Größe des dynamisch zugewiesenen Arrays finden

Question

Warum ist es nicht möglich, die Länge eines Puffers auf diese Weise zu erhalten.

AType * pArr = new AType[nVariable]; 

Wenn das gleiche Array

delete [] pArr; 

die Laufzeit freigegeben wird wissen muss, wie viel freizugeben. Gibt es eine Möglichkeit, auf die Länge zuzugreifen, bevor das Array gelöscht wird? Wenn nein, warum wird keine solche API bereitgestellt, die die Länge abruft?

Answer 1

Gibt es eine Möglichkeit, auf die Länge zuzugreifen, bevor das Array gelöscht wird?

Nein, es gibt keine Möglichkeit, das festzustellen.
Der Standard erfordert nicht, dass sich die Implementierung an die Spezifizierung der Anzahl der Elemente erinnert, die über new angefordert werden.
Die Implementierung kann einfach bestimmte Bitmuster am Ende zugewiesener Speicherblöcke einfügen, statt sich die Anzahl der Elemente zu merken, und könnte einfach nach dem Muster suchen, während es den Speicher freigibt.
Kurz gesagt, es ist nur eine Erläuterung Detail.

---

Auf einer Seite zur Kenntnis, gibt es 2 Möglichkeiten praktisch, dieses Problem zu überwinden:

1. Sie können einfache Nutzung ein std::vector, die Sie Elementfunktionen wie size() oder
2. Sie einfach liefert kann Führen Sie die Buchhaltung selbst aus.

newatleast weist genügend Speicher so viel wie Sie verlangten.
Sie wissen bereits, wie viel Speicher Sie angefordert haben, damit Sie die Länge leicht berechnen können. Sie können die Größe jedes Artikels mit sizeof finden.

Total memory requested/Memory required for 1 item = No of Items 

Answer 2

Die Laufzeit weiß, wie viel zugeteilt wurde. Solche Details sind jedoch compilerspezifisch, so dass Sie keine plattformübergreifende Möglichkeit haben, damit umzugehen.

Wenn Sie die gleiche Funktionalität wie und in der Lage sein, die Größe verfolgen Sie eine std :: vector verwenden könnte wie folgt:

std::vector<AType> pArr(nVariable); 

Dies hat den zusätzlichen Vorteil, auch mit RAII.

Answer 3

Nein, nicht wirklich. Zumindest nicht in einer plattformunabhängigen, definierten Weise.

Die meisten Implementierungen speichern jedoch die Größe eines dynamisch zugewiesenen Arrays vor dem eigentlichen Array.

Answer 4

Der Operator delete muss die Größe nicht kennen, um den zugewiesenen Speicher freizugeben, genauso wie der Systemaufruf free nicht funktioniert. Dies liegt daran, dass dieses Problem dem Betriebssystem und nicht dem Compilers-Laufzeitsystem überlassen wird.

Answer 5

Die Laufzeitumgebung muss die gleiche Menge freigeben, wie sie zugewiesen wurde, und sie behält dies in gewisser Weise (normalerweise sehr indirekt) bei. Aber gibt es keine zuverlässige Möglichkeit, von der Menge zu Elemente zugewiesen zu bekommen: die Menge zugewiesen kann nicht weniger sein als die Anzahl der Elemente mal die Größe jedes Elements, aber es wird oft mehr sein. Ausrichtung Überlegungen, zum Beispiel bedeuten, dass new char[5] und new char[8] oft die gleiche Menge an Speicher zuweisen, und es gibt verschiedene Zuordnungsstrategien, die erheblich mehr Speicher zugeordnet werden kann, was unbedingt erforderlich ist.

Answer 6

warum nicht ein bisschen mehr Informationen wie folgt aus:

template <typename T> class AType 
{ 
public: 

    AType(size_t s) : data(0) 
    { 
     a_size = s; 
     data = new T[s]; 
    } 
    ~AType() { 
     if (data != nullptr) 
      delete [] data; 
    } 

    size_t getSize() const 
    { 
     return a_size * sizeof(T); 
    } 

private: 
    size_t a_size; 
    T* data; 
}; 

Answer 7

Es gibt keine tragbare Art und Weise in C++ die Größe eines dynamisch zugewiesenen Array aus dem rohen Zeiger zu erhalten.

Unter MSVC und WIN32 können Sie die Größe des zugewiesenen Blocks mit der Funktion _msize (void *) abrufen.

siehe https://msdn.microsoft.com/en-us/library/z2s077bc.aspx für weitere Details.