ich hab gerade versucht, ein C-Array von Objekten zu erstellen. Allerdings bekomme ich die Fehlermeldung "Binärer Operator '=': Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operanden vom Typ 'stuff *' akzeptiert".

class stuff  {
private:
	int x;
};

int main(int argc, char* argv[]) 
{
	// geht
	int* x = new int[10];
	for(int i = 0; i < 10; i++){
		x[i] = i;
	}

	// geht nicht
	stuff* arr = new stuff[10];
	for(int i = 0; i < 10; i++)  {
		arr[i] = new stuff; // Fehlermeldung
	}
	return 0;
}

Hab schon lange kein C++ mehr programmiert. Ich dachte immer, dass man ein Array von Objekten genauso wie ein Array von Integern (oder anderen primitiven Datentypen) erstellen kann. Oder habe ich hier irgendwo einen Denkfehler drinn?

Hab schon lange kein C++ mehr programmiert. Ich dachte immer, dass man ein Array von Objekten genauso wie ein Array von Integern (oder anderen primitiven Datentypen) erstellen kann. Oder habe ich hier irgendwo einen Denkfehler drinn?

Wie erstellst du denn ein Array aus int?

int* arr = new int[10];
    for(int i = 0; i < 10; i++)  {
        arr[i] = i;
    }

und warum dann hier plötzlich new?

stuff* arr = new stuff[10];
    for(int i = 0; i < 10; i++)  {
        arr[i] = new stuff; // Fehlermeldung
    }

ich hab gerade versucht, ein C-Array von Objekten zu erstellen. Allerdings bekomme ich die Fehlermeldung "Binärer Operator '=': Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operanden vom Typ 'stuff *' akzeptiert"...

Ich dachte immer, dass man ein Array von Objekten genauso wie ein Array von Integern (oder anderen primitiven Datentypen) erstellen kann.

1. Dann tue es aber auch bitte wie bei dem int-Array. Du versucht einen Zeiger einem Objekt zuzuweisen (Dein Array enthält nach deinem Code Objekte, nicht Zeiger - du weist ja auch nicht dem int-Array new-Allozierte Werte zu).

2. Zu jedem new gehört ein delete, zu jedem new[] ein delete[]. In deinem Fall sind alle new ohnehin hinfällig, warum schreibst du nicht einfach:

//...
int x[10];
for(int i = 0; i < 10; i++)
  x[i] = i;

stuff arr[10];
for(int i = 0; i < 10; i++)
    arr[i] = stuff(); // Konstruktor + Zuweisungsoperator
//...

3. Wie wäre es mit der C++ Alternative (std::vector, std::tr1::array)?

// Für Variante 1
#include <vector>
// Für Variante 2 (Falls bereits vom Compiler unterstützt, oder z.B.
//                 durch boost nachgerüstet)
#include <array>

//...

int main()
{
    // Variante 1 (Dynamisch Wachsender Vektor)
    // Durch anhängen
    std::vector<stuff> arr;
    for(int i=0; i<10; ++i)
        arr.push_back(stuff());

    // Durch Initialisierung mit Standardkonstruktor für 10 Elemente
    std::vector<stuff> arr2(10);

    // Variante 2 (Array fester Größe)
    // Durch direktes Setzen (Ist aber bereits mit jeweils den Standard-
    // konstruktor initialisiert).
    std::tr1::array<stuff, 10> arr3;
    for(int i=0; i<10; ++i)
        arr2[i] = stuff();
}

cu André

Wie erstellst du denn ein Array aus int?

int* arr = new int[10];
    for(int i = 0; i < 10; i++)  {
        arr[i] = i;
    }

und warum dann hier plötzlich new?

stuff* arr = new stuff[10];
    for(int i = 0; i < 10; i++)  {
        arr[i] = new stuff; // Fehlermeldung
    }

Ja klar ... ich hätts so machen müssen:

stuff** arr = new stuff*[10];

Naja manchmal übersieht man solche Sachen einfach Normalerweise hätte ich das auch mit einem Vector gemacht (so wie in asc's Beispiel). Aber ich musste jetzt noch rausfinden, was an der C-Array Variante falsch war (das delete[] hatte ich absichtlich weggelassen).

Danke euch beiden.

...

Wenn die Elemente wirklich als Zeiger gehalten werden sollen, gibt es noch weitere Alternativen:

a) Datenhaltung über boost::shared_ptr bzw. std::tr1::shared_ptr
b) Boost Pointer Container Library

cu André

stuff::stuff(int i)
{
  m_items = new int[i];
}

stuff &stuff::operator=(const stuff &rhs)
{
   // destroy m_items
   // alloc m_items
   // copy from rhs
   return *this;
}

// ...

 stuff *arr = new stuff[dynamicSize]; 
for(int i = 0; i < 10; i++) 
     arr[i] = stuff(i); // Konstruktor + Zuweisungsoperator 
// ...

delete [] arr;

, denn
- new stuff[dynamicSize] allokiert "sizeof(stuff) * dynamicSize" Bytes (nicht initialisiert)
- arr[i] = stuff(i) ruft auf: 1. stuff(i) 2. arr[i].operator=(stuff(i))

Nachdem das Array nicht initialisiert wurde können bei dem operator= Probleme auftreten. Oder wird bei "new anyclass[amount]" automatisch der default ctor aufgerufen?

Besten Dank, ich steh diesbzgl. auf der Leitung.

Oder wird bei "new anyclass[amount]" automatisch der default ctor aufgerufen?

Ja. IMHO hättest dafür aber nicht einen 3 Jahre alten Thread reaktivieren müssen.