Module movModules[ readin.getnumModules() - readin.getnumTerminals() ]

Von der Klasse Module wird ein Array angelegt das eine variable Menge an Array-Elementen enthält. Wird der Konstruktor gleich für jedes Array-Element aufgerufen?
Wie könnte man unterschiedliche Konstruktoren für die Einzelnen Elemente definieren?

#include <vector>
#include <iostream>

using namespace std;

class MyClass
{
public:
	MyClass(int a, int b, int c) : a(a), b(b), c(c) {}´
    //Mehr Konstuktoren etc...

	void Print()
	{
		cout << "a: " << a << "b: " << b << "c: " << c << endl;
	}

private:
	int a, b, c;
};

int main() 
{ 
	vector <MyClass> myclasses;

	myclasses.push_back(MyClass(1,2,3));
	myclasses.push_back(MyClass(4,7,3));
	myclasses.push_back(MyClass(1,4,3));
	myclasses.push_back(MyClass(4,3,3));

	for(vector <MyClass>::iterator i = myclasses.begin(); i != myclasses.end(); ++i)
		i->Print();

    return 0; 
}

Ich meinte das folgendermaßen:

Module movModules[ readin.getnumModules() - readin.getnumTerminals() ]

Von der Klasse Module wird ein Array angelegt das eine variable Menge an Array-Elementen enthält. Wird der Konstruktor gleich für jedes Array-Element aufgerufen?
Wie könnte man unterschiedliche Konstruktoren für die Einzelnen Elemente definieren?

Ein solches Array mit variabler Elementanzahl ist in C++ nicht möglich. Der Compiler spuckt dir einen Fehler aus, dass die Anzahl der Elemente konstant sein soll.

Wenn du eine Konstante wählst, dann werden auch die Konstruktoren aufgerufen:

#include <iostream>

struct MyClass
{
	MyClass() : value(42)
	{
		std::cout << "constructor call" << std::endl;
	}

	int value;
};

int main()
{
	MyClass foo[10];
	std::cout << foo[0].value << std::endl;
}

Ausgabe:

constructor call
constructor call
constructor call
constructor call
constructor call
constructor call
constructor call
constructor call
constructor call
constructor call
42

HighLigerBiMBam schrieb:

std::vector ist da deutlich komfortabler...

#include <vector>
#include <iostream>

using namespace std;

class MyClass
{
public:
	MyClass(int a, int b, int c) : a(a), b(b), c(c) {}´
    //Mehr Konstuktoren etc...

	void Print()
	{
		cout << "a: " << a << "b: " << b << "c: " << c << endl;
	}

private:
	int a, b, c;
};

int main() 
{ 
	vector <MyClass> myclasses;

	myclasses.push_back(MyClass(1,2,3));
	myclasses.push_back(MyClass(4,7,3));
	myclasses.push_back(MyClass(1,4,3));
	myclasses.push_back(MyClass(4,3,3));

	for(vector <MyClass>::iterator i = myclasses.begin(); i != myclasses.end(); ++i)
		i->Print();

    return 0; 
}

std::vector ist zum Befüllen nicht komfortabler, sondern im Gegenteil richtig ätzend, wie du selbst mit deinem Code zeigst. Das hat sich aber zum Glück mit boost::assign geändert und wird sich mit dem kommenden Standard ebenfalls verbessern.

MyClass *myclass = new MyClass[5];

Ich kann jetzt zwar allen den selben Konstruktor geben, muss aber wenn ich unterschiedliche Initialisierungen haben will. Extra Funktionen Aufrufen. Das habe ich im Fall des Vektors nicht. Da stellt sich echt die Frage, was hässlicher ist?

MyClass *myclass = new MyClass[5]
MyClass[0].Init(1,2,3);
MyClass[1].Init(4,7,3);
MyClass[2].Init(2,2,3);
MyClass[3].Init(1,4,3);
MyClass[4].Init(1,2,8);

//oder Vektor verwenden

Hier muss ich auch noch 2-mal Werte zuweisen. (Konstruktor und Init) Man kann das natürlich gescheiter schreiben, aber das kann man dann mit dem vector auch.

Ich finde nicht, dass ein Defaultkonstruktor eine gescheite Initialisierungsmöglichkeit bietet bzw. ist!

MyClass *myclass = new MyClass[5];

Ich kann jetzt zwar allen den selben Konstruktor geben, muss aber wenn ich unterschiedliche Initialisierungen haben will. Extra Funktionen Aufrufen. Das habe ich im Fall des Vektors nicht. Da stellt sich echt die Frage, was hässlicher ist?

MyClass *myclass = new MyClass[5]
MyClass[0].Init(1,2,3);
MyClass[1].Init(4,7,3);
MyClass[2].Init(2,2,3);
MyClass[3].Init(1,4,3);
MyClass[4].Init(1,2,8);

//oder Vektor verwenden

Hier muss ich auch noch 2-mal Werte zuweisen. (Konstruktor und Init)

Wenn man Placement New (OP: googlen!) benutzt, bekommt man die unterschiedlichen Initialisierungen mit unterschiedlichen Konstruktoren und die doppelte Zuweisung und die Init-Funktionen (igitt) fallen weg. (Edit: Ein zusätzliches memset() muss man wahrscheinlich in Kauf nehmen).

Wenn man eine variable Anzahl von Elementen unterschiedlich initialisieren will, sehe ich den Schreibarbeitsvorteil weder bei Arrays noch bei std::vector. Wenn es eine konstante Anzahl ist, sind Arrays allerdings weniger Arbeit.