Größe eines dynamischen Arrays bestimmen.

Prophet05

Moin,

wenn ich mir ein dynamisches Array erstelle:

int gross = 30;
int* meinArray = new int[gross];

Wie kann ich dessen größe später bestimmen wenn die Variable gross z.B. nicht mehr exsistiert?

Ich habe mir schon überlegt das es vll so geht:

int gross = sizeof(meinArray) / sizeof(meinArray[0]);

Nur leider kam ich schnell zu der erkenntnis das ich immer nur die größe der start Adresse des Array bestimmen kann.

Mein zweiter ansatz wäre es die Elemente einfach durchzuzählen nur weiß ich nicht woran ich erkenne wann ich am ende des Array ankomme.

Kann mir jemand helfen bzw. sagen wie ich die größe eines solchen arrays bestimme?

Gruß, Prophet05

Braunstein

Hallo,

Merk dir doch einfach die Zahl gross oder du verwendest std::vector statt deinem Array.

Prophet05

Es muss doch eine möglichkeit geben die größe eines solchen array zu bestimmen!

David_pb

Es gibt durchaus welche, allerdings sind die meist nicht besonders schön! Also merk dir die größe einfach. Oder verwende, wie gesagt, lieber std::vector.

grüße

Prophet05

Wenn möglich würde ich die möglichkeiten trotzdem gerne wissen...

Kann mir jemand eine Referenz für std::vector geben? Sonst weiß ich nemlich nicht wie es verwenden kann.

Braunstein

Meines Wissens gibt es keine andere Möglichkeit. Wo ist denn aber das Problem? Du kannst doch eine der beiden von mir genannten Lösungen verwenden. Du kannst dir auch eine struct basteln, die die Länge mitführt oder boost::array verwenden.
[edit]Da war ich wohl viel zu langsam[edit]
zu vector und co
http://www.c-plusplus.net/forum/viewtopic-var-t-is-143816.html
http://www.cppreference.com/cppvector/index.html

David_pb

Doch, man kann tricksen wenn man sich einen eigenen Allocator schreibt der irgendwo die Zahl der reservierten Bytes speichert (z.B. die ersten 4 Bytes des reservierten Datenblocks) und denentsprechend einen inkrementierten Zeiger zurückgibt.

Dann muss man nur die Funktionen operator new/[] und operator delete/[] überschreiben.

Bei falscher Handhabung kann das allerdings viele Nachteile mit sich bringen, angefangen bei ausgebremster Speicherreservierung bis hin zu kritischen Fehlern... Daher würde ich raten die Finger davon zu lassen und lieber vectoren zu verwenden. Es sei denn du kennst dich wirklich sehr gut mit dem Memory Management von C++ aus.

grüße

Prophet05

Nun gut danke für eure hilfe.

Knuddlbaer

Das Problem ist, das ein native Array keine größenangabe mit sich führt.
Du müsstest also ein definiertes Ende im Array haben (wie z.B. \0 oft für c Strings definiert wird) und dann von anfang bis zum Ende durch zählen.

std::vector führt die größe intern mit sich.

Kurz:

Es gibt keine Möglichkeit von einem native Array die größe zu bestimmen da keinerlei größenangaben vorhanden sind.

David_pb

Die kannst du dir ggf selbst beschaffen.

Knuddlbaer

Ja, in dem Du entweder exakt den Typ kennst (dann is die größe nich unbekannt) oder Du nach nem Endzeichen suchst.

Weitere Wege bitte kurz aufzeigen , möchte was lernen

David_pb

Einfach die Funktionen operator new[] und operator delete[] überschreiben. Ein STARK gekürztes und wirklich minimalistisches Beispiel hier:

typedef unsigned char byte;
typedef unsigned long dword;

// ...

class Allocator
{
public:
	// ...

	void *Allocate( size_t size ) const
	{
		size_t *memory = static_cast< size_t *>( ::operator new( size+sizeof( size_t ) ) );
		*memory = size;
		return memory+1;
	}

	void Free( void *p ) const
	{
		::operator delete( static_cast< byte *>( p )-sizeof( size_t ) );
	}

	size_t Allocated( void *p ) const
	{
		return *( static_cast< byte *>( p )-sizeof( size_t ) );
	}

	// ...
};

// ...

// minimalversion, hier sollten noch andere wichtige dinge beachtet werden
void *operator new[]( size_t size ) 
{
	return allocator.Allocate( size );
}

// dito
void operator delete[]( void *p )
{
	allocator.Free( p );
}

// ...

int main()
{
	int *p = new int[ 20 ];
	std::cout << allocator.Allocated( p ) << " bytes allocated" << std::endl;
	std::cout << ( allocator.Allocated( p ) / sizeof( p[ 0 ] ) ) << " items allocated" << std::endl;

	delete [] p;
}

Ausgabe:

80 bytes allocated
20 items allocated

grüße

int gross = 30;
int* meinArray = new int[gross+1];
meinArray[0]=gross+1;

Jetzt haste immer an Position 0 die Größenangabe

David_pb

Abgesehen davon dass das genau das selbe macht wie mein Code... Meinst du wirklich man will das jedesmal machen wenn man ein Array auf diese Weise erstellt? Im übrigen könnten Probleme auftreten wenn du durch das Array (bei 0 begonnen) iterierst, da der Wert ja nichts mit dem Arrayinhalt zu tuen hat. Diese Angabe sollte also vor dem Benutzer verborgen bleiben.

David_pb schrieb:

Abgesehen davon dass das genau das selbe macht wie mein Code... Meinst du wirklich man will das jedesmal machen wenn man ein Array auf diese Weise erstellt? Im übrigen könnten Probleme auftreten wenn du durch das Array (bei 0 begonnen) iterierst, da der Wert ja nichts mit dem Arrayinhalt zu tuen hat. Diese Angabe sollte also vor dem Benutzer verborgen bleiben.

Ich hatte das so verstanden, dass der Thread ersteller das nur einmal braucht und dann ist mein code etwas kürzer

David_pb

Wozu sollte man sowas nur ein einziges mal gebrauchen? Ich denke das war eher allgemein gemeint. Imho sollte man sowiso lieber std::vector verwenden.

grüße