header 1:

#import "B.h"

class A{
public:
    A(int a);
private:    
    B 1;
    B 2;
    B 3;
};

cpp1

#import "A.h"

A::A(int a)
{
1 = B::B(a);
2 = B::B(a);
3 = B::B(a);
}

header 2

class B{
public:
    B(int a);
private:    
 int i;
};

cpp2

#import B.h"

B::B(int a)
{
i = a;
}

Der constructor von B wird in A nicht gefunden was mach ich da falsch?
mfg

Also Import ist hier schon mal falsch. -> #include
2. Solltest du mal Initialisierungslisten anschauen.
Und 3. Namenskonventionen auch nochmal. Ein Name kann nicht mit einer Zahl anfangen.

Noch eine frage wenn ich nun in A über den constructor ein array mit 3 B elementen erzeugen will wie müsste ich dann vorgehen?

Noch eine frage wenn ich nun in A über den constructor ein array mit 3 B elementen erzeugen will wie müsste ich dann vorgehen?

Arrays gehen nicht in der Initialisierungsliste. Da kommst du nicht drum herum das im ctor selber zu machen.

array ist schon definiert

A::A(int i)
{
array[0] = B::B(10);
}

Aber ich kann nicht auf den constructor von B zugreifen

A::A(int i) 
{ 
 array[0] = B(10); 
}

der ctor wird immer in der form klasse(parameter) aufgerufen.
der aufruf B::B(10) bedeutet, dass du aus dem namespace "B" eine funktion des namens B aufrufst oder eine klasse des typs "B" erzeugst. das existiert aber beides nicht.

edit: bitte immer die fehlermeldung deines compilers mitposten. "geht nicht" ist eine sehr wage beschreibung des problems.

A.cpp:24: error: no matching function for call to `B::B()'

B.h:23: note: candidates are: B::B(const B&)

B.h:25: note: B::B(int)

constructor sieht so aus in der cpp:

A::A(int size)
{
Array[0] = B(size);
}

Irgendwie findet er die funktion nicht in der 2. cpp

c++ initialisiert jedes objekt. wenn du also ein array der form:

B array[10];

hast, werden 10 objekte des typs B erstellt. dafür ist der standard-ctor B() notwendig. der wird vom compiler selbstständig erzeugt, wenn du keine anderen ctor angibst. da du aber einen eigenen ctor definiert hast, musst du auch einen ctor der form B() definieren, wenn du den oben stehenden code nutzen willst.

sieht dann in deinem fall etwa so aus:

class B{
public:
    B();
    B(int a);
private:    
 int i;
};

B::B()
:i(0) //könnte man auch weglassen, aber dann hast du einen undefinierten wert von i
{}

B::B(int a)
:i(a)
{}

B::B(int a)
:i(a)
{}

hab ich in b ja schon.

Habe ja in beiden klassen einen constructor definiert und implementiert. in a binde ich die header.h von b ein somit kenne ich ja dessen funktionen. Nun will ich in a ein array mit objkten von b erzeugen, dazu muss ich ja den constructor von b in a aufrufen und ihm den parameter übergeben. So und an der stelle scheitert es auch, ich kann nicht auf den constructor zugreifen der compiler meckert dann immer das es eben diesen constructor nicht geben würde.

über B::B(int i) sage ich ihm doch, das er den constructor im "namespace" von B findet oder nicht?

bei B::B(int) musst du unterscheiden. wenn du den ctor implementierst bezieht es sich auf den member von B. das ist der code "B::B(int a):i(a){}".
wenn du den aufruf "B::B(1);" schreibst, beziehst du dich auf eine funktion/objekt im namespace B. du hast aber gar keinen namespace B definiert.

damit "B::B(1);" legal wäre,müsstest du so etwas hier schreiben:

namespace B{
  class B{
  public:
	B(int a):i(a){}
  private:
	int i;
  };
}