3. Konstruktor für vektoren

Konstruktor für vektoren

  • ?

    Ich möchte einen Vektor von Objekten meiner Klasse "test" erstellen.
    Der Vektor enthält 20 Elemente.
    Muss ich den Konstruktor für jedes Vektorelement aufrufen????
    (in einer for-schleiefe???)

    0
  • H

    häh wie sieht dein Code aus? meinst du ein Array oder std::vector? Zeig mal was du genau meinst.

    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?

    0
  • H

    Du musst alle initialisieren. 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; 
}
    0
  • M

    web1 schrieb:

    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.

    0
  • H

    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) Man kann das natürlich gescheiter schreiben, aber das kann man dann mit dem vector auch.

    0
  • M

    HighLigerBiMBam schrieb:

    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.

    0
Anmelden zum Antworten