Klasse *obj;
obj = new Klasse[zahl];

Mit meinen Worte würde ich sagen, dass zunächst ein Zeiger auf eine undefinierte Stelle im Speicher ohne bekannte Größe zeigt. Stimmt das so? Warum muss erst ein Zeiger gesetzt werden?
Anschließend wird das Objekt mit dem Operator "new" der Größte zahl initialisiert. Das klingt natürlich laienhaft, wäre jemand so freundlich, mir das kurs zu erklären?

Danke und Gruß, Julian

Stimmt das so?

shizzophate schrieb:

Warum muss erst ein Zeiger gesetzt werden?

Falls du mit "gesetzt" definiert meinst: Muss er nicht, man hätte ihn auch initialisieren können.

shizzophate schrieb:

Anschließend wird das Objekt mit dem Operator "new" der Größte zahl initialisiert.

Ne, das ist höchstens noch ungenau. new reserviert genug Speicher für [zahl] hintereinanderliegende Objekte (wenn alles gut läuft), und ruft gegebenenfalls die Konstruktoren auf. new liefert dann einen Zeiger auf diesen Speicherbereich zurück, auf den der Zeiger nach der Zuweisung zeigt.

cooky451 schrieb:

new reserviert genug Speicher für [zahl] hintereinanderliegende Objekte (wenn alles gut läuft), und ruft gegebenenfalls die Konstruktoren auf. new liefert dann einen Zeiger auf diesen Speicherbereich zurück, auf den der Zeiger nach der Zuweisung zeigt.

Dennoch verstehe ich nicht, warum es nötig ist, einen Zeiger auf den Zeiger zeigen zu lassen.
Wenn mit

obj = new Klasse[zahl];

Gruß!

Danke für die Erklärung.

cooky451 schrieb:

new reserviert genug Speicher für [zahl] hintereinanderliegende Objekte (wenn alles gut läuft), und ruft gegebenenfalls die Konstruktoren auf. new liefert dann einen Zeiger auf diesen Speicherbereich zurück, auf den der Zeiger nach der Zuweisung zeigt.

Dennoch verstehe ich nicht, warum es nötig ist, einen Zeiger auf den Zeiger zeigen zu lassen.

Das hast du missverstanden/war ungünstig formuliert^^
Du hast einen Zeiger, der auf den dynamischen Speicherbereich zeigt, und keinen Zeiger auf einen Zeiger.

Klasse *obj;
// der Zeiger "obj" zeigt jetzt irgendwohin, da er nicht initialisiert wurde.
// besser wäre "Klasse *obj = NULL;"
obj = new Klasse[zahl]; 
// mit "new Klasse[zahl]" wird auf dem Heap Speicher für "zahl" Objekte vom Typ "Klasse" reserviert.
// obj zeigt nach der Zuweisug auf das erste Element

T* ptr = new T[n];

Warum schreibst du's nicht einfach in einem? Diese Extra-Zuweisungen finde ich bei Anfängern immer wieder, und ich finde sie weder leserlicher, noch irgendwie besser.

T* ptr = new T[n];

Korrigiere mich bitte aber:
Im Normalfall kann new eine Exception werfen. Um sich dagegen abzusichern
müsste man try und catch verwenden und schon hätte man ein Sichtbarkeitsproblem sich eingehandelt.
Deswegen trennt man die Deklaration und Speicherzugriff, denn sonst hat man

try
{
    T* ptr = new T[n];
    // hier wird der Pointer benutzt.
    // ...
}
catch()
{
}

Und z.B. für mein Geschmack ist die die Trennung des Speicherzugriff und der Deklaration leserlicher.Insbesondere, wenn man die Initialisierung hinter einer Funktion "versteckt".

template< typename T >
bool __inline erstelle_array( T*& instance, size_t anzahl )
{
        try
	{
		if ( anzahl != 0 )
		{
			instance = new T[ anzahl ];
		}
	}
	catch( std::bad_alloc& )
	{
		instance = 0;
                // Fehlermeldung ausgeben( ? )
		return false;
	}
	return true;
}

T* ptr = 0;
if ( erstelle_array( ptr, 100 ) )
{
    // Variablenverwendung.
}

//oder z.B.

T* ptr = 0;
if ( !erstelle_array( ptr, 100 ) )
{
    // Fehlermeldung.
    return;
}

Es ist halt Geschmacksfrage.

Ganz verwirrtes Zeug

Man will doch gerade rausspringen, wenn eine Exception geworfen wird. Und wenn man das anders handeln möchte, nutzt man die nothrow Variante. Diese von dir gepostete Funktion ist nicht nur Quatsch, sondern nicht mal standardkonform.

Ob man herausspringen will oder nicht ist eine Entscheidung des Programmierers. Ist halt nicht immer sinnvoll.

Lies erstmal meinen Beitrag ordentlich.

Im Normalfall kann new eine Exception werfen.

Richtig.

Um sich dagegen abzusichern
müsste man try und catch verwenden

Bedingt richtig - man muss try/catch nicht unbedingt in der Funktion verwenden, in der man auch new aufruft. Meist kann man sowas schwerwiegendes wie Speichermangel nicht dort verwenden wo man new aufruft, sondern behandelt es irgendwo weiter oben.

und schon hätte man ein Sichtbarkeitsproblem sich eingehandelt.

Meistens falsch. Du willst nicht wie in C nur das new in einen try-Block packen, dann Fehler behandeln und nach dem catch mit dem Pointer weiterarbeiten, sondern du packst die gesamte Logik der Funktion in einen try-Block, also die Definition des Pointers, new-Aufruf und die Benutzung des Pointers. Das ist doch einer der großen Vorteile von Exceptions - dass man erst die komplette Logik schreiben kann, gefolgt von der kompletten Fehlerbehandlung, statt immer abwechselnd eine Zeile Logik, fünf Zeilen Fehlerbehandlung.

Travor schrieb:

Ob man herausspringen will oder nicht ist eine Entscheidung des Programmierers. Ist halt nicht immer sinnvoll.

Lies erstmal meinen Beitrag ordentlich.

Sorry ich habe das mal wieder falsch gelesen. .

pumuckl schrieb:

.. Meist kann man sowas schwerwiegendes wie Speichermangel nicht dort verwenden wo man new aufruft, sondern behandelt es irgendwo weiter oben.
Meistens falsch. Du willst nicht wie in C nur das new in einen try-Block packen, dann Fehler behandeln und nach dem catch mit dem Pointer weiterarbeiten, sondern du packst die gesamte Logik der Funktion in einen try-Block, also die Definition des Pointers, new-Aufruf und die Benutzung des Pointers.

Ja stimmt auch alles. Allerdings erlaubt mir meine Konstruktion das ganze in eine while-Schleife zu packen und einfach abzuwarten bis für bestimmte ( in dem Fall sekundäre ) Aufgaben mal wieder Ressourcen da sind. Mir ist keine andere Lösung eingefallen, um so etwas zu erledigen. Und wenn ich sowieso so etwas drin stehen habe, kann ich es überall verwenden, um an der Stelle zu entscheiden was zu tun ist.

Allerdings erlaubt mir meine Konstruktion das ganze in eine while-Schleife zu packen und einfach abzuwarten bis für bestimmte ( in dem Fall sekundäre ) Aufgaben mal wieder Ressourcen da sind.

(geht mit nothrow() auch)
Und du solltest dir mal set_new_handler angucken.