Bestimmen Sie die Größe eines C++ - Arrays programmgesteuert?

Diese Frage wurde inspiriert durch eine ähnliche Frage: Wie funktioniert delete[] "weiß" die Größe des Operanden-array?

Meine Frage ist ein wenig anders: gibt es eine Möglichkeit, bestimmen die Größe eines C++ - Arrays programmgesteuert? Und wenn nicht, warum? Jede Funktion, die ich gesehen habe, dass dauert ebenfalls ein Feld erfordert einen integer-parameter, um ihm die Größe. Aber wie der verlinkte Frage darauf hingewiesen, delete[] müssen wissen, die Größe des Speichers freigegeben werden.

Betrachten dieser C++ - code:

int* arr = new int[256];
printf("Size of arr: %d\n", sizeof(arr));

Diese Drucke "Size of arr: 4", die nur die Größe des Zeigers. Es wäre schön, eine Funktion zu haben, die druckt 256, aber ich glaube nicht, dass man existiert in C++. (Nochmals, die Frage ist, warum es nicht existiert.)

Klärung: ich weiß, dass wenn ich deklariert das array auf dem stack statt dem heap (d.h. "int arr[256];"), dass die sizeof operator zurückkehren würde, 1024 (array length * sizeof(int)).

  • Eigentlich, wenn Sie zugewiesen das array auf dem stack der sizeof-operator zurückkehren würde, 1024 -- die 256 (Anzahl der Elemente) * 4 (die Größe eines einzelnen Elements). (sizeof(arr)/sizeof(arr[0])) geben würde, das Ergebnis 256.
  • danke, habe ich übersehen, weil ich war eigentlich mit char[] in meinem test-code (und sizeof(char) == 1)
  • Es ist zwar nur hypotethical - da funktioniert es nicht - ich habe darauf hinweisen, dass Sie geschrieben haben soll printf("Size of arr: %d\n", sizeof(*arr)); statt printf("Size of arr: %d\n", sizeof(*arr)); denn Sie wollen zum abrufen der Größe des dereferenzierter Zeiger.
InformationsquelleAutor Kip | 2008-10-13
  1. 65

    delete [] kennt die Größe reserviert wurde. Jedoch, dass das wissen befindet sich in der Laufzeit oder im Betriebssystem Speicher-manager, was bedeutet, dass es nicht verfügbar ist für den compiler während der Kompilierung. Und sizeof() ist keine wirkliche Funktion, es ist tatsächlich ausgewertet, um eine Konstante vom compiler, das ist etwas, das es nicht für dynamisch zugewiesenen arrays, deren Größe nicht bekannt ist, während der Kompilierung.

    Auch, betrachten Sie dieses Beispiel:

    
