How properly get data out of vectors of templates?

How would I do this?

I want to be able to handle vectors of many different types of data and vectors that can contain any number of other vectors of data.

Currently, I have a templated function that handles vectors of vectors of <typename T> (which could be anything from int to vectors of something else). As well, I have specialized/overloaded functions to handle the single-level vectors of data (e.g. vector<string>). So the templated function only handles vectors of vectors of....whatever and then as it loops down to the last vector of data, it "passes" it off to the overloaded specialized functions.

My problem is that the way I'm currently doing this creates extra uselss objects and thus isn't clean/efficient. I can't seem to figure out how to properly narrow down the vectors.

Code:

---

vector<int>* convert(SomeClass obj)
{
        //Return vector
        vector<int>* retVector = new vector<int>();
       
        //Get the values
        int* values = ...elided...
       
        //Put into vector
        retVector->assign( values, values + length );
       
        //Clean up
        delete values;
       
        return retVector;
}

vector<vector<int> >* convert(SomeClass obj, vector<int> spec)
{
        //Length of array
        int length = GetArrayLength( obj );
       
        //Return vector
        vector<vector<int> >* retVector = new vector<vector<int> >();
       
        //Get all inner arrays
        for ( int i = 0; i < length; i++ )
        {
                //Create an inner vector
                vector<int>* innerVector;
               
                //Now get the element of the outer SomeOtherClass Array
                SomeOtherClass otherObj = ...elided...
               
                //Set data
                innerVector = convert( env, otherObj );
               
                //Add it to the outer vector
                retVector->push_back( *innerVector );
               
                //Clean up
                delete innerVector;
        }
       
        return retVector;
}

template <typename T>
vector<vector<T> >* convert(SomeClass obj, vector<T> spec)
{
        //Length of array
        int length = GetArrayLength( obj );
       
        //Return array
        vector<vector<T> >* T = new vector<vector<T> >();
       
        //Set all inner arrays
        for ( int i = 0; i < length; i++ )
        {
                //Create an inner vector
                vector<T>* innerVector;
               
                //use this to narrow down to eventually the specialized function
                T subSpec;
               
                //Now get the element
                SomeOtherClass otherObj = ...elided...
               
                //Convert inner data
                innerVector = convert( env, otherObj, subSpec );
               
                //Add it to the outer vector
                T->push_back( *innerVector );
               
                //Clean up refs
                delete innerVector;
        }
       
        return T;
}

int main()
{
        vector<vector<string> >* ret = convert( env, o2, vector<string>() );
       
        //Print out results
        for ( vector<vector<string> >::const_iterator it = ret->begin(); it != ret->end(); ++it )
        {
                vector<string> vec = *it;
                for ( vector<string>::const_iterator vecIt = vec.begin(); vecIt != vec.end(); ++ivecIt )
                {
                        printf( ( ( *vecIt ) + "\n" ).c_str() );
                }
        }
}

---

Way too much going on there.

Code:

---

template <typename T>
void drill_down(const vector<T> &vec_p)
{
    for(typename vector<T>::const_iterator i = vec_p.begin(), end = vec_p.end(); i != end; ++i)
        drill_down(*i);
}

template <typename T>
void drill_down(const T &elem_p)
{
    // Base case
}

---

Quote:

---

Originally Posted by brewbuck

Way too much going on there.

Code:

---

template <typename T>
void drill_down(const vector<T> &vec_p)
{
    for(typename vector<T>::const_iterator i = vec_p.begin(), end = vec_p.end(); i != end; ++i)
        drill_down(*i);
}

template <typename T>
void drill_down(const T &elem_p)
{
    // Base case
}

---

---

Thanks for the reply! :) When i try the above, it only sends it to the first &elem_p function.

Code:

---

vector<vector<vector<string> > > vec;

//This sends it to element function
drill_down( &vec );

//All of these can't find matching function
//drill_down<vector<vector<vector<string> > > >( &vec );
//drill_down<vector<vector<string> > >( &vec );

---

You're passing a pointer, which is not what the function expects. Get rid of that '&'

Quote:

---

Originally Posted by brewbuck

You're passing a pointer, which is not what the function expects. Get rid of that '&'

---

Thanks but it still didn't work until I changed the element function to be a specialized one (in this case for string) and then it can find it properly. Thanks for all your help i think this is going to lead to a nice solution to my problem! :)