Variable Array-Dimension zur Laufzeit C++

Question

Ich versuche ein Programm zu erstellen, das einige Daten aus 2 Dateien lesen kann. Die erste Datei ist der Header, der die Datenstruktur (Dimensionen, Datentyp, Extents usw.) beschreibt, und die zweite sind die Rohdaten.

Um verschiedene Datentypen zur Laufzeit zu behandeln, habe ich eine Vorlagenklasse erstellt, die als Container für die Daten verwendet wird. Abhängig vom Datentyp, der im Header gelesen wird, erstelle ich eine spezielle Klasse des Containers, um die Daten zu speichern.

Allerdings habe ich jetzt ein anderes Problem. Wie kann ich zur Laufzeit ein dynamisches mehrdimensionales Array erstellen?

Ich dachte zuerst, es auf altmodische Art und Weise zu tun, und legte einen Zeiger in die Speicherklasse, und einige Schleifen (= zur Dimensionalität) erstellen, um ein neues Array (neues Array [Größe]) zu erstellen. Aber ich denke nicht, dass es eine sehr saubere Art ist, es zu tun.

Ich dachte auch über Stapel std :: vector, aber ich weiß nicht die Dimensionalität vor der Laufzeit.

Dann dachte ich Boost zu verwenden, um ein multi_array zu erstellen, und resize() zu verwenden, um den Umfang meines Arrays zur Laufzeit zu aktualisieren, aber es ist erforderlich, die Dimension beim Erstellen des Arrays zu kennen (multi_array < type, dim> variable) . Da ich in all meiner Klasse (für zukünftige Verarbeitung, etc ...) darauf zugreifen möchte, sehe ich nicht, wie ich das in meiner Klasse einfügen soll, da ich nur die Dimensionalität zur Laufzeit kenne. Ist es möglich, einen Basiszeiger von multi_array in meiner Klasse zu erstellen und später zu deklarieren (wenn ich die benötigte Dimension kenne)?

Oder gibt es einen anderen Weg, dies zu tun? Mein Ziel ist es, zur Laufzeit ein multidimensionales Array zu erstellen, auf das ich in meiner Klasse zugreifen kann.

Vielen Dank.

Bearbeiten: Die meisten der Themen, die ich darüber gelesen habe, sind für feste dimensionale Array, mit einer variablen Größe. Aber in meinem Fall variiert auch die Dimension.

Update: Ihre Antwort inspirierte mich eine Idee Hugues. Ich habe bereits eine Template-Klasse, um die Daten zu lesen, aber für den Moment braucht es nur als Parameter den Datentyp. Ich denke, die dimensionnality ihm hinzufügen und erstellen Sie eine Klasse wie folgt aus: storageClass< data_type, data_dimension > myStorage(filename, data_extent, data_endian, data_encoding);

Auf diese Weise kann ich auch die dimensionnality der Datenvorlage, und erstellen Sie eine multidimensionnal Array (mit boost zum Beispiel). Ich werde Sie wissen lassen, ob es funktioniert hat. Danke.

Update 2: Offenbar ist es nicht möglich, da Templates konstanten Ausdruck erwarten. Ich kann die Variable 'dimension' nicht übergeben (auch wenn es in diesem Fall ein fester Wert ist, aber zur Kompilierzeit nicht definiert ist). Also ich denke, meine beste Option ist ein variadic Getter in der benutzerdefinierten Speicherklasse erstellen und den entsprechenden Wert zurückgeben. Das Problem besteht darin, dass eine variadische Methode das Parsen der Argumente beinhaltet, und da dies eine Methode ist, die häufig aufgerufen wird, ist sie nicht optimal.

Answer 1

Es ist wahrscheinlich notwendig, eine benutzerdefinierte Klasse zu erstellen. Eine Idee ist es Haupt Mitglieder m_dims und m_data enthält zwei haben:

#include <vector> 
#include <cassert> 

using std::size_t; 

template<typename T> class MultiArray { 
public: 
    MultiArray(const std::vector<int>& dims) 
     : m_dims(dims), m_data(product(m_dims)) { } 
    const std::vector<int>& dims() const { return m_dims; } 
    const T& operator[](const std::vector<int>& indices) const { 
     return m_data[index(indices)]; 
    } 
    T& operator[](const std::vector<int>& indices) { 
     return m_data[index(indices)]; 
    } 
private: 
    std::vector<int> m_dims; 
    std::vector<T> m_data; 
    static size_t product(const std::vector<int>& dims) { 
     size_t result = 1; 
     for (size_t i = 0; i<dims.size(); ++i) result *= size_t(dims[i]); 
     return result; 
    } 
    size_t index(const std::vector<int>& indices) const { 
     size_t v = 0; 
     for (size_t i = 0; i<m_dims.size(); ++i) { 
      assert(indices[i]>=0 && indices[i]<m_dims[i]); 
      if (i) v *= size_t(m_dims[i]); 
      v += size_t(indices[i]); 
     } 
     return v; 
    } 
}; 

int main() { 
    MultiArray<float> ar{std::vector<int>{2, 3}}; 
    ar[std::vector<int>{0, 0}] = 1.f; 
    ar[std::vector<int>{0, 1}] = 2.f; 
    ar[std::vector<int>{0, 2}] = 3.f; 
    ar[std::vector<int>{1, 0}] = 4.f; 
    ar[std::vector<int>{1, 1}] = 5.f; 
    ar[std::vector<int>{1, 2}] = 6.f; 
} 

Siehe Code in http://coliru.stacked-crooked.com/a/92e597d4769f9cad