Herausfinden wieviel Speicher ein Pointer reserviert hat.

[JaykopX]

Hallo!
Wie kann ich herausbekommen wieviel Speicher ein Pointer reserviert hat?
Damit meine ich echte Pointer (void*).

int Test[10];           //Ist ja nichts anderes als ein int* mit reserviertem Speicher von 10*sizeof(int)
   void* Unbekannt = Test; //Pointer auf den ersten int in Test[]

Wie bekomme ich nun die 10*sizeof(int) aus der Variable Unbekannt rausgequetscht?
Danke...

[_Awesome_]

So erst mal gar nicht. Du musst Dir die Länge merken oder alternativ, was hässlich ist ein Sentinel-Element am Ende einfügen, was das Ende des Arrays markiert. Dann kannste den Array durchlaufen und zählen ab was das letzte Element erreicht wurde. Du kannst dann aber das Sentinel-Element nicht als eigentlichen Wert im Array verwenden.

BTW: Die "moderne" C++ Fraktion würde dich dafür schlagen, dass du keinen std::vector benutzt.

[l'abra d'or]

Ein Pointer ist immer gleich groß, jedenfalls wenn dein Programm nicht mittendrin die Plattform wechselt...
sizeof(void*) == sizeof(T*);
Warum ein void* ein echterer Pointer als T* ist versteh ich auch nicht.

Und du willst wahrscheinlich nicht sizeof(void*) sondern die Größe des Objektes (nicht Pointer) was sich hinter dem void* versteckt.
Wenn du zur Laufzeit (eigentlich schon compilezeit) nicht weißt, was hinter dem void* steckt hast du ganz schlechte Chancen, das herauszufinden...
Ansonsten geht das über static_cast:

int nums[10];
void* ptr = nums;
cout << sizeof( static_cast<int>(*nums) );

Wobei du da sogar ein NULL nach int casten könntest.

cout << sizeof( static_cast<int>(NULL) );

[du hecht]

JaykopX schrieb:

Hallo!
Wie kann ich herausbekommen wieviel Speicher ein Pointer reserviert hat?

new überschreiben und dir alles merken

Damit meine ich echte Pointer (void*).

alle anderen pointer sind auch echt

[JaykopX]

@labrador
Ich möchte nicht die Größe des Objektes haben, sondern wie schon erwähnt die größe des reservierten speichers.
Mit "echtem" Pointer mein ich, dass es ein reiner Zeiger ohne Typ ist(den feinen Unterschied merkt man schnell wenn man sizeof(void) probiert).

Ich möchte quasi

int Test[10];           //Ist ja nichts anderes als ein int* mit reserviertem Speicher von 10*sizeof(int)
   void* Unbekannt = Test; //Pointer auf den ersten int in Test[]

   int SizeIs = sizeof(Test);  //Liefert mir 40 = 10*sizeof(int)
   SizeIs = sizeof(Unbekannt);  //Liefert mir 4, die größe eines Pointers...

Man sieht, das der Compiler sehr wohl weis wieviel Speicher reserviert wurde.
Das wird für

int* Test = new int[10];

anders ausehen, aber genau dafür brauch ich das.

Aber ich seh schon, das ich nicht drumherumkomme die größe zu speichern. Falls wer noch was weis, dann her damit.
Danke, an alle.

[theta]

Nimm doch einfach std::vector.

[pumuckl]

JaykopX schrieb:

Hallo!
Wie kann ich herausbekommen wieviel Speicher ein Pointer reserviert hat?
Damit meine ich echte Pointer (void*).

Mit standard-Mitteln und den eingebauten Implementierungen von new/delete garnicht. Du könntest new/delete natürlich überladen und ein speichermanagement dahinterlegen das sich zu jedem Pointer merkt wieviel speicher dazu gehört.

[Tachyon]

Deine Annahme ist einfach falsch:

int a[10]; //Typ ist int[10] und NICHT int*

Und sizeof(int[10]) ist eben etwas anderes als sizeof(int*) .
Demenstprechend ist die Aussage:

JaykopX schrieb:

int Test[10]; //Ist ja nichts anderes als ein int* mit reserviertem Speicher von 10*sizeof(int)

auch falsch...

[JaykopX]

@Tachyon
Jo, das seh ich ein.
Hätte aber nicht gedacht das int[10] als eigener Typ durchgeht, und hab auch nicht damit gerechnet das er mir das richtige ausspuckt;).

Ja, es wird auf dem Stack angelegt, oder was meinst du mit "auch falsch"?

[Tachyon]

JaykopX schrieb:

...oder was meinst du mit "auch falsch"?

Falsch ist die Aussage, dass ein int x[10] das Gleiche ist, wie ein int* mit einem reservierten Speicher von 10*sizeof(int) .

Arrays sind eigenständige Typen. Das man Arrays so leicht (und fälschlicherweise) mit Zeigern gleichsetzt, liegt am Typkonvertierungssystem von C++. Arrays eines Types werden werden bei Zuweisung an einen Zeiger des gleichen Typs ohne Murren des Kompilers automatisch umgewandelt. Deshalb sind Arrays und Zeiger aber trotzdem nicht das Selbe.

[drakon]

@JaykopX
Probier mal ein Array von int zu inkrementieren und probier mal einen Zeiger auf int zu inkrementieren. Das eine geht. Das andere nicht. Das alleine zeigt schon, dass es sich um unterschiedliche Typen handelt.