int *arr = new int[256];
int *p = &arr[100];
printf("Size: %d\n", sizeof(p));

    Wie würde der compiler wissen, was die Größe der p ist? Die Wurzel des Problems ist, dass arrays in C und C++ sind nicht die erste-Klasse-Objekte. Sie zerfallen zu Zeigern, und es gibt keine Möglichkeit für den compiler oder das Programm selbst zu wissen, ob ein Zeiger auf den Anfang der einen Teil des Arbeitsspeichers durch new oder auf ein einzelnes Objekt oder einen Ort in der Mitte ein Stück des Arbeitsspeichers durch new.

    Ein Grund dafür ist, dass C und C++ lassen Sie den Speicher management für den Programmierer und dem Betriebssystem, das ist auch der Grund, warum Sie nicht haben die garbage collection. Umsetzung von new und delete ist nicht Teil der C++ - standard, weil C++ verwendet werden soll, die auf einer Vielzahl von Plattformen, die möglicherweise verwalten Sie Ihr Gedächtnis in sehr unterschiedlicher Weise. Kann es möglich sein zu lassen, C++ verfolgen Sie alle zugeordneten arrays und Ihre Größen, wenn Sie schreiben einen word-Prozessor, der für eine windows-Kiste läuft auf der neuesten Intel-CPU, aber kann es völlig undurchführbar, wenn Sie schreiben eine embedded-system läuft auf einem DSP.

    • Gute Erklärung Dima.
    • Es gibt absolut arrays in C++. Howe, sonst würde Sie erklären, warum mit diesem "char x[4]; size_t sz = sizeof(x);" dass die 'sz' wird zugewiesen 4?
    • Kevin, x ist nicht wirklich ein array. Es ist ein Zeiger auf einen Speicherblock,, die passiert werden die auf dem stack. Und da es vergeben war statisch auf dem stack, der compiler kennt die Größe. Wenn Sie x auf eine Funktion, er würde nicht wissen, seine Größe. Arrays in C oder C++ nicht die erste-Klasse-Objekte.
    • Fantastische Erklärung. 🙂
    • Nur als Anmerkung: sizeof ist ein operator und keine Funktion ist, wie bereits das poster, dass es nicht eine echte Funktion.
    • Dima, es gibt absolut arrays. arrays unterscheiden sich von Zeigern. leider, viele Lehrer verwechseln Sie es aus und sagen Sie Ihren Schülern, dass Sie "nur" Hinweise. NÖ, sind Sie nicht. wie sonst erklären Sie sich, dass diese: char const**s = &"bar"; nicht kompilieren? [...]
    • (wenn Sie sagen, dass die "bar" ist ein Zeiger auf das Zeichen-array "bar", die ist "nur" ein Zeiger?). und die Tatsache, dass arrays nicht erste-Klasse-Objekte bedeutet nicht, dass es "keine echten arrays". Funktionen sind nicht erste Klasse zu. so haben Sie nicht "reelle Funktionen" in c++?
    • litb, der Grund, char const **s = &"bar"; nicht kompiliert ist, die "bar" ist eine Konstante und nicht ein lvalue, so können Sie nicht nehmen Sie sich die Adresse von ihm. Es ist das gleiche wie int *p = &5; was wird nicht kompiliert, entweder.
    • Durch Nein-sagen "echte" arrays habe ich genau das gemeint, dass die C-oder C++ - arrays sind keine erste-Klasse-Objekte. Sie sicherlich verwenden Sie arrays in C oder C++, sondern eine Funktion void foo(int *a), wobei ein Zeiger als argument übergeben, hat keine Ahnung, ob ein array oder ein Zeiger auf eine ganze Zahl.
    • dann editieren Sie bitte die Antwort zu sagen. Ich kann schreiben, Funktionen, arrays, aber keine Zeiger, wenn Sie möchten mehr Beweise.
    • auch, das Programm muss ja wissen, wie groß der reservierte array ist, sonst ist es nicht löschen Sie die richtige Anzahl vor der Freigabe.
    • Ich glaube, meine Antwort ist bereits klar genug.
    • Es ist klar, aber fast alles ist falsch. Es ist schon eine situation, wo sizeof ist Laufzeit statt compile-Zeit, Arrays do existiert, und es gibt Möglichkeiten für die Umsetzung, um zu wissen, die Größe des gesamten arrays. Auch ein DSP muss halten Sie die Größe für die Zuweisungen.
    • void foo(int *a); nimmt einen Zeiger, der auf void foo(int (&a)[5]); nimmt ein array. Array-Namen zerfallen zu Zeigern, das nervt, aber es bedeutet nicht, dass arrays und Zeiger sind die gleiche Sache.
    • Sie irren sich. Arrays sind vorhanden, und "x" ist ist ein lvalue. Arrays und pointer decay ist sehr schlecht, aber Sie werden verschiedene Dinge. Eine Funktion void foo(int* a) nimmt einen Zeiger auf eine ganze Zahl. Die Tatsache, dass dieser Zeiger auf ein element eines Arrays ist, werden es die ersten pointer decay oder in sonstiger Weise, ist irrelevant.
    • Jeder, der dies sieht, braucht dagegen zu Votieren. Tonnen und Tonnen von Fehlern hier. Dies ist ein Missverständnis
    • Ok, alle. Die ursprüngliche Frage war etwa, warum sizeof(arr) zurück nicht die Größe des Arrays. Ich glaube, ich habe das beantwortet.
    • Mein anderer Punkt ist, dass C-arrays sind keine erste-Klasse-Objekte. Ihre Größe muss gegeben werden zur compile-Zeit, Sie muss zugewiesen werden, auf den Stapel, und Sie zerfallen zu Zeigern. Für die meisten praktischen Zwecke, wenn Sie wollen, übergeben Sie ein array an eine Funktion übergeben Sie müssen den Zeiger auf das erste element und die Größe des Arrays. Auch wenn Sie schreiben, eine Bibliothek von Funktionen, die den Betrieb auf festen Größe von Vektoren oder Matrizen, würden Sie immer noch übergabe von Zeigern und Größen um, weil Sie nicht erwarten können, dass der Anrufer zu reservieren, alles auf den stack. Siehe "Numerical Recepies" für ein Beispiel.
    • Wenn Sie sagen "1.-Klasse-Objekt", was genau meinst du? Wenn Sie erklären int a[4]; ergibt einen zusammenhängenden 4-byte-chunk-Speicher. Was fehlt, von diesem suggeriert Ihnen, dass dies nicht ein array? Ich versuche nicht zu Haufen auf, ich versuche eine Klärung.
    • ein erste-Klasse-Objekt ist eine Einheit, die konstruiert werden können, die zur Laufzeit als parameter übergeben, nach der Rückkehr von einem Unterprogramm zugewiesen oder in eine variable. en.wikipedia.org/wiki/First-class_object Aus dem gleichen Artikel: In vielen älteren Sprachen (z.B. C) - arrays wurden nicht die erste-Klasse: Sie konnten nicht zugeordnet werden als Objekte oder als parameter übergeben, um eine subroutine; nur Ihre Elemente können direkt manipuliert werden.
    • Dann sind Sie nicht argumentieren, dass es keine arrays in C++, nur dass Sie nicht "1. Klasse-Objekte", die durch Ihre definition?
    • Ich sagte in der Antwort, dass es keine "echte" arrays in C, und ich habe später geklärt in den Kommentaren, dass ich meinte, dass C arrays sind nicht 1st-class-Objekte. Und nicht von meiner definition, sondern von einer allgemein akzeptierten definition.
    • vergleichen Sie C-arrays in Java arrays, zum Beispiel. Java-arrays können einander zugeordnet sein, Sie können an Funktionen übergeben werden, und Sie nicht haben, um Weitergabe Ihrer Größe zusammen mit Ihnen.
    • OK. Sie hätte nur gesagt, "ja."
    • und da haben Sie erwähnt C++, dann std::vector ist im Grunde ein "echtes" array.
    • ist ein lvalue, und &"bar" gültig ist. Aber die letztere Art ist char (*)[4] das ist nicht kompatibel mit char **.
    • Ich glaube nicht, dass Sie die Frage beantwortet, "Wenn delete[] kann auf die Größe des reservierten Arrays, warum kann nicht der Programmierer". Entschuldigt, wenn ich den Punkt verpasst.
    • Kurze Antwort: weil dies ist, wie new/delete definiert sind. Lange Antwort: new/delete tun, Buchführung, versteckt von der Außenwelt. Wie Sie tun es mit Absicht nicht standardisiert, und es kommt auf den compiler an. Ein Grund für das verstecken dieser Informationen, ist, dass new() in der Regel mehr Speicher reserviert fragst du dann wegen der Ausrichtung, und da kann es verwenden, einige der reservierte Speicher für seine eigene Buchhaltung. Seit dieser Buchhaltung ist compiler-abhängig, Ihr code sollte nicht sein Vertrauen auf Sie.

    InformationsquelleAutor Dima
  2. 18

    Nein, es gibt keine Möglichkeit zu tun, die in Standard-C++.

    Gibt es keinen wirklich guten Grund warum nicht, dass ich bewusst bin. Wahrscheinlich, die Größe wurde als ein Implementierungsdetail, und am besten nicht ausgesetzt. Beachten Sie, dass wenn Sie sagen malloc(1000), es gibt keine Garantie, dass der block zurückgekehrt ist 1000 bytes --- nur, dass es mindestens 1000 bytes. Wahrscheinlich ist es über 1020 (1K minus 4 bytes für den overhead). In diesem Fall, das "1020" Größe ist wichtig für die run-time-Bibliothek zu erinnern. Und natürlich, dass würde sich ändern, zwischen den Implementierungen.

    Weshalb der Standards committee Hinzugefügt std:vector<>, die nicht nachverfolgen der genauen Größe.

    • Eine Sache zu beachten ist, dass new[] speichert die Anzahl der angeforderten Elemente, als auch, um die richtige Anzahl von Konstruktoren und Destruktoren für das array. Wo dieser gespeichert wird ist wieder die Umsetzung-spezifisch. Grund, nicht enthalten einen Weg, um es ist jenseits meiner ken.
    • Ich denke, der "gute Grund" ist, dass arrays nicht die Objekte überhaupt. Ein array ist nur ein raw block of memory. Die Größe ist Speicher-management Daten, die nicht Objekt-Daten. Sie schreiben, könnte eine Array-Klasse, die immer den überblick über die Speicher und die Größe, aber Sie konnte einfach std::vector und sich nicht darum kümmern.
    • Aha... natürlich. Ein int* konnte nicht wissen, ob das array war es zu zeigen, war eine neue würde-array oder einem lokalen array oder ein Fleck in der Mitte des Arrays.
    • std::string[10] ist definitiv nicht raw-Speicher, aber es ist ein array.
    • workmad3, evtl. nur für Objekte mit einem nicht trivialen Destruktor und für Arten mit einem Benutzer-definierten operator löschen, die will, dass die Größe bekannt sein. für alles andere genügt es nicht, um die Nummer zu speichern
    • Es wäre sehr praktisch, um eine Funktion zurückgegeben, die Zuordnungsgröße, vor allem, wenn es größer war, als gefragt wurde.

    InformationsquelleAutor James Curran
  3. 16

    Nun, es ist tatsächlich ein Weg, um die Größe zu bestimmen, aber es ist nicht "sicher" und wird Verschieden von compiler zu compiler.... , so sollte es nicht verwendet werden, auf alle.

    Wenn du dies tust:
    int* arr = new int[256];

    256 ist unerheblich, Sie erhalten 256*sizeof(int) vorausgesetzt, für diesen Fall 1024, dieser Wert wird gespeichert, wahrscheinlich ( arr - 4 )

    So geben Sie die Anzahl der "Elemente"

    int* p_iToSize = arr - 4;

    printf("Anzahl der Artikel %d", *p_iToSize /sizeof(int));

    Für jedes malloc, new, was vor den kontinuierlichen Speicherblock, dass Sie erhalten, es ist auch zugewiesen einen reservierten Platz mit ein paar Informationen über den Speicherblock, der Sie gegeben wurden.

    • Dennoch, das ist tatsächlich die Frage beantwortet.
    • interessant, 🙂 als extra 2 Cent, die Sie überlasten könnte "neuen" und implementieren memory-management jedoch, das Sie mögen, könnten Sie es wie joao beschreibt, oder speichern jeden Zeiger in eine Karte mit der entsprechenden Größe...kurzum es gibt viele tolle Möglichkeiten, wie es erreicht werden könnte, aber ich würde Sie nicht benutzen :p
    • was ist mit char-array ? char * arr = new char[100];
    InformationsquelleAutor João Augusto
  4. 5

    Gemeinsamen Weg zu handhaben, ist entweder eine Vektor -

    int main()
{
   std::vector<int> v(256);
   printf("size of v is %i capacity is %i\n", sizeof(int) * v.size(), sizeof(int) * v.capacity());
}

    vordefinieren oder die Größe

    const int arrSize = 256;
