Discussion :

[Arnau6]

Bonjour,

je cherche a déclarer une classe en tant qu'attribut d'une autre classe.

Concrètement j ai une classe élève qui doit contenir plusieurs entités note, l'entité note étant une classe.

Pour le faire un java je procède de la manière suivante :
private LinkedList<note> les_notes;

Actuellement je bloque pour faire l’équivalent en c++
Dans mon projet j'ai 2 fichiers pour chaque classe un .h et un .cpp (pour ma classe élève et ma classe note)

Voici le code de mon fichier eleve.h

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
16
17
18
 
class eleve
{
 
private :
	note lesNotes[100];
	int id_eleve;
	string nom, prenom;
 
public :
	eleve();
	void saisir();
	void afficher();
	int retour_id();
	string retour_nom();
	string retour_prenom();
	void menu();
};

Ces erreurs sont alors générées (elle correspondent a la ligne 6) :
error C2146: syntax error : missing ';' before identifier 'lesNotes'
error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
error C4430: missing type specifier - int assumed. Note: C++ does not support default-int

en ajoutant #include "note.h" au début de mon fichier des erreurs différentes apparaissent :

error C2248: 'note::note' : cannot access private member declared in class 'note'
1> c:\users\weanz\documents\visual studio 2010\projects\architecture\architecture\note.h(10) : see declaration of 'note::note'
1> c:\users\weanz\documents\visual studio 2010\projects\architecture\architecture\note.h(3) : see declaration of 'note'

Voici le code de mon fichier note.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class note
{
 
public:
	string matiere;
	int chiffre;
 
private:
	note();
	void saisir();
	void afficher();
};

Pourriez vous m'indiquer mes erreurs et comment faire une bonne déclaration. Merci

[mitkl]

Bonjour,

le constructeur de ta classe "note" est privé, je ne pense pas que ça soit ce que tu veuilles. Ca réglera déjà un problème.

[ternel]

En effet, un tableau utilise le constructeur par défaut (ici "note();").

[Bousk]

Bonjour,

puisque tu as l'équivalent JAVA, pourquoi ne pas s'y appuyer ?

Tu dis utiliser une LinkedList, alors pourquoi choisir un tableau statique et non une list, ou mieux un vector ?

[koala01]

Salut,

Bon, déjà, on peut considérer que les objets de la classe Note ne devraient plus être modifiés une fois créés...

En effet, au moment de leur création, tu devrais connaitre non seulement la matière mais aussi la note qui est attribuée

Tu devrais donc prévoir un constructeur (publique) qui prenne... le nom de la matière et la note comme paramètre.

Seuls les accesseurs sur la valeur et sur la matière sont nécessaires, étant donné que ce sont deux propriétés de la classe

Cette classe peut parfaitement avoir sémantique de valeur étant donné qu'il se peut très bien que deux élèves différents obtiennent une note identique pour la même matière, et qu'il est donc cohérent d'envisager que les deux notes identiques se trouvent à deux adresses mémoire différentes

Ta classe Note ressemblerait donc à quelque chose de fort proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
class Note
{
    public:
        Note(std::string const & matiere, int valeur):matiere_(matiere),valeur_(valeur){}
        std::string const & matiere() const{return matiere_;}
        int note() const{return valeur_;}
    private:
        std::string matiere_;
        int valeur_;
};

Pour le reste...

Evites d'utiliser des tableaux statiques pour gérer tes notes : non seulement, tu risque fort d'exploser la pile en voulant placer 100 notes cote à cote, mais, en plus :

• Si tu ne dois au final gérer que beaucoup moins de notes, cela fait que de la place perdue inutilement (et peut etre beaucoup)
• Si, par malheur, tu te trouve à devoir gérer plus de 100 notes, tu te trouveras face à un problème
• Il faut, enfin, que tu penses à maintenir en premanance le nombre de note obtenues par l'élève pour éviter d'aller en écraser une existante avec une nouvelle

Pour toutes ces raisons, je te consellerais d'utiliser un des conteneurs fournis par le standard comme std::vector

Enfin, pour quand même te mettre sur la voie, il faut savoir que le compilateur ne connait, quand il s'occupe d'un fichier, que ce qu'il a déjà rencontré dans le fichier...

Quand il lit le fichier d'en-tete "Eleve.h", s'il n'a pas rencontré la définition de la classe Note, il va simplement te dire qu'il ne la connait pas.

Comme, en plus, il doit connaitre la taille de la classe Note, tu ne peux pas te contenter d'une déclaration anticipée.

Tu dois donc veiller à inclure la définition de ta classe Note (ou le fichier qui la contient) dans le fichier d'en-tête de ta classe Eleve

[Arnau6]

Merci pour vos réponses. En cours on m'avait toujours dis de mettre les attributs en public et mes fonctions/ procédures et le constructeur en privé.
Le fait de mettre le constructeur en public a résolu le problème.

Dans ce cas il n'est pas possible de donner accès aux fonctions déclaré en privé de la classe note uniquement pour l’élément les lesNotes ? en java quand on crée un élément de cette manière, il a accès par la suite au fonction déclaré en privé.
C'est dans un cas comme celui ci ou il faut déclarer ma classe 1 comme étant ami de ma classe 2 ?

Pourriez vous me dire ce que est le plus intéressant a utiliser entre les vecteurs et les listes, parce qu'il est vrai qu'utiliser un tableau pour stocker les notes ne semble pas être le bon choix.

[mitkl]

Merci pour vos réponses. En cours on m'avait toujours dis de mettre les attributs en public et mes fonctions/ procédures et le constructeur en privé.

Non c'est l'inverse généralement.

Je n'ai pas compris le deuxième paragraphe, quand tu fais private LinkedList<note> les_notes; en Java tu as accès aux fonctions membres privées de note ??

Pour le container, ça dépend de tes opérations, regarde de ce côté : http://cpp.developpez.com/faq/cpp/?p...hoix_conteneur

[Arnau6]

Ah oui merci mitkl j'avais tout inversé.
Ton lien est vraiment utile, cependant je ne suis pas sûr de bien comprendre le terme "fusion fréquente". Veut il exprimer le fait d'ajouter un élément a la liste ou au vecteur ?

[koala01]

Merci pour vos réponses. En cours on m'avait toujours dis de mettre les attributs en public et mes fonctions/ procédures et le constructeur en privé.

A mon avis, tu as mal compris...

Le fait de mettre quelque chose (quoi que ce soit ) en accessibilité privée fait que ce "quoi que ce soit" n'est accessible qu'aux fonctions membres de la classe en question, ou aux fonctions/classes déclarées amies (et même pas aux fonctions membre des classes dérivées )

Si tu déclares le constructeur privé, tu interdit la création d'un objet, à moins de passer par une fonction amie ou une fonction membre statique.

Et un objet qui ne pourrait pas être créé a autant d'intérêt qu'un frigo pour en alaska en plien hiver

Il y a bien certains cas pour lesquels il est intéressant de rendre le constructeur par copie et l'opérateur d'affectation ( = ) privé sans les définir, pour rendre la classe non copiable (enfin, c'était le cas avant la nouvelle norme qui permet de déclarer n'importe quelle fonction deleted ) mais il ne s'appliquent définitivement qu'aux classes ayant sémantique d'entité, et c'est donc totalement hors scope par rapport à une classe Note.

On peut aussi envisager de rendre le constructeur privé dans le cadre d'un pattern "factory", en déclarant la fabrique amie de la classe, mais, là encore, c'est un patron de conception utile pour les classes ayant sémantique d'entité, alors que ta classe note a, décidément, sémantique de valeur
Le fait de mettre le constructeur en public a résolu le problème.

Dans ce cas il n'est pas possible de donner accès aux fonctions déclaré en privé de la classe note uniquement pour l’élément les lesNotes ? en java quand on crée un élément de cette manière, il a accès par la suite au fonction déclaré en privé.

Quand tu crées une classe imbriquée, il est possible que la classe "maitresse" ait acces aux membres privés de la classe imbriquée, comme si elle avait été déclarée amie...

Cependant, dans le cas présent, la classe Note n'a strictement aucun besoin d'être imbriquée dans la classe Eleve, vu qu'elle peut tout à fait être utilisée en dehors de la classe Eleve

C'est dans un cas comme celui ci ou il faut déclarer ma classe 1 comme étant ami de ma classe 2 ?

Pour que la classe Eleve puisse construire une note alors que le constructeur de Note est privé, il faudrait, effectivement, déclarer la classe Eleve comme amie de la classe Note.

Cependant, cela risquerait fort d'inciter l'utilisateur de la classe Eleve à aller "chipoter" dans les membres de la classe Note, et ce n'est en aucun cas souhaitable, vu qu'on part du principe qu'une note n'a absolument plus à être modifiée une fois qu'elle a été construite

Pourriez vous me dire ce que est le plus intéressant a utiliser entre les vecteurs et les listes, parce qu'il est vrai qu'utiliser un tableau pour stocker les notes ne semble pas être le bon choix.

A priori, et sans savoir exactement ce que tu comptes faire des notes, je dirais que la classe vector vaut n'importe quel autre choix...

Je me base (par défaut) sur le fait que tu accéderas beaucoup plus souvent aux notes que tu n'en rajouteras, mais ce n'est qu'une supposition arbitraire et pas forcément justifiée

Sinon, le shéma indiqué par mitkl te permettra de choisir en "connaissance de cause"