Array mit elementen erweitern

[FBIagent]

Moin,

wie im Betreff schon gesagt möchte ich ein Array mit elementen erweitern.
Dazu habe ich auch schon etwas Code geschrieben.
Die Klasse beinhaltet eine methode add(std::string);, diese soll das private Array
(pointer) der Klasse um ein Element erweitern.

Nur ist im nachhinein bei der Ausgabe nur 1 Element dort:

class extraStrList
{
private:
    int _elementsCount;
    std::string *_data;
public:
    extraStrList()
    {
        _elementsCount = 0;
    }
 
    ~extraStrList()
    {
        delete[] _data;
    }
 
    void add(std::string newData)
    {
        std::string *dataTemp = new std::string[_elementsCount+1];
 
        for (int i=0;i<_elementsCount;i++)
          dataTemp[i] = _data[i];
 
        if (_elementsCount > 0)
            delete[] _data;
 
        dataTemp[_elementsCount] = newData;
        _data = new std::string[_elementsCount+1];
        *_data = *dataTemp;
        delete[] dataTemp;
        _elementsCount++;
    }
 
    std::string get(int element)
    {
        return _data[element];
    }
 
    int elementsCount()
    {
        return _elementsCount;
    }
};

Dies gibt mir bei volgendem Testprogramm

#include <iostream>
#include ".\extraStrList.h"
 
int main()
{
    extraStrList strList;
 
    strList.add("eins");
    strList.add("zwei");
    strList.add("drei");
    strList.add("vier");
    strList.add("fünf");
 
    for (int i=0;i<strList.elementsCount();i++)
        std::cout << i << ": " << strList.get(i) << std::endl;
 
    system("Pause");
 
    return 0;
}

folgenden output

0: eins
1:
2:
3:
4:
Drücken Sie eine beliebige Taste . . .

Wäre nicht schlecht wenn ihr mir mit dem anhängen von Elementen helfen könntet.

THX im Vorraus,
FBIagent

 

[Matthias Reitinger]

Hallo,

in Zeile 29 kopierst du lediglich das erste Element von dataTemp nach _data (die Zeile ist gleichbedeutend mit _data[0] = dataTemp[0];). Wenn du bei deinem Algorithmus bleiben willst, müsstest du also die Elemente in einer weiteren Schleife Stück für Stück nach _data übertragen. Du kannst es dir aber auch etwas leichter machen und auf das zweimalige allokieren von Speicher verzichten:

class extraStrList
{
private:
    int _elementsCount;
    std::string *_data;
public:
    extraStrList()
    {
        _elementsCount = 0;
        _data = NULL;
    }

    ~extraStrList()
    {
        if (_data != NULL) delete[] _data;
    }

    void add(std::string newData)
    {
        std::string *dataTemp = new std::string[_elementsCount+1];

        std::copy(_data, &_data[_elementsCount], dataTemp);
        dataTemp[_elementsCount] = newData;

        if (_data != NULL) delete[] _data;
        _data = dataTemp;

        _elementsCount++;
    }

    std::string get(int element)
    {
        return _data[element];
    }

    int elementsCount()
    {
        return _elementsCount;
    }
};

Aber mal ganz abgesehen davon: warum benutzt du nicht einfach einen std::vector?

Grüße,
Matthias

 

[FBIagent]

std::copy(_data, &_data[_elementsCount], dataTemp);
Das copy hörrt sich gut an.
Folgendes zu den Parametern:
_data <- das was kopiert wird?
&_data[_elementsCount] <- ? wofür ? soll angeben welche größe?
dataTemp <- klar da wos rein kommt

Was wäre denn die performantere variante. Das mit dem immer wieder Reservieren
und Freigeben oder die copy Variante.

Aber mal ganz abgesehen davon: warum benutzt du nicht einfach einen std::vector?

Ich habe mir gedacht das direkter Array zugriff performanter ist als einen vector zugriff.

MFG,
FBIagent

 

[Matthias Reitinger]

std::copy(_data, &_data[_elementsCount], dataTemp);
Das copy hörrt sich gut an.
Folgendes zu den Parametern:
_data <- das was kopiert wird?
&_data[_elementsCount] <- ? wofür ? soll angeben welche größe?
dataTemp <- klar da wos rein kommt

Siehe http://cppreference.com/cppalgorithm/copy.html

Was wäre denn die performantere variante. Das mit dem immer wieder Reservieren
und Freigeben oder die copy Variante.

Der Aufruf von std::copy ersetzt hier nur die Schleife, die in deinem Code in Zeile 21–22 stand. Es muss trotzdem immer noch Speicher reserviert und wieder freigegeben werden. Welche Lösung schneller ist, hängt von der Implementation von std::copy ab.

Ich habe mir gedacht das direkter Array zugriff performanter ist als einen vector zugriff.

Ein std::vector speichert seine Daten (i.d.R.) auch in einem Array. Da die STL-Implementierungen meist sehr optimierte Algorithmen verwenden, kommt man mit eigenen Reimplementierungen bestenfalls an die Performance der STL heran, liegt damit meist aber eher weit darunter. Daher macht es hier keinen Sinn, das Rad neu zu erfinden.

Grüße,
Matthias