Discussion :

[kiroukou]

Bonjour à tous,
Voila j'avance doucement avec le C++ mais il y a des choses qui m'échappent encore
Je vous joins ma classe, j'ai mis des commentaires là où il y a des problèmes.
D'autres fichiers sont nécéssaires pour compiler, mais je pense que mon probleme est tellement simple que vous n'aurez pas besoin de tester, en regardant ca devrai vous suffir

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
//Classe abstraite qui servira de base pour tous les autres objets du projet
class Basic
{
	public :
			CompilManager& 	_rManager;
			Basic&		_rFils;
			Basic&		_rParent;
			Basic&		_rSuivant;
			int		_id;
 
			//Constructeurs
			Basic(CompilManager&, Basic&, Basic&, Basic&);
			Basic(CompilManager&);
			//Constructeur de copie
			Basic(const Basic& b)
			:	_rManager (b._rManager)	,
				_rParent (b._rParent)		,
				_rSuivant (b._rSuivant)		,
				_rFils (b._rFils)			
			{
				_id = b._id; //On peut pas mettre getId car le parametre est en const!! A se souvenir	
			}
			// DESTRUCTEUR
			inline ~Basic(){ std::cout << "Basic detruit" << std::endl; }
 
			//Methode virtuelle pure , qui fait de cette classe une classe abstraite
			virtual string	convertASM(void) = 0;
			//Getters
			Register& 		getFreeRegister(const int) const;
			Basic& 		getNext(void) const;
			Basic& 		getParent(void) const;
			Basic& 		getChild(void) const;
			CompilManager& 	getManager(void) const;
			int			getId(void) const;
			//setters
			void 			setNext(Basic&);
			void 			setChild(Basic&);
			void 			setParent(Basic&);
			void 			setManager(CompilManager&);
 
//Ne ps oublier ce *!&$ù*" de point virgule a  la fin !!			
};
 
Basic::Basic(CompilManager& manager)
	://Initialisation des references  => erreurs comme quoi les autre references ne sont pas initialisées pourquoi et comment??
	_rManager(manager)			
{
	_id = _rManager.getId();
	cout << "Basic instancie" << _id << endl;
}
 
 
Basic::Basic(CompilManager& manager,Basic& parent, Basic& suivant, Basic& fils)
	://Initialisation des references
	_rManager(manager)	, 
	_rParent(parent)		,
	_rSuivant(suivant)		, 
	_rFils(fils)		
{
	_id = _rManager.getId();
	cout << "Basic instancie" << _id << endl;
}
 
 
Register& Basic::getFreeRegister(const int type ) const
{	
	Register r;
	return r; //Warning ici mais c'est normal, c'est juste un code temporaire
	/*
	if( _rManager.getRegisterManager().getFreeRegister(type, r) == false )
	{
		cout << "Basic.getFreeRegister / Impossible d'avoir un registre de libre "<<endl;
	}
	return r;
	*/
}
 
Basic& Basic::getNext(void) const
{
	return  _rSuivant;
}
 
Basic& Basic::getParent(void) const
{
	return _rParent;
}
Basic& Basic::getChild(void) const
{
	return _rFils;
}
CompilManager& Basic::getManager(void) const
{
	return _rManager;
}
int Basic::getId(void) const
{
	return _id;
}
 
 
void 	Basic::setNext(Basic& b)
{
	_rSuivant = b; // Le compilo semble détester cette synthaxe ....  Pourquoi?
}
void Basic::setChild(Basic& b)
{
	_rFils = b;
}
void Basic::setParent(Basic& b)
{
	_rParent = b;
}
 
void Basic::setManager(CompilManager& c)
{
	_rManager = c;
}

Pour faciliter votre réponse voila ce que me sort le compilo chez moi :

In file included from main.cpp:14:
classes/Basic/Basic.h: In constructor `Basic::Basic(CompilManager&)':
classes/Basic/Basic.h:53: error: uninitialized reference member `Basic::_rFils'
classes/Basic/Basic.h:53: error: uninitialized reference member `Basic::_rParent'
classes/Basic/Basic.h:53: error: uninitialized reference member `Basic::_rSuivant'
classes/Basic/Basic.h: In member function `Register& Basic::getFreeRegister(int) const':
classes/Basic/Basic.h:73: warning: reference to local variable `r' returned
classes/Basic/Basic.h: In member function `Basic& Basic::operator=(const Basic&)':
classes/Basic/Basic.h:109: error: non-static reference member `CompilManager&Basic::_rManager', can't use default assignment operator
classes/Basic/Basic.h:109: error: non-static reference member `Basic&Basic::_rFils', can't use default assignment operator
classes/Basic/Basic.h:109: error: non-static reference member `Basic&Basic::_rParent', can't use default assignment operator
classes/Basic/Basic.h:109: error: non-static reference member `Basic&Basic::_rSuivant', can't use default assignment operator

Je precise que j'ai regardé sur le forum et dans la FAQ sans succés. J'espère ne pas avoir mal regardé..

En vous remerciant
++

[mtopoloff]

REmplacer :

Code :

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

1
2
3
4
5
 
         CompilManager&    _rManager; 
         Basic&      _rFils; 
         Basic&      _rParent; 
         Basic&      _rSuivant;

Par :
Si tu maintiens une copie :

Code :

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

1
2
3
4
5
 
         CompilManager    _rManager; 
         Basic      _rFils; 
         Basic      _rParent; 
         Basic      _rSuivant;

Si tu veux un pointeur :

Code :

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

1
2
3
4
5
 
         CompilManager*    _rManager; 
         Basic*      _rFils; 
         Basic*      _rParent; 
         Basic*      _rSuivant;

[kiroukou]

Salut mtopoloff et merci pour ta réponse très rapide
Mais si je veux que mes membres soient des references ? Cela n'est pas possible?
[EDIT]
J'ai testé ta solution pour les copies. Cela ne marche pas non plus .....
[/EDIT]
Merci

[DestyNov@]

Mais si je veux que mes membres soient des references ?

ben oui mais des références de quoi ? il me semble que les références ne sont utilisables seulement pour un passage de paramètres dans des fonctions. en fait le passage par référence a été "inventé" pour simplifier l'utilisation des pointeurs. en fait après dans ta fonction tu utilises les variables passées par référence comme des variables normales. 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
16
17
18
19
20
21
 
void fonction1(int &n)
{
      n=1;
}
void fonction2(int n)
{
     n=2;
}
 
void fonction3(int *n)
{
     *n=3;
}
void fonction4()
{
      int nb=4;
      fonction1(n); //n est alors égal à 1
      fonction2(n); //n est toujours égal à 1
      fonction3(&n); //on passe l'adresse de n et n est égal à 3
}

j'espère avoir répondu à la question. ++

[kiroukou]

MErci de ta réponse
En fait je connais le principe des references Le probleme est que je ne sais pas comment m'en servir correctement dans les classes, surtout pour les initialiser... La synthaxe du C++ m'est encore tres peu familiere.

En fait mon problème ne viendrait'il pas que l'on ne peut pas avoir de reference sur une classe abstraite? on ne peut avoir que des pointeurs n'est ce pas?
Car là j'ai changé avec des pointeurs et je n'ai plus les meme erreurs(oui car il y en a toujours lol)

Merci encore
++

[DestyNov@]

en fait tu ne peux tout simplement pas déclarer de variable en tant que référence tout court !

la référence n'est utilisé que dans le passage de paramètre pour une fonction.

en fait si tu déclares une variable comme ça :

Code :

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

int &n;

... en fait je ne sais pas trop ce qu'il fait, car &n va aller pointer sur l'adresse de la variable n, et n... n'existe pas. donc il plante. donc le compilateur ne le laisse pas passer.

[kiroukou]

Ouais bien sur. Tu as raison.
Ce que me gene c'est que parfois cela passe.. Il va falloir que l'aille changer ca vite fait

Merci de ton aide
++

[DestyNov@]

en fait je n'avais pas raison. du moins pas tout fait.
tu peux aller jeter un coup d'oeil ici :
http://c.developpez.com/faq/cpp/?pag...TION_reference

Les références sont souvent utilisées lors du passage de paramètres

donc pas tout le temps
++

[kiroukou]

Ouais en effet,
JE viens de faire qq tests d'ailleurs à ce sujet, j'aimerai avoir votre avis sur leur pertinence :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class Test
{
	public :
		 int val;
		 Test(int&);
};
 
Test::Test(int& laval)
{
	val = laval;
}

et

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class Test
{
	public :
		 int& val;
		 Test(int&);
};
 
Test::Test(int& laval)
:
val(laval)
{
	;
}

et le main

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include <iostream>
#include "Test.h"
int main(void)
{
	int a = 4;
	Test t =  Test(a);
	std::cout << "val de test " << t.val << std::endl;
	return 0;
}

Les résultats sont les mêmes. Que vous pouvez vous dire come critique ou comme suggestion?

Merci
++

[DestyNov@]

Pour tes tests, c'est normal que tu obtiennes le même résultat : en fait, dans les deux cas, c'est la variable membre que tu initialises avec ton passage par référence. il faudrait faire l'inverse :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Class Test
{
   public :
            int val;
            Test(int &laval);
};
 
Test::Test(int &laval)
{
        val=1;
         laval=val;
}

ne donnera pas le même résultat que :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Class Test
{
   public :
            int val;
            Test(int laval);
};
 
Test::Test(int laval)
{
        val=1;
         laval=val;
}

parce que laval est passé en recopie et non en référence. le passage par référence a le même but que le passage par pointeur : modifier la valeur ou l'objet passé en paramètre. la seule différence entre les deux, c'est que le pointeur = l'adresse de la variable, la référence = la valeur de la variable. c'est pas facile à expliquer, car je m'embrouille moi-même là... j'espère que tu as compris quand même

[Laurent Gomila]

On peut tout à fait avoir une référence en donnée membre (et c'est souvent utilisé), seulement celle-ci doit impérativement être initialisée dans la liste d'initialisation. Même combat que pour les données membres constantes.

Dans le second exemple de kiroukou, si a est modifié alors la donnée membre val le sera aussi, contrairement au 1er exemple.

[DestyNov@]

Mais je ne vois pas l'intérêt de déclarer une référence en variable membre d'une classe. pour un pointeur ok, c'est pour le créer dynamiquement ensuite, mais une référence ?

Merci ++

[Laurent Gomila]

Eh bien pour pointer sur une variable. En fait tu auras besoin d'un pointeur seulement dans certains cas : si tu veux gérer la durée de vie de la variable, ou changer le pointage en cours de route. Pour tout le reste une référence sera préférable.
Bon je n'ai pas d'exemple concret sous la main là, mais crois moi il en existe beaucoup

[kiroukou]

Salut,
désolé d'avoir mis autant de temps pour répondre et vous remercier de vos reponses .

Loulou aurais tu la raison de ceci ?

Code :

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

1
2
3
4
5
6
7
8
 
Basic::Basic(CompilManager& manager)
   ://Initialisation des references  => erreurs comme quoi les autre references ne sont pas initialisées pourquoi et comment??
   _rManager(manager)         
{
   _id = _rManager.getId();
   cout << "Basic instancie" << _id << endl;
}

En fait je vois bien que les autres references ne sont pas initialisée, mais coment les initialiser a null ?
Merci encore

++

[rolkA]

Tu ne peux pas les initialiser à null, elles DOIVENT être initialisées sur une variable...
Personnellement je trouve que les références apportent énormément + de problèmes que les pointeurs et je les utilise uniquement en tant que référence constante dans les paramètres de fonctions (const string& par exemple)... Pour le reste => pointeur intelligent.
D'ailleurs Bjarne Stroustrup lui-même est d'accord.

[kiroukou]

salut et meci de ta reponse.
en fait du coup je ne sais pas quoi penser.... D'un coté je viens du C avec les bien connus pointeurs, et de l'autre j'ai appri l'objet avec un language qui n'utilise que des references (comme le Java). Du coup avec le C++ je ne sais pas qu'elle voie choisir !!

Les references me paraissent bien, mais je dois avouter qu'en C++ cela semble pas si facile que ça de bien s'en servir. Mais vu que je suis debutant cela ne m'etonne pas bcp non plus

Bref un nouveau petit echange de discussion avec vous me permettrai surement de mieux comprendre, si vous etes d'accord pour avoir ce genre de discussion bien sur

Merci
++

[Laurent Gomila]

Il existe pas mal de threads débattant des pointeurs vs. références sur ce forum, commence par tous les parcourir

Ensuite c'est également beaucoup une question de goût. Certains n'aiment pas les références, d'autres savent écrire du code sans pointeur.

Il y a également quelques situations bien identifiées où tu n'auras pas le choix (tu les trouveras en détail dans les autres sujets je pense).

Pour finir, et pour répondre à ta question, si tu as besoin de faire pointer ta référence sur rien du tout, c'est que tu as besoin d'un pointeur. Une référence est simplement un alias sur une variable, elle est initialisée lors de sa déclaration et ne peut plus être modifiée par la suite.

[kiroukou]

Ok merci Loulou. J'étais justement en train de ma ballader sur le forum

Pour ce qui est de l'initialisation tu as completement raison. Je n'avais pas tourné le probleme comme ça

Bonne journée à vous
++