Größe eines dynamischen Arrays bestimmen.

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