int main()
{
    int array[arrSize];
    printf("Size of array is %i", sizeof(int) * arrSize);
}
    • sizeof(int) * arrSize ist dieselbe, wie bei malloc('sizeof(int) * arrSize') ist es nicht??
    InformationsquelleAutor Doug T.
  5. 3

    C++ entschieden, um neues zu tun, eine typesafe malloc, als neue muss wissen, sowohl in Größe als e-Nummern der Elemente für den Aufruf ctors, so löschen zum aufrufen dtors. In den frühen Tagen haben Sie pass eigentlich zu löschen, die zahlen sind Objekte, die Sie übergeben, um neue.

    string* p = new string[5];
delete[5] p;

    Aber Sie dachte, wenn die Nutzung der neuen<Typ>[] der Aufwand für eine Zahl war klein. So beschlossen Sie, die neue[n] muss sich erinnern, n und pass es zu löschen. Es gibt drei wichtigsten Möglichkeiten, es zu implementieren.

    1. halten Sie eine hash-Tabelle, die Zeiger, um die Größe
    2. schrieb es direkt in der Nähe der Vektor
    3. etwas völlig anderes tun

    Vielleicht möglich ist, um die Größe wie:

    size_t* p = new size_t[10];
cout << p[-1] << endl;
//Or
cout << p[11] << endl;

    Oder die Hölle, keiner von denen.

    InformationsquelleAutor Mykelyk
  6. 3

    Je nach Anwendung, die Sie erstellen könnte ein "sentinel-Wert" an das Ende von array.

    Sentinel-Wert muss eine einzigartige Eigenschaft.

    Können Sie dann entweder ein Prozess-array (oder eine lineare Suche) für die sentinel-Wert, zu zählen, wie Sie gehen. Wenn Sie erreichen die sentinel-Wert, müssen Sie das array zählen.

    Für einen einfachen C-string, der terminierenden \0 ist ein Beispiel für eine sentinel-Wert.

    InformationsquelleAutor bearvarine
  7. 3

    Einige magic:

    template <typename T, size_t S>
