ein Array von struct dynamisch

Question

I haben folgende Struktur:

struct Vertex { 
    Vertex(float px, float py, float pz, 
      float nx, float ny, float nz, 
      float tx, float ty) : position(px, py, pz), 
           normals(nx, ny, nz), 
           texCoords(tx, ty) {} 
    XMFLOAT3 position; 
    XMFLOAT3 normals; 
    XMFLOAT2 texCoords; 
}; 

und ich brauche einen Array aus, dass bei einigen Vektoren zu füllen:

std::vector<XMFLOAT3> positions; 
std::vector<XMFLOAT3> normals; 
std::vector<XMFLOAT2> texCoords; 

Die Länge des Arrays ist gegeben durch

int numVertices; 

Ich möchte das Array struct Vertex mit den angegebenen Vektoren füllen. Wie kann ich das machen? Ich habe versucht, das Array auf diese Weise zu initialisieren:

Vertex points[numVertices]; 

aber, dass var nicht einen konstanten Wert hat.

Vielen Dank für Ihre Hilfe.

Answer 1

std::vector ist die beste Option, um ein dynamisches Array zu erstellen.

1. Es kümmert sich um die Speicherverwaltung für Sie.
2. Sie können auf den Inhalt des Arrays zugreifen, indem Sie std::vector::data, std::vector::operator[], std::vector::iterator verwenden.
3. Sie können jedes Element einer std::vector mit einer Range-for-Schleife verarbeiten.

Statt

Vertex points[numVertices]; 

Verwendung

std::vector<Vertex> points(numVertices); 

Answer 2

Wenn Sie rohe Arrays verwenden müssen, können Sie dies versuchen. Unter der Annahme, XMFLOAT3 ist XMFLOAT2 etwas wie folgt:

struct XMFLOAT3 { 
    XMFLOAT3(float x, float y, float z) : _x(x), _y(y), _z(z) {}; 
    float _x; 
    float _y; 
    float _z; 
}; 

struct XMFLOAT2 { 
    XMFLOAT2(float x, float y) : _x(x), _y(y) {}; 
    float _x; 
    float _y; 
}; 

definieren eine Funktion init Vertex-Array initialisiert durch dynamisches Zuweisen und Initialisieren der Elemente wie:

Vertex ** 
initVertex(int numVertices) 
{ 
    Vertex **points = new Vertex *[numVertices]; 
    for (int i = 0; i < numVertices; ++i) { 
     points[i] = new Vertex(positions[i]._x, positions[i]._y, positions[i]._x, 
       normals[i]._x, normals[i]._y, normals[i]._z, 
       texCoords[i]._x, texCoords[i]._y); 
    } 
    return points; 
} 

Sie Vertex **points = initVertex(numVertices) und dereferenzieren jedes Element verwenden können.

Wenn Sie müssen Vertex *points dann können Sie diese Funktion verwenden, um die initialisierte Array von Eckpunkten zu erstellen:

Vertex * 
initVertex2(int numVertices) 
{ 
    char *points_buf = new char[sizeof(Vertex) * numVertices]; 
    Vertex *points = reinterpret_cast<Vertex *>(points_buf); 
    for (int i = 0; i < numVertices; ++i) { 
     new (points_buf + i * sizeof(Vertex)) 
       Vertex(positions[i]._x, positions[i]._y, positions[i]._x, 
       normals[i]._x, normals[i]._y, normals[i]._z, 
       texCoords[i]._x, texCoords[i]._y); 
    } 
    return points; 
} 

Und es Vertex *points = initVertex2(numVertices) nennen und Array-Indizierung verwenden, um jedes Element zugreifen.