Dynamischer Speicherplatz

LordJaxom

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.

zwutz

http://www.cplusplus.com/reference/stl/vector/

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" ) );
}

LordJaxom schrieb:

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?

LordJaxom

Der aus dem Westen ... schrieb:

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.

pumuckl

Der aus dem Westen ... schrieb:

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? Irgendwie MUSS man ja wissen, ob die Zuweisung funktioniert hat. Ich kann das bei mir nicht testen, da ich den Speicher nie voll genug kriege, und selbst wenn der voll wäre (habe ich mal mit einem hübschen Code geschafft, hinterher hat selbst den Prozess beenden und Windows runterfahren nichts gebracht), kriege ich nicht mal mehr Minesweeper auf.

pumuckl

Der aus dem Westen ... schrieb:

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.

Im Klartext? Soweit ich dich verstehe, fängt man die Exception entweder ab und behandelt den Fehler, oder das Betriebssystem greift ein und reisst alles nieder (das wäre meine Vorgehensweise, wenn kein freier, aber absoulut notwendiger Speicher vorhanden ist und ich nix löschen kann), oder?

pumuckl

Im Klartext heißt das: Wenn operator new keinen Speicher bereitstellen kann, wird ein std::bad_alloc geworfen. Dies fliegt bis man es fängt (spätestens in main()), oder das System räumt dir das komplette Programm ab. Bei einer fliegenden Exception wird jede Funktion, aus der sie fliegt, ohne Rückgabe eines Wertes einfach verlassen.
Ich persönlich lasse bad_alloc immer fliegen - wenn mir der Speicher ausgeht kann ich auch nicht mehr viel tun um das Programm noch zu retten.

Gut zu wissen. Vielen Dank.

Pellaeon

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

unskilled

Pellaeon schrieb:

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