inline
size_t array_size(const T (&v)[S]) 
{ 
    return S; 
}

    Und dies ist, wie wir es tun, in C++11:

    template<typename T, size_t S>
constexpr 
auto array_size(const T (&)[S]) -> size_t
{ 
    return S; 
}
    • Sehr nützliche und schöne Lösung. Nur eine Sache: ich würde size_t als zweiten template-parameter statt.
    InformationsquelleAutor Zingam
  8. 2

    Weil deine variable arr ist nur ein Zeiger. Es enthält die Adresse eines bestimmten Speicherort im Speicher, ohne etwas darüber zu wissen. Sie deklarieren int*, das gibt dem compiler einen Hinweis darauf, was zu tun ist, wenn Sie erhöhe den Zeiger. Andere als das, Sie könnten zeigen, in der Anfang oder das Ende des Arrays oder in den stack oder ins ungültigen Speicher zu.
    Aber ich Stimme mit Ihnen, die nicht in der Lage zu nennen sizeof ist sehr ärgerlich 🙂

    QuantumPete

    • Aber das system irgendwie weiß die Größe des Arrays, oder "delete[] arr" und nicht funktionieren würde.
    • Nun weiß das system zur Laufzeit, sondern sizeof ist eine compile-Zeit nennen.
    • delete[] arr, wird wissen, die Größe des Arrays, aber nicht, wenn das array war auf dem Stapel reserviert.
    InformationsquelleAutor QuantumPete
  9. 2

    Gibt es keine portable Möglichkeit zur Bestimmung der Größe einer dynamisch reservierten Arrays in C++ gegeben nur Ihre Zeiger. C++ ist sehr flexibel und geben Kraft für den Benutzer. Zum Beispiel der standard definiert nicht, wie Speicherzuordnungen arbeiten müssen, z.B. durch hinzufügen eines gewünschten Größe Kopfzeile. Nicht die eine header ermöglicht viel mehr Flexibilität.

    Als ein Beispiel, sollten Sie einen string implementiert als char * - array. Es ist üblich, verwenden Sie Zeiger in der Mitte der Reihe zu Holen, von Teilstrings. Als ein Beispiel, siehe die strtok-Funktion in der standard-C-Bibliothek. Wenn einige der header-waren erforderlich, um eingebettet werden kurz vor jedem array, müssten Sie in den Papierkorb, Teile des Arrays vor dem Teilstring.

    Alternative Möglichkeit zum verarbeiten der Header wäre die array-Header in einem block im Speicher, und haben Sie diese Punkt, um die raw-array-Speicher anderswo. In vielen Situationen, die diese erfordern würden zwei Zeiger-lookups für jede Referenz, die wäre eine große ziehen an der Leistung. Gibt es Möglichkeiten der überwindung dieser Mängel, aber Sie fügen Sie Komplexität und reduzieren Umsetzung Flexibilität.

    Std::vector template ist meine Lieblings-Weg, um die Größe eines array an das array selbst.

    C ist portabler Assembler mit besserer syntax.

    • strtok arbeiten würde, genau das gleiche, wenn arrays haben Kopfzeilen, da strtok nimmt Zeiger auf chars, keine arrays.
    InformationsquelleAutor Mr Fooz
  10. 1

    Leider ist dies nicht möglich. In C und C++, ist es in der Verantwortung des Programmierers zu erinnern, von der Länge eines Arrays, da die array-Länge ist nicht überall gespeichert. Delete[] und free() nicht erinnere mich an die Größe des zugeordneten Blocks, aber Sie können mehr Speicher zuzuweisen, als erforderlich ist, damit Ihre internen Datenstrukturen speichern der Größen der zugewiesenen Speicherblöcke möglicherweise nicht geben Sie die genaue Größe des Arrays.

    Beachten Sie, dass die C++ - STL-Vektoren, die im Grunde arrays eingewickelt in eine Klasse mit einigen Hilfsfunktionen, lagern Sie die Länge des Arrays, also, wenn Sie wirklich brauchen diese Funktion, Sie könnte nur Vektoren verwenden.

    InformationsquelleAutor Tamas Czinege
  11. 1

    Im Allgemeinen, Nein. Arrays in C und C++ sind nur Blöcke von Speicher mit keine Buchhaltung Informationen beigefügt. Ohne Speicherung der Länge des Arrays im Arbeitsspeicher und hinzufügen overhead zu tun, ist es unmöglich, in den Allgemeinen Fall.

    Gibt es eine Ausnahme für arrays sind statisch zugewiesen. Zum Beispiel, wenn Sie erklären: int a[50] dann sizeof(a) arbeiten. Dies ist möglich, weil die [50] ist Teil der statische Typ des Arrays: es ist bekannt, dass der compiler. sizeof interpretiert wird zur compile-Zeit.

    Allerdings, wenn Sie erstellen Sie einen Zeiger: int *p = a, dann sizeof(p) wird wieder die Größe des Zeigers, wie Sie erwähnen, nicht die Größe des Arrays, da der compiler nicht wissen, was p Punkte zu.

    InformationsquelleAutor James Rose
  12. 1

    Können Sie nicht, grundlegend:

    void foo(int* arr);

