classe et constructeur

Bonjour a tous

je vais essayer de me faire comprendre sans les codes si ce n'est pas possible je les posterais :)

en fait j'ai un problème pour les déclarations de classe :

si on a:

class X
{
    private int a;
    ...

    public:
       X( int ); // constructeur
       X( const X & );  // constructeur par recopie
};
X::X( int c  { a = c; }
X::X( const X &x) { a = x.a; }

puis dans un autre fichier:

#include"X.h"

class Y
{
    private X a1;
    private X a2;
    private int b;
    ...

    public: Y( X, X, int);
};

Y::Y(X x1, X x2, int t)
{
    a1 = new X(x1);
    a2 = new X(x2);
    b = t;
}


Si je comprends bien il n'est pas possible de déclarer
    private X a1;
    private X a2;
car il n'existe pas de constructeur sans argument pour X .. mais est il possible de faire sans puisque je crée les objets dans le constructeurs de Y ??

Il  est possible que je ne sois pas clair du tout, je m'en excuse d'avance :p

Merci

    Non, je pense que tu dois obligatoirement mettre un constructeur par défaut, quitte à ne rien mettre à l'intérieur... ca ne coute rien de toute facon.

je sais pas je trouve pas ca très "propre" :'(
merci de ta réponse je vais quand meme faire ca

c'est toujours moi :)

dans mon constructeur par recopie j'ai cette erreur :

erreur: no match for ‘operator=’ in ‘((Arc*)this)->Arc::somsrc = (((Sommet*)operator new(8u)), (<anonymous>->Sommet::Sommet(((Sommet&)(& s1))), <anonymous>))’

// ce qu'il faut savoir : Arc est une classe ayant pour attribut deux Sommets ( une autre classe ) qui sont somcrc et somdest

je ne comprends vraiment pas cette erreur ( je suis désolé, je débute )

Tu n'as pas à être désolé :-) tu pourrais me donner la ligne de code ou tu appelles ce constructeur par recopie ainsi que le prototype de ce constructeur par recopie ? j'ai un peu de mal à décrypter les messages d'erreur comme ca :)

    ah non j'avais pas vu que cette erreur était DANS le constructeur de recopie... si tu pouvais mettre la ligne de code correspondant à l'erreur ce serait bien

    En fait du devrait avoir un constructeur de recopie de la forme :

Arc::Arc(&Arc arc)
{
    this->somsrc=arc.somsrc;
    this->somdest=arc.somdest;
}

Non, de la forme:
Arc::Arc(const &Arc arc)
{
    this->somsrc=arc.somsrc;
    this->somdest=arc.somdest;
}

Tjs utiliser "const" des que possible.

Je vois pas en quoi ca ne serait pas propre, toi tu veux créer un objet sans l'initialisé, c'est encore moins PROPRE !

Sinon dans ta classe X:
class X
{
    private int a;
    ...

    public:
       X( int _val = 0); // <= Met une valeur par défaut, et ainsi, par besoin de constructeur par défaut, puisque celui la jouera ce role.
       X( const X & );  // constructeur par recopie
};

Sinon autre solution, mets ton constructeur par défaut private dans la classe X, et ajoute friend class Y dans la classe X. Comme ca, le constructeur par défaut n'existe que pour la classe Y et pas pour le programmeur hors de cette classe.

voici les deux classes :

class Arc
{
   private: Sommet somsrc; // sommet source
   private: Sommet somdest; // sommet destination
   private: int poid; // poid de l'arc

   public: Arc( Sommet, Sommet , int );
   public: int getpoid();
   public: void setpoid( int );
   public: Sommet getsource();
   public: Sommet getdestination();
   public: void setsource( Sommet s );
   public: void setdestination( Sommet s );
};



Arc::Arc( Sommet s1, Sommet s2, int p )
{
   somsrc = new Sommet(s1);   /////////// c'est ici que ce situe l'erreur
   somdest = new Sommet (s2);
   poid = p;
}


// accesseur
string Arc::getsource() { return somsrc; }
string Arc::getdestination() { return somdest; }
int Arc::getpoid() { return poid; }

// modifieur
void Arc::setsource( Sommet s ) { somsrc = s; }
void Arc::setdestination( Sommet s ) { somdest = s; }
void Arc::setpoid( int p ) { poid = p; }

void Arc::affiche()
{
   somsrc.affiche();
   cout<<"-"<<poid<<"-";
   somdest.affiche();
}



class Sommet
{
   private: string nom;
   private: bool marque;

   public: Sommet( );
   public: Sommet( string );
   public: Sommet( Sommet &);
   public: string getnom();
   public: bool getmarque();
   public: void setnom( string );
   public: void setmarque( bool );
   public: void affiche();

};
// * definition des fonctions membres de la classe Sommet

// constructeur par defaut
Sommet::Sommet( )
{
   marque = false;
   nom = "";
}

Sommet::Sommet( string n )
{
   nom = n;
   marque = false;
}

// constructeur par recopie
Sommet::Sommet( Sommet &s )
{
   nom = s.getnom();
   marque = s.getmarque();
}

// accesseur
string Sommet::getnom() { return nom; }
bool Sommet:: getmarque() { return marque; }

// modifieur
void Sommet::setnom( string n ) { nom = n; }
void Sommet::setmarque( bool b ) { marque = b; }

void Sommet::affiche() { cout<<nom<<endl; }


et voici l'erreur :

Arc.cpp:26: erreur: no match for ‘operator=’ in ‘((Arc*)this)->Arc::somsrc = (((Sommet*)operator new(8u)), (<anonymous>->Sommet::Sommet(((Sommet&)(& s1))), <anonymous>))’

pour luthor : ce que je disais c'est que lorsque on déclare un objet ca le crée en meme temps ? je pensais que le new crée un objet initialement déclaré