ich habe zwei Klassen foo und bar.

class bar {
  public:
    foo x;
    bar(foo y) {x = y;}

};

Die eine Klasse hat eine Instanz der anderen. Beide haben Konstruktoren, die aufgerufen werden müssen. Wie kann ich die Variabel x in bar initialisieren? Der Code oben funktioniert jedenfalls nicht.

class A
{
  B b_;
public:
  A(B b)
    : b_(b) // std::move?
  {}
};

danke! und wie kriege ich es hin, den Konstruktor von b_ aufzurufen, wenn das Objekt erst noch erstellt werden muss?

Der wird doch automatisch aufgerufen, wenn das Objekt erstellt wird, das ist schließlich gerade der Erstellungsprozess. Mit der Initialisierungsliste gibst du an, wie (d.h. mit welchem Konstruktor und welchen Parametern) dass b_ erstellt werden soll.

Oder verstehe ich gerade nicht, was du meinst?

vector<A> arr; //Ich habe eine Vektor mit foo-Instanzen
while(bedingung) {

  arr.push_back(//???

}

Ich möchte in einer Schleife Instanzen von A erstellen, die ich dann in arr ablege. Wie geht das in C++? Der vector arr wird dann nämlich wiederum an eine andere Klasse gegeben, die ihn verarbeitet.

Die Klasse A sieht so aus, wie cooky451 dargestellt hat.

Ich muss also verschiedene Instanzen von in einer Schleife anlegen. Wie mache ich das in C++?

Wie mache ich das in C++?

Sag es erst einmal auf Deutsch. Da fehlen ein paar entscheidende Nomen und Verben in deinen Sätzen. Keine Ahnung, was du tun möchtest. Ich rate mal:

arr.push_back(B(parameter, vom, B_Objekt));

A bekommt über den Konstruktor jetzt die Werte, die B im Konstruktor braucht, sodass B automatisch beim Anlegen von A erzeugt wird.

Nein. Oder sagen wir mal, nur bedingt. Wenn B nur einen Parameter im Konstruktor erwartet (und der nicht als explicit definiert ist), dann geht das. Man modelliert damit eine Art "ist ein", wie z.B. bei std::string:

void foo(std::string s);

int main()
{
  foo("Hallo");
}

Das ist aber eher eine Art Sonderregel, allgemein schreibt man

void foo(std::string s);

int main()
{
  foo(std::string("Hallo"));
}

Und genau so sieht das dann auch bei dir aus:

std::vector<A> v;

while(blubb)
{
  v.push_back(A(B(/* Parameter? */)));
}

Oder, wenn jedes a mit dem gleichen B erzeugt werden soll, wahlweise auch

std::vector<A> v;

B b(/* Parameter? */);
while(blubb)
{
  v.push_back(A(b));
}