Discussion :

[Drannor]

Bonjour,

Comme l'indique le titre je souhaite coder une classe qui inclus des variables représentant d'autre classe que j'ai précédément codées. Seulement, néophyte en c++, j'ai un problème dont la FAQ ne m'a pas donné la réponse de manière claire.

Comme l'exemple ci-dessous le montre, je souhaite créer des variables pivées qui sont en faites des variables représentant les classes incluses. Seulement, je ne sais pas comment les déclarer en privates sans pour autant appeler le constructeur (si il s'appele) de chacune des classes qu'elles représentent car je ne dispose pas encore des paramètres nécessaire à leur constructeur.

Et si le constructeur ne s'appele pas quand je les déclare en private, comment faire pour l'atteindre une fois dans le constructeur de la class que je suis entrain d'écrire ?

Merci D'avance

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "classeX.h"
#include "classeY.h"
 
private :
         classeX::varX ;
         classeY::varY ;
 
 
class maClasse{
//constructeur
           maClasse(int x, int y){
              varX(x);
              varY(y);
           }
}

[Luc Hermitte]

Si tu ne disposes pas des paramètres nécessaires, les seules façons, que je vois à cette heure-ci, de retarder la construction (sans payer une construction par défaut), c'est :
- de réorganiser ton code pour sortir (/faire apparaitre) des fonctions qui vont calculer ce dont tu as besoin pour les constructions
- de ne plus composer directement, mais via pointeur -- un boost::scoped_ptr ou un std::auto_ptr sont très bien pour obtenir le même niveau d'aggrégation que si tu avais des attributs non pointeurs.

[boromir73]

Ta syntaxe est incorrecte.

Si varX doit être un objet de type classeX , alors il doit être déclaré ainsi : classeX varX; .

Si tu veux que varX et varY soient des membres privés de maClasse, c'est à l'intérieur de celle-ci qu'il faut les déclarer.

Les paramètres nécessaires à la construction de varX et varY doivent être placés dans la liste d'initialisation du constructeur de maClasse.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
#include "classeX.h"
#include "classeY.h"
 
class maClasse {
public: // Je suppose que tu veux pouvoir instancier ta classe
 maClasse(int x, int y): varX(x), varY(y) {}
 
private:
 classeX varX;
 classeY varY;
}; // Ne pas oublier le ';'

[Drannor]

Merci à vous deux.

La première solution est trop obscur pour moi :s

Pour la seconde solution, il n'est donc pas nécessaire en c++ par rapport au C, de déclarer les variables avant de les utiliser ?

edit : je viens de tester et il me donne des références indéfinies, je pense que c'est dû au fait que je les déclare après.

[boromir73]

il n'est donc pas nécessaire en c++ par rapport au C, de déclarer les variables avant de les utiliser ?

Au contraire, c'est exactement comme le C. En C, l'instruction "int x;" déclare ET initialise x (mais à une valeur aléatoire).

La classe maClasse n'utilise pas les variables varX et varY.
"classeX varX" déclare varX.
"varX(x)" initialise varX.

C'est comme si on mettait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
classeX varX(x); // déclaration-initialisation de varX (en C : "int x=42;" par exemple)
classeY varY(y); // idem pour varY

La liste d'initialisation est une particularité du constructeur qui permet de séparer visuellement ces 2 étapes.

[Drannor]

C'est bon !
Ca marche !!!!

Merci beaucoup.

L'erreur venait de moi, je croyais qu'en C++ comme en java quand ma classe avait besoin d'autre classe, elle les compilait automatiquement pour user du .o mais en faites c'est pas le cas.

J'ai du tout rajouter dans le make et là ça fonctionne (enfin faut que je teste voir si c'est vraiment initialiser mais au moins ça compile )

Merci encore

juste une derniere chose :

pourquoi :

maClasse(int x,int y){
varX(x);
varY(y);
}

n'est pas la même chose que :

maClasse(int x,int y): varX(x),varY(y) {};

Car dans mon cas de figure, le premier marche mais pas le second.

[Laurent Gomila]

maClasse(int x,int y){
varX(x);
varY(y);
}

Là tu tentes d'appeler l'opérateur () sur tes variables avec comme paramètre un entier, opérateur qui j'imagine n'a pas été défini.

La syntaxe de la liste d'initialisation n'est valide que dans la liste d'initialisation.

C'est exactement la même différence qu'ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int i(42); // Constuit et initialise i à 42
 
int i;
i(42); // keskecékça ???

Car dans mon cas de figure, le premier marche mais pas le second.

Ce ne serait pas plutôt le contraire ?

[boromir73]

La solution avec la liste d'initialisation ne fonctionne pas ? Etrange, ça devrait être le contraire. Peut-être est-ce une particularité de ton compilateur (il suit des normes que j'ignore dans ce cas) ?

Normalement, "varX(x);" devrait appeler l'opérateur classeX::operator()(int), et ça c'est bien une utilisation de l'objet varX, ce qui suppose que varX a été créé avec un constructeur par défaut, ce qui nécessiterait comme définition de classeX (par exemple) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
class classeX {
public:
 void operator()(int x) { this->x = x; }
private:
 int x;
};

Pour fonctionner avec la liste d'initialisation, classeX devrait plutôt ressembler à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
class classeX {
public:
 classeX(int x): x(x) {}
private:
 int x;
};

[Matthieu Brucher]

Merci à vous deux.

La première solution est trop obscur pour moi :s

Mais non, mais non Regarde mon tuto sur les pointeurs intelligents, ça t'aidera : http://miles.developpez.com/tutoriel...oost/smartptrs

[Drannor]

Oui c'était bien le contraire.
Merci beaucoup

Je vais lire le tuto pour apprendre les pointeurs intelligents;

Merci encore