如何将向量的向量传递到期望指向指针的（原始）指针的函数中

Question

I have a function that accepts a pointer to pointer to double:

void Foo(double ** m);  // expects a 3x3 matrix of doubles

Is it somehow possible, with appropriate casting and whatnot, to pass into this function either a std::vector of std::vectors of double or else an std::array of std::arrays of double? If so, can someone please explain how?

std::vector<std::vector<double>> v(3, std::vector<double>(3));
std::array<std::array<double, 3>, 3> a;

If the function accepted only a pointer to double, this would be possible. (via either v.data() or a.data()). But the pointer to pointer in the function interface makes me think that such a conversion may not be possible.

Thank you,

Aaron

Answer 1

You have to build the array, by example:

double* a[3] = {v[0].data(), v[1].data(), v[2].data()};
Foo(a);

Answer 2

You can't. double** does not point to two-dimensional data. It points to an array of pointers to other arrays. Even if you could find a cast that compiled, the data layouts are simply incompatible.

Answer 3

Try the following

double **p = new double *[v.size()];

for ( size_t i = 0; i < v.size(); i++ ) p[i] = v[i].data();

Foo( p );

delete [] p;

Here is a demonstrative program

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>


int main()
{
    std::vector<std::vector<double>> v =
    {
        { 1.1, 2.2, 3.3 },
        { 4.4, 5.5, 6.6 },
        { 7.7, 8.8, 9.9 }
    };

    double **p = new double *[v.size()];

    double * ( std::vector<double>::*fn )() noexcept = &std::vector<double>::data;

    std::transform( v.begin(), v.end(), p, std::mem_fn( fn ) );

    for ( size_t i = 0; i < v.size(); i++ )
    {
        for ( size_t j = 0; j < v.size(); j++ ) std::cout << p[i][j] << ' ';
        std::cout << std::endl;
    }

    delete [] p;
}

The output is

1.1 2.2 3.3 
4.4 5.5 6.6 
7.7 8.8 9.9 

Answer 4

If it's just that one function that's mismatched, and it isn't called in an inner loop somewhere, (and you can't change its signature, like its part of an API you can't change): the only solution I can think of is to unbox your vector. Iterate over your vector and pull out all of the data and put it into an array and then feed that into your function.

Obviously, that's nasty in several ways, so if you have another option (notably, overloading the function to accept vector , then that's probably a better choice.

Answer 5

I think there is a design problem. Are you sure that void Foo(double ** m); expects a 3x3 matrix of doubles? If yes, than you need some wrapper function to convert vector<vector<double> > to double** . Any way it's the wrong approach.

Answer 6

template<class T>
std::vector<T*> make_jagged_array( std::vector<std::vector<T>>& vec ) {
  std::vector<T*> retval;
  retval.reserve(vec.size());
  for(auto&& v:vec)
    retval.push_back(v.data());
  return retval;
}

will convert a vector<vector<X>> into a vector<X*> , and vector<X*>.data() returns you your X** you need.

Doing this for n dimensions would be amusing.