Ändern der Größe einer dynamisch zugewiesenen Matrix

Question

Der Versuch, die Formmatrix dynamisch zu ändern. Dies ist Teil eines Zeichenprogramms, in dem _capacity die Anzahl der in einem Rahmen gezeichneten Formen ist.

Erhalten Sie den Fehler in der neuen Form über _capacity Sprichwort Ausdruck muss einen konstanten Wert haben.

void ShapeStore::Grow(int minimumCapacity) 
{ 
_capacity = max (minimumCapacity, 2 * _capacity); 
if (_capacity) 
    { 

    Shape ***newData = new Shape[_frames][_capacity]; //figure out this 
    int i; 

    for (int k = 0; k < _frames; k++) 
     for (i=0;i<_count;i++) 
      newData[k][i] = _data[k][i]; 

    delete [] _data; 
    _data = newData; 
    } //*/ 
} 

Answer 1

Wenn Inhalte von newData Zugriff, es ist nicht newData[k][i] sondern (*newData)[k][i]

newData ist kein zweidimensionales Feld, dann ist es ein Zeiger auf eine zweidimensionale Anordnung. Faustregel ist jeweils * zum Zeitpunkt der Deklaration sollte durch eine *, -> oder [] im Einsatz übereinstimmen.

Answer 2

Shape ***newData = new Shape[_frames][_capacity]; //figure out this 

Dies tut nicht, was Sie denken, dass es tut. Es weist nur ein Array von Zeigern auf Arrays im freien Speicher zu. Unter der Annahme, dass _capacity eine Konstante ist, ist jeder Zeiger im Array ein Zeiger auf ein anderes festes Array, das genau _capacity Instanzen von Shape enthält. Hier ist ein Bild:

 
       index 
      +-----------+ 
newData --> |  0  | (pointer to a fixed array of _capacity instances of Shape) 
      +-----------+ 
      |  1  | (pointer to a fixed array of _capacity instances of Shape) 
      +-----------+ 
      |  2  | (pointer to a fixed array of _capacity instances of Shape) 
      +-----------+ 
      |   | 

       ....... 

      |   | 
      +-----------+ 
      | _frames-1 | (pointer to a fixed array of _capacity instances of Shape) 
      +-----------+ 
(This is the only thing that is actually allocated) 

Der Ausdruck new Shape[_frames][_capacity] nicht genügend Speicher zuweisen, um tatsächlich _frame*_capacity Instanzen Shape halten. Da jeder Zeiger im Array auf ein anderes Array von festen Größe zeigt, beschwert sich der Compiler über die nicht konstante _capacity in Ihrem Code-Snippet.

Anstatt das schmerzlich verwirrend Shape*** und new[_frames][_capacity] Geschäft zu verwenden, verwenden Sie ein std::vector eine lineare Anordnung von Shape s zu halten, dann ein Adressierungsschema verwenden, um Zeilen und Spalten zu emulieren, wie folgt aus:

// Exposition only 

std::vector<Shape> data; 

void ResizeMatrix(std::vector<Shape>& data, int frames, int capacity) 
{ 
    data.resize(frames * capacity); 
} 

// Populate data with Shapes 

void IndexMatrix(int capacity_index, int frame_index, int capacity) 
{ 
    Shape& aShape = data[capacity_index + (capacity * frame_index)]; 
    // Do something with it 
}