Discussion :

[black-falco]

Bonjour !

Pour mon héritage tou se passe bien jusqu'à ce type d'instruction : s.begin().

Ma classe abstraite (mere) possède un vecteur d'objets en protected dans ses attributes privés.
Ma classe fille hérite en public de la classe abstraite.

s.begin() fonctionne parfaitement dans la classe mère pour initialiser mes iterator, mais c'est apparamment le seul probleme que je rencontre dans mes classes filles ...

voila le code :
vector<Sommet>::iterator its ;

its = s.begin();

et l'erreur :

'=' binaire : aucun opérateur trouvé qui accepte un opérande de partie droite de type 'std::_Vector_const_iterator<_Ty,_Alloc>' (ou il n'existe pas de conversion acceptable)
with
[
_Ty=Sommet,
_Alloc=std::allocator<Sommet>
]

[r0d]

Bonjour,

essaie:
vector<Sommet>::const_iterator its ;

[black-falco]

Ca élimine certaines erreurs mais il en reste ...

J'utilise un int et la méthode at de vector pluôt que iterator .

Merci quand même !

[r0d]

Quelles sont les erreurs qui restent?

[black-falco]

vector<Relation>::const_iterator itr = r.begin();
itr++;
o << *itr->getS1()-> getNum();

l'erreur :
indirection non conforme

*itr-> : si je mets autre chose (genre itr. ou itr-> soyons fous) ça ne marche pas non plus. Idem pour vector<Sommet>::const_iterator.

[r0d]

Un itérateur se comporte comme un pointeur qui pointe sur l'élément du conteneur. C'est donc bien la notation "itr->" qu'il faut utiliser (ou "(*itr)." qui est équivalente). Mais j'ai peur que le problème ne soit dû au const.
Le plus simple serait que tu regardes d'un peu plus prés ces histoires de const.

[black-falco]

Pour la notion de pointeur qu'on applique à l'iterator j'avais bien compris, j'ai tout essayé quand même puisque l'erreur est "bizarre".

Sinon j'ai un autre problème de const apparamment :

L'erreur :
'=' : impossible de convertir de 'const Sommet *' en 'Sommet *'

Le code :
Relation::Relation (const Sommet& sommet1, const Sommet& sommet2, int &p)
{
s1 = &sommet1; // erreur ici
s2 = &sommet2; // et là
poids = p;
}

Sommet& Sommet::operator = (const Sommet &som)
{
num = som.num;
return *this;
}

Merci de vos réponses !

[NiamorH]

Pour cette erreur, c'est très simple, comme te le dit clairement le compilateur, s1 et s2 sont des Sommet * et tu tentes de leur affecter des Sommet const *.
Il y a donc un probleme de conception. Soit s1 et s2 doivent être déclarés const car par amenés à être modifiés, soit ton constructeur de Relation doit prendre des références non constantes.

[black-falco]

Bon, ok =)

* Je vais m'en sortir - Je vais m'en sortir * AHHHH

Merci

[black-falco]

Il y a quand même des choses que je ne comprends pas ...

s1 = &sommet1 donne une erreur car un const Sommet* ne peut pas être converti en Sommet*.
Je ne vois pas pourquoi ça ne marche pas. Je n'ai jamais eu de problème en faisant des choses comme ça.
s1 est un Sommet*, sommet1 un const Sommet& soit une référence sur l'objet passé en paramètre, objet que je ne pourrais pas modifier dans la méthode :

Relation::Relation (const Sommet& sommet1, const Sommet& sommet2, int &p)
{
s1 = &sommet1; // erreur ici
s2 = &sommet2; // et là
...
}

Je ne peux pas déclarer les attributes privés s1 et s2 en const puisque je veux pouvoir les modifier.

J'ai un plantage quand je lance l'exe, mon code est pourtant tout simple.
Si je mets une Relation* dans un vector il y a erreur, de même si j'appelle le destructeur de Relation.

[Médinoc]

Ajouter l'attribut const à un pointeur ou une référence n'est pas du tout la même chose que le supprimer.

[black-falco]

Je ne vois pas où tu veux en venir

[Médinoc]

Tes pointeurs suppriment l'attribut const, donc il est normal que ça ne compile pas.

