Question

Suppose I have the following simple struct:

struct Vector3
{
    double x;
    double y;
    double z;
};

and I create a list of vertices:

std::vector<Vector3> verticesList;

In addition to this I need to use a third-party library. The library has a function with the following signature:

typedef double[3] Real3;
external void createMesh(const Real3* vertices, const size_t verticesCount);

What is the best way to convert verticesList into something which could be passed into createMesh() as the vertices parameter?

At the moment I use the following approach:

static const size_t MAX_VERTICES = 1024;

if (verticesList.size() > MAX_VERTICES)
    throw std::exception("Number of vertices is too big");

Real3 rawVertices[MAX_VERTICES];
for (size_t vertexInd = 0; vertexInd < verticesList.size(); ++vertexInd)
{
    const Vector3& vertex = verticesList[vertexInd];

    rawVertices[vertexInd][0] = vertex.x;
    rawVertices[vertexInd][1] = vertex.y;
    rawVertices[vertexInd][2] = vertex.z;
}

createMesh(rawVertices, verticesList.size());

But surely it is not the best way to solve the issue.

Answer 1

That is one proper way of doing it. There are also some other ways…

The type Vector3 is layout compatible with the type Real3, the implication of this is that you can force casting a pointer to one type to a pointer of the other:

createMesh( reinterpret_cast<Real3*>(&verticesList[0]), vertices.size() );

Other alternative, as Rook mentions, to remove the loop is using memcpy, since the types are POD:

Real3 rawVertices[MAX_VERTICES];
std::memcpy( rawVertices, &verticesList[0], 
             vertices.size()*sizeof verticesList[0] );

This is more concise, and probably more efficient, but it still is copying the whole container.

---

I believe that the standard does guarantee this behavior (at least C++11), two standard layout and standard compatible types have the same memory layout (duh?), and §9.2p19 states:

A pointer to a standard-layout struct object, suitably converted using a reinterpret_cast, points to its initial member (or if that member is a bit-field, then to the unit in which it resides) and vice versa.

This guarantee technically means something slightly different than what I claimed before: you can reinterpret_cast<double*>(&verticesList[0]) points to verticesList[0].x. But it also implies that the conversion from double* to Real3 pointer through reinterpret cast will also be fine.