Vielen dank

#include <iostream>
#include <assert>
using namespace std;

int main()
{
    int *pnExample=NULL; // Dynamischer Zeiger
    unsigned short int nLenghtOfExample=0; 
    cout<<"Bitte geben sie die Länge des Arrays an: ";
    cin>>nLenghtOfExample; // Hier gibt der Benutzer die Länge an.
    pnExample=new int[nLenghtOfExample]; // Zuweisung des geforderten Speichers.
    assert(pnExample); // Überprüfung, ob Zuweisung geklappt hat.
    delete []pnExample; // Freigeben des Speichers (wichtig!).
}

Dynamische Speicherverwaltung klappt sowohl über Listen als auch über Zeiger. Anders als beim statischen Array kann hier der resiervierte Speicher variieren.

Kann mann auch sowas tun?

assert(pnExample); // Überprüfung, ob Zuweisung geklappt hat.

Diese Überprüfung wird niemals fehlschlagen, da new niemals 0 zurückgibt.

Vector containers are implemented as dynamic arrays; Just as regular arrays, vector containers have their elements stored in contiguous storage locations, which means that their elements can be accessed not only using iterators but also using offsets on regular pointers to elements.

But unlike regular arrays, storage in vectors is handled automatically, allowing it to be expanded and contracted as needed.

bsp:

#include <iostream>
#include <vector>

int main()
{
    std::cout << "Anzahl: ";

    int n;
    std::cin >> n;

    std:vector<double> tab;

    // Eingabe
    for ( int i = 0; i < n; ++i )
    {
        std::cout << i + 1 << ": ";
        double d;
        std::cin >> d;
        tab.push_back( d );
    }

    // Ausgabe
    for ( int i = 0; i < tab.size(); ++i )
    {
        std::cout << tab.at( i ) << std::endl;
        // oder
        std::cout << tab[i] << std::endl;
    }

    // Alternativ
    for ( std::vector<double>::iterator iter( tab.begin() ); iter != tab.end(); ++iter )
    {
        std::cout << *iter << std::endl;
    }

    // Alternativ
    std::copy( tab.begin(), tab.end(), std::ostream_iterator<double>( std::cout, "\n" ) );
}

Der aus dem Westen ... schrieb:

assert(pnExample); // Überprüfung, ob Zuweisung geklappt hat.

Diese Überprüfung wird niemals fehlschlagen, da new niemals 0 zurückgibt.

Wenn die Zuweisung von Speicher nicht funktioniert hat (Heap voll oder beschädigt), gibt der new-operator zur Sicherheit die Speicherstelle NULL zurück, die dem Zeiger zugewiesen wird. Habe ich zumindest gelernt.

Damit ich das richtig verstehe: du willst den Benutzer eine variable Anzahl von Werten abfragen lassen (deren Anzahl er selbst nicht kennt) und diese Speichern? Dann würde ich dir eine Liste empfehlen, da diese die dynamischste Variante ist:

class Data
{
public:

    Data(){}
    ~Data(){}

    Data *pNext; // Zeigt auf ein nächtes Dataelement, welches auf ein Element zeigt, das auf ein Element zeigt, das auf ein Element zeigt... es wird aber noch kein Speicher reserviert.
    int  Value;
};

Du weisst aber schon, was Listen sind, oder?

Wenn die Zuweisung von Speicher nicht funktioniert hat (Heap voll oder beschädigt), gibt der new-operator zur Sicherheit die Speicherstelle NULL zurück, die dem Zeiger zugewiesen wird. Habe ich zumindest gelernt.

Der new-Operator wirft std::bad_alloc in diesem Fall. 0 gibt nur der new(nothrow)-Operator zurück.

Wenn die Zuweisung von Speicher nicht funktioniert hat (Heap voll oder beschädigt), gibt der new-operator zur Sicherheit die Speicherstelle NULL zurück, die dem Zeiger zugewiesen wird. Habe ich zumindest gelernt.

Hast du hoffentlich vor 1998 gelernt. Andernfalls solltest du den Lehrer (bzw. das Buch/Tutorial) wechseln.

Mag schon sein! Aber was gibt der Operator dann zurück, wenn nicht NULL?

Wenn eine Exception fliegt wird nichts zurückgegeben. Dann wird auch nichts zugewiesen, sondern die Exception fliegt bis zum nächsten passenden catch.

Du kannst das Verhalten aber so ändern, dass wieder 0 zurück kommt anstatt einer Exception^^

das hatten wir schon mal...
aber selbst bei dem nothrow-new wäre das assert dort falsch - ich kann zumindest keinen logikfehler erkennen : D

bb