int arr[100] = {0};

foo(arr+1); //Calls foo with a pointer to 100-1 elements.

    Einem C++ - array ist nichts anderes als eine Sammlung von Objekten, die gespeichert sind, in einem zusammenhängenden Speicherbereich. Da gibt es keine Löcher zwischen Ihnen (die Polsterung ist innen Objekte), können Sie das nächste element eines Arrays, indem Sie einfach incerementing den Zeiger. Auf CPU-Ebene ist dies eine einfache Anpassung. Nur C++ fügt ein sizeof(element) Multiplikator.

    Beachten Sie, dass Implementierungen können wählen, zu implementieren "fat pointers" enthalten, die von array-Grenzen. Sie müssten doppelt so groß sein, wie man bräuchte, um einen link zu einer Art "array gebunden descriptor". Als Nebeneffekt, auf solche Implementierungen könnten Sie in der Lage sein zu rufen delete [] (1+new int[5]);

    InformationsquelleAutor MSalters
  13. 1

    Nein, es gibt keinen Weg, dies zu tun, müssen Sie verfolgen, wie groß er ist extern. Klassen wie std::vector dies für Sie tun.

    InformationsquelleAutor Greg Rogers
  14. 1

    Nun gibt es std::array, eine effiziente compile-Zeit wrapper um eine Konstante Größe-array:

    #include <array>

