Was stimmt hiermit nicht!?

Wenn ich folgenden Array-Code in einer Funktion verwende, kackt das Programm nach Beendigung dieser Funktion ab... ich hab keine Ahnung woran es liegen könnte, habt ihr ne Idee?

template <typename T>
class Array
{
public:
    Array()
    {
        m_size=0;
        m_data=new T[0];
    }
    Array(u32 size)
    {
        m_data=new T(size);
        m_size=size;
    }

    T &operator[] (u32 pos)
    {
        return m_data[pos];
    }

    inline u32 getSize()
    {
        return m_size;
    }

    inline T* getData()
    {
        return m_data;
    }

    void resize(u32 newSize)
    {
        if(newSize==0)
        {
            //delete(m_data);
            m_data=new T[0];
            m_size=0;
        }

        if(m_size==0)
        {
            m_data=new T(newSize);
            m_size=newSize;
            return;
        }
        T* tmp = new T[m_size<newSize?m_size:newSize];
        for(u32 i=0;i<m_size;i++)
        {
            if(i>=newSize)
                break;
            tmp[i]=m_data[i];
        }

        //delete(m_data);
        m_data=tmp;
        m_size=newSize;
    }

protected:
private:
    T* m_data;
    u32 m_size;
};

Fellhuhn

a) Destruktor fehlt
b) m_data=new T(size); müsste T[size] sein.

l'abra d'or

() != []
Du willst, dass m_data ein array ist. Deshalb willst du immer new[] verwenden.

// btw:
Du hast gewaltig dicke Memoryleaks drinnen. new[] einfach über das alte Objekt lässt letzteres bis Programmende im SPeicher rumgeistern

Fellhuhn

Und nicht delete(m_data); sondern delete[] m_data;

Registrierter Troll

c) deletes sind auskommentiert
d) delete ist keine Funktion
e) man benutzt delete[] auf Speicher der mit new[] angefordert wurde
f) es gibt std::vector und boost::array

Ja, ich nutz sonst auch immer std::vector, aber ich brauch das, um Pakete fürs Netz zu bauen, daher muss das Array 1. flexibel in seiner Größe (wie bei vector), aber 2. auch direkt als zusammenhängender Datensatz - zb für memcpy o.ä. - ansprechbar sein.. Geht sowas etwas auch mit std::vector?

std::vector garantiert, dass alle Daten am Stück im Speicher hängen - std::vector ist ein variables Array. Sonst könntest du ja std::list nutzen, was eine verkettete Liste ist.

Achsooooooo! Und wie greift man direkt darauf zu?

Fellhuhn

zB &myVector[0]

Manchmal sieht man den Wald vor lauter Pointern nicht... Vielen Dank euch allen!

DocShoe

Fellhuhn schrieb:

zB &myVector[0]

Aber vorher das

if( !myVector.empty() )
{
  ...
}

nicht vergessen, sonst rappelt´s im Karton

Fellhuhn

Rappelnde Kartons sind meist interessanter als das was vorher drin war. Sagen zumindest meine Katzen.