Dynamischen Array in C++

[IT-homas]

Hallo,

ich möchte ein Programm schreiben, durch das ein dynamisches Array genutzt werden kann. Es soll über den Konstruktor eine Größe übergeben werden und sobald diese Größe erreicht ist, wird ein neues Array generiert, in welchem die vorherigen Werte hineinkopiert werden.
Hierfür habe ich den []-Operator überladen.
Das Programm scheint auf den ersten Blick auch zu funktionieren. Nachdem ich dann aber versucht habe ein Array mit der Größe 100 zu implementieren und hier 20000 Elemente zu speichern, werden unterschiedliche Zahlen ausgegeben.
Bei ersten Durchlauf wurden über 7000 Zahlen ausgegeben. Nach erneuten Durchlauf über 1800. Allerdings nie die gewünschten 20000.

Woran könnte das liegen?

#include <iostream>

using namespace std;

template<class T>

class Container{
    public:
    T *dynamischesArray;
    private:
    T *neuesArray;
    int size;

    public:
    Container(int size){
    this->size=size;
    dynamischesArray=new T[size];
    }

    T operator[] (unsigned long index){
        //Array vergrößern
        if(index>size-1){
            neuesArray=new T[size+(index-size)];
            T i;
            for(i=0; i<(size+(index-size)); i++){
                neuesArray[i]=dynamischesArray[i];
            }
            delete[] dynamischesArray;
            dynamischesArray=neuesArray;
            delete[] neuesArray;
        }

        return dynamischesArray[index];
    }
};
int main()
{
    Container <int> dArray(100);
    for(int i=1; i<20000; i++){
    dArray.dynamischesArray[i]=i;
    cout << dArray.dynamischesArray[i] << "\n";
    }

    return 0;
}

Vielen Dank im Voraus!

 

[mihe7]

Du hast einen Operator für die Klasse Container definiert - dann musst Du den auch auf ein Container-Objekt anwenden. Außerdem ist die Berechnung der Arraygröße falsch (size+(index-size) ist ja nichts anderes als index). Das i ist nicht vom Typ T, sondern vom Typ std::size_t. Dann bringt es nichts, wenn Du den reservierten Speicher sofort wieder freigibst.

Probiers mal so:

#include <iostream>

using namespace std;

template<class T>

class Container{
    public:
    T *dynamischesArray;
    private:
    int size;

    public:
    Container(int size){
    this->size=size;
    dynamischesArray=new T[size];
    }

    T &operator[] (size_t index){
        //Array vergrößern
        if(index>size-1){
            size = index+1;
            T* neuesArray=new T[size];

            for(size_t i=0; i<size; i++){
                neuesArray[i]=dynamischesArray[i];
            }
            delete[] dynamischesArray;
            dynamischesArray=neuesArray;

        }

        return dynamischesArray[index];
    }
};
int main()
{
    Container <int> dArray(100);
    for(int i=1; i<20000; i++){
        dArray[i] = i;
        cout << dArray.dynamischesArray[i] << std::endl;
        cout << dArray[i] << std::endl;
    }

    return 0;
}

 

[IT-homas]

Vielen Dank!

 

[kneitzel]

Öhm, irgendwie hört sich das nicht korrekt an.

            size = index+1;
            T* neuesArray=new T[size];

            for(size_t i=0; i<size; i++){
                neuesArray[i]=dynamischesArray[i];
            }

Habe ich da etwas übersehen oder greifst Du da über die Grenzen des Arrays zu?
dynamisches Array hat z.B. 10 Elemente.

Es wird auf das Element 19 zugegriffen, also ist die notwendige Größe 20 und du erzeugst ein entsprechendes Array.

Nun kopierst du aber die Elemente 0...19 von dynamischesArray (Das ja nur von 0..9 geht!).

Daher wäre mein Ansatz:
lokale Variable newSize setzen und nutzen. Dann in der for schleife size (also alte Größe) nutzen. Dann am Ende size = newSize setzen.

 

[mihe7]

Habe ich da etwas übersehen oder greifst Du da über die Grenzen des Arrays zu?

Oops.

 

[Barista]

Ist dies eine Übung?

Wenn nein, dann soltest Du std::vector verwenden.