int main (int argc, char** argv)
{
    std::array<int, 256> arr;
    printf("Size of arr: %ld\n", arr.size());
}

    Werden die Parameter <type, #elements>.

    Bekommen Sie auch noch ein paar andere Nettigkeiten, wie Iteratoren, leer(), und max_size().

    InformationsquelleAutor Brent Faust
  15. 0

    Der compiler kann nicht wissen, dass 

    char *ar = new char[100]

    ist ein array von 100 Zeichen, da Sie es nicht schaffen, eine tatsächliche array im Speicher, sondern erstellt nur einen Zeiger auf 100 uninitialisierte bytes im Speicher.

    Wenn Sie wollen, um zu wissen, die Größe des gegebenen array benutzen Sie einfach std::vector.
    std::vector ist ein array besser einfach.

    InformationsquelleAutor SMeyers
  16. 0

    Gibt es eine Möglichkeit, bestimmen die Größe eines C++ - Arrays programmgesteuert? Und wenn nicht, warum?

    1. Nein, es sei denn, Sie behalten es selbst.
    2. Denn wenn der compiler dies nicht zu sagen, jemand neben sich zu, dass die Informationen, die es schränkt den compiler weniger. Ob das wünschenswert ist oder nicht, ist bis zu Debatte.
    InformationsquelleAutor MSN
  17. 0

    @Dima,

    Wie würde der compiler weiß, wie groß p ist?

    Der compiler muss wissen, die Größe der p; andernfalls kann er nicht umsetzen delete[]. Der compiler braucht nicht zu sagen, jemand anderes, wie es zahlen aus.

    Für ein Spaß Weg, um dies zu überprüfen, vergleichen Sie die Zeiger zurückgegeben operator new[] auf den Zeiger zurückgegeben new[].

    InformationsquelleAutor MSN
  18. 0

    Wenn Sie erstellen Sie ein array von Zeigern (Create wrapper mit der Vorlage Zeiger) kann man nicht, aber wenn Sie erstellen Sie ein array von Objekt -,
    Sie können die Größe des Arrays so:

    char* chars=new char[100];
printf("%d",*((int*)chars-1));

    Den delete[] Funktion benötigen, zu dekonstruieren, werden alle Objekte in ihm. das new[] Schlüsselwort legt die Anzahl der Elemente, die hinter all dem array.

    Den Körper der array sieht so aus:

    int count;
ObjectType* data; //This value is returned when using new[]
    InformationsquelleAutor MessyCode
  19. 0

    die Weise, die ich tun, ist durch Division der Größe des Arrays durch die Größe des ersten Elements

    int intarray[100];
printf ("Size of the array %d\n", (sizeof(intarray) / sizeof(intarray[0]));

    Druckt es 100

    • Bitte Lesen Sie nochmals die Frage (Letzte Zeile), der Autor ist sich auch bewusst, dass. dies ist nicht das, was verlangt wird.
    InformationsquelleAutor user4443767
  20. -1

    Könnte man erstellen Sie einfach ein zusätzliches element des Arrays und wenden Sie dann die unmöglichsten Nummer, die im array gespeichert werden. Dann bestimmen Sie die Anzahl der Elemente, die durch irgendeine Funktion, indem diese Zahl.

    In dem Fall deklarieren und initialisieren ein array im moment der Schöpfung, Sie kann dann Scannen Sie es und generieren Sie dann eine Zahl, die nicht mit einem der Elemente des Arrays. Aber wenn du dann ändern die Elemente, die Sie nicht wissen, ob dieses element speichert den gleichen Wert wie das Letzte element, also Sie haben dann zum generieren einer neuen Nummer zu speichern in das Letzte element.. Gehst durch all das, könnte man auch speichern nur die Gesamtzahl von Elementen, die im moment der Erstellung in einer variable. Und das wird wahrscheinlich der Fall sein, wenn man nur die array innerhalb einer Funktion.

    • Das ist sowohl vage und unpraktisch, beim auch sich mit der Sache zu Messen. nicht eine ernsthafte Antwort.
    • Es ist jedoch eine Lösung.
    • Es ist eine sehr schlechte.
    • Die Einführung einer magischen string ('höchst unwahrscheinlich number') in den Daten ist ein anti-Muster für einen Grund. Was passiert, wenn, was sehr unwahrscheinlich Anzahl tatsächlich tritt aufgrund von unvorhergesehenen Gründen von dem Programmierer?
    InformationsquelleAutor PER
Schreibe einen Kommentar