Thread: How make function that can take std::vector's of varying dimensions?

I want to make a function that takes std::vector as a parameter but without specifying the number of dimensions. Then it will check how many dimensions inside the function and use loops to get all the data out. How would i do this? Do I have to do something like:

Code:

public void getData(std::vector *vec)
{
   //do work here
}

Would that even work? is there a better way?

A std::vector has no such thing as "dimensions." It is always one dimensional. Are you talking about vectors of vectors?

Originally Posted by brewbuck

A std::vector has no such thing as "dimensions." It is always one dimensional. Are you talking about vectors of vectors?

Whoops. Yep, sorry about the confusion. I mean I'd like to be able to do something like:

Code:

//We've got some variables
<std::vector<std::vector<int> > nums;
<std::vector<std::vector<std::vector<int> > > otherNums;

//Put them both into the function
getData( nums );
getData( otherNums );

(And this assumes that getData(...) can be used for ANY
depth of vectors of vectors, so no overloading of the function would solve it)

CornedBee, is there a reason for the non-const reference in the second version but the reference to const in the first? Why not make them all const or all not const?

Originally Posted by CornedBee

Code:

template <typename T>
void getData(const std::vector<T> &data)
{
  // This is the final recursion. Do something with the data here.
}

template <typename T>
void getData(const std::vector< std::vector<T> > &data)
{
  // This unwraps the vectors.
  for(typename std::vector< std::vector<T> >::const_iterator it = data.begin();
    it != data.end(); ++it)
  {
    getData(*it);
  }
}

I apologize for taking your time and really appreciate all your help. I'm a little confused.

How would that work if it was passed a vector of a vector of a vector of some object? (In other words: <std::vector<std::vector<std::vector<int> > >) Or four levels deep, etc?

I want a function that can handle anywhere from 1..n levels of vectors without knowing beforehand. That's the code that confuses me a bit (I can write it in Java but am having trouble with C++, sorry).

The compiler tries to figure out which of the two should be used for std::vector<std::vector<std::vector<int> > >. It can either make T = std::vector<std::vector<int> > and use the first, or it can make T = std::vector<int> and use the second.

Apparently the rules require that it choose the second because the type used for the argument is closer to the actual parameter type of the second function.

From there, it calls getData for each element in the outer vector. This means a std::vector<std::vector<int> > is being passed to getData. Again, the compiler can choose between T = std::vector<int> (for the first one) or T = int (for the second one). Again, we are passing a std::vector<std::vector<T> > so that is a closer match, so the second version is used.

Each element of that vector is then sent to getData, but those would each have the type std::vector<int>. Since that type doesn't match the second function, the first function is used.

Originally Posted by 6tr6tr

I apologize for taking your time and really appreciate all your help. I'm a little confused.

How would that work if it was passed a vector of a vector of a vector of some object? (In other words: <std::vector<std::vector<std::vector<int> > >) Or four levels deep, etc?

I want a function that can handle anywhere from 1..n levels of vectors without knowing beforehand. That's the code that confuses me a bit (I can write it in Java but am having trouble with C++, sorry).

I haven't tried this, but I think it should work for n levels because for:

Code:

const std::vector< const std::vector<T> >

T can be anything, including another const std::vector<T>, then that T could be another const std::vector...
When the loop calls getData() it calls the first version if it's the inner-most level, otherwise it calls itself.

Originally Posted by CornedBee

Yeah, there is: confusion.
I'll edit the post.

HELP! I wrote the code you gave an it won't compile. For some reason it says that "GetData" has already been defined! Why won't it let me overload the function?

What are you doing inside getData? If you're changing data you need to de-constify it. This simple example works for me since the data doesn't change:

Code:

#include <iostream>
#include <vector>

template <typename T>
void getData(const std::vector<T> &data)
{
  for(typename std::vector<T>::const_iterator it = data.begin();
    it != data.end(); ++it)
  {
      std::cout << (*it) << ' ';
  }
  std::cout << '\n';
}

template <typename T>
void getData(const std::vector< std::vector<T> > &data)
{
  // This unwraps the vectors.
  for(typename std::vector< std::vector<T> >::const_iterator it = data.begin();
    it != data.end(); ++it)
  {
    getData(*it);
  }
}

int main()
{
    std::vector<std::vector<std::vector<int> > > threeD(2,
                         std::vector<std::vector<int> >(3,
                                       std::vector<int>(4, 7)));
    getData(threeD);
}

Originally Posted by 6tr6tr

Really? it won't compile for me in MS Visual C++. It says:

'error C2995' : 'GetData' : template function has already been defined.

EDIT: And when I compile your code, I get the same error! Help, why isn't this working?

Probably because the compiler sucks.