C'est comme si on te donnait quelque chose que tu n'as pas le droit de modifier, mais que tu essayais de le modifier quand même --> Pan sur les doigts!

Si tu veux un pointeur non-const, tu dois travailler sur des copies des objets passés en paramètre.

[black-falco]

Bon c'est réglé. Merci de votre patience je sais que des questions bêtes donnent envie de donner des réponses bêtes.

Dernier problème pour moi, après je devrai plus vous embêter :

Code :

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

1
2
3
4
5
6
7
8
 
Relation::~Relation ( )
{
	if ( s1 != NULL)
		delete s1;
	if ( s2 != NULL )
		delete s2;
}

Je reprends : s1 et s2 sont des Sommet* (pointeurs qui contiennent l'adresse des Sommets d'origine).
Lorsque j'appelle le destructeur de Relation : plantage.

[Médinoc]

Assure-toi que ces pointeurs sont bien nuls quand il ne pointent sur rien.

[yan]

Bon c'est réglé. Merci de votre patience je sais que des questions bêtes donnent envie de donner des réponses bêtes.

Dernier problème pour moi, après je devrai plus vous embêter :

Relation::~Relation ( )
{
if ( s1 != NULL)
delete s1;
if ( s2 != NULL )
delete s2;
}

Je reprends : s1 et s2 sont des Sommet* (pointeurs qui contiennent l'adresse des Sommets d'origine).
Lorsque j'appelle le destructeur de Relation : plantage.

Bonjour,

Code :

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

1
2
3
4
5
6
Relation::Relation (const Sommet& sommet1, const Sommet& sommet2, int &p)
{
s1 = &sommet1;
s2 = &sommet2; 
...
}

tu est sur que les sommmets que tu passe en reference existe encore??
A mon avis il te manque un recopie des sommets dans la creation de Sommet

ce code devrait planter :

Code :

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

1
2
3
4
5
6
7
void une_fonction()
{
Sommet sommet1,sommet2;
int p;
...//ce que tu veut avec
relation relation_erreur_memoire(sommet1,sommet2,p);
}

en sortie de la fonction sommet1,sommet2,p seront detruit et lors de la destruction de relation_erreur_memoire, ton code va t'enté de detruire ce qui se trouve en s1 et s2 qui correspondent à sommet1 et sommet 2 qui ne sont pas alloué dynamiquement (indéfinie) et qui sont ou seront detruit une deusième fois.

[yan]

pour info
if ( s1 != NULL) delete s1;
ne sert a rien
http://cpp.developpez.com/faq/cpp/?p...RS_delete_NULL

[black-falco]

ils ne sont pas censés être nuls, les pointeurs, quand ils ne pointent sur rien ?


Voilà le code du main que j'ai codé pr vérifier tt ça :

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
 
vector<Sommet> vs = vector<Sommet>();
	vector<Relation> vr = vector<Relation>();
 
	Sommet* s1 = new Sommet(1);
	Sommet* s2 = new Sommet(2);
	Relation* r = new Relation();
	int p = 23;
		r->setS1(*s1);
		r->setS2(*s2);
		r->setPoids(p);
	cout << *s1 << endl;
	cout << *s2 << endl;
	cout << *r << endl;
 
 
	vs.push_back(*s1);
	vs.push_back(*s2);
 
	vr.push_back(*r);
	//
	GrapheOriente* gno = new GrapheOriente(vs, vr);
	cout << *gno << endl;
	delete gno;
 
	delete r;
	delete s1;
	delete s2;

Les sommets que je créé existent toujours lorsque je détruit r.

[Médinoc]

Seulement si on y a pensé:

• À l'initaliser à NULL au départ
• À le remettre à NULL une fois l'objet pointé déplacé ou détruit...

De plus, pour qu'un delete soit possible, l'objet pointé doit absolulment être un objet créé avec new...

[black-falco]

D'accord.

Donc le problème est résolu :

Code :

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

1
2
3
4
5
6
7
 
Relation::Relation ( )
{
	s1 = NULL;
	s2 = NULL;
	poids = -1;
}

Mon destructeur sera donc vide.
Une belle confusion à la source de tout ça...
Merci beaucoup.