如何转换向量 <vector<int> &gt; int **而无需重建数组？

Question

I don't like to use pointers too much and I'm always using stl tools. I've gotten into this situation where I need to pass a int** to a third_party function that needs to work with a 2d array of ints. I have written the following function that creates a vector of int*s to do the job. My question is that is it safe to do this assuming that the third_party function does not change the structure of the array and just accesses the data entries. Is there a better way to do this?

Here is the function def:

void ConvertVectorVectorToIntStarStar(const std::vector<std::vector<int> >& v,vector<int*>* a) {
  assert(a);
  int n = v.size();
  a->resize(n);
  for(int i = 0; i < n; ++i)
    (*a)[i] = (int*)(&v[i][0]);
}

and this is the usage:

  vector<int*> p;
  ConvertVectorVectorToIntStarStar(v, &p);
  int** a = &p[0];
  third_party_function(a);

Answer 1

How to convert a vector<vector<int>> to int**

You can't simply convert it.

The internal layout of a vector of vector<int> is just mind-bogglingly incompatible with an array of int* . :-)

Here are your types:

vector<vector<int>> v{{ 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } };
int (*a)[] = { new int[3], new int[3], new int[3] };

The first thing you'll notice is that a is an int (*)[] rather than an int** . When you use a it'll decay to an int** ; an int[][] would not do this .

Let's get our first-level pointers:

vector<int>* ptr1 = &v[0];
int**        ptr2 = &a[0];

Now let's look at the storage:

• ptr1[0] is a vector<int>
• ptr2[0] is a int*

Clearly, these are not in any way the same sort of thing. Without even needing to go any further, the memory layout is already different. This means you cannot just "get" an int** to the vector's data.

---

However , if you don't mind constructing the outermost "indexing" array from scratch, then your approach is basically sound. It's just not the zero-step process you seem to be after.

---

Instead of all this, my suggestion would be wrapping a vector<int> (with length Width × Height) with 2D-index access semantics. You would then be able to play with an int* to the entire data buffer if you wished.

With thanks to Freenode ##c++ :

template<typename T>
struct matrix
{
   matrix(unsigned m, unsigned n)
      : m(m), n(n), vs(m*n)
   {}

   T& operator()(unsigned i, unsigned j)
   {
      return vs[i + m * j];
   }

private:
   unsigned m, n;
   std::vector<T> vs;
};

/* column-major/opengl: vs[i + m * j], row-major/c++: vs[n * i + j] */

Answer 2

If you need the cast, something isn't right:

(*a)[i] = (int*)(&v[i][0]);

I guess this should really read

(*a)[i] = const_cast<int*>(v[i].data());

Otherwise the code looks OK and it should work: the elements in a std::vector<T> are contiguous.

Answer 3

Instead of the current code …

void ConvertVectorVectorToIntStarStar(const std::vector<std::vector<int> >& v,vector<int*>* a) {
  assert(a);
  int n = v.size();
  a->resize(n);
  for(int i = 0; i < n; ++i)
    (*a)[i] = (int*)(&v[i][0]);
}

I suggest that you do …

vector<int*> IntStarStarFrom( std::vector<std::vector<int>>& v)
{
    int const n = static_cast<int>( v.size() );
    assert( n > 0 );
    vector<int*> a( n );

    for(int i = 0; i < n; ++i)
    {
        assert( v[i].size() > 0 );
        a[i] = &v[i][0];
    }
    return std::move( a );
}

Disclaimer: off-the cuff code, not touched by compiler's hands.

The assertions express the relevant safety concerns.

A vector's buffer is guaranteed contiguous, but IIRC it's Undefined Behavior to index the vector when its size is 0.

The usage code, reworked to use the suggested function replacement:

vector<int*> p = IntStarStarFrom( v );
int** const a = &p[0];
third_party_function( a );

Or as Mark Ransom remarked in a comment, you can now do this in a single line of code:

third_party_function(IntStarStarFrom(v).data());

Answer 4

std::vector<std::vector<int> > vt;
// some code with vt..

std::vector<int *> vtp;
for (const std::vector<int> &vtr : vt)
    vtp.push_back(const_cast<int *>(vtr.data()));

I haven't tested but I think I works well