Discussion :

[bruno_pages]

Sinon, place aux critiques !!!

d'abord c'est franchement bien compliqué pour pas grand chose, il suffit de comparer la taille du code de ma proposition et la votre pour s'en rendre compte immédiatement.

sinon le manque le plus flagrant dans votre proposition c'est que la destruction d'un atome ou d'une liaison laissera les objets encore existants dans un état incohérent car pointant vers les éléments détruits

si vous regardez ma proposition vous verrez que la destruction d'un atome détruit proprement ses éventuelles liaisons. De même la destruction d'une liaison provoque la mise à jour des deux atomes qu'elle reliait. Bref ca marche ... si ce n'est les lacunes dont j'ai parlé histoire de vous faire réfléchir

[gilims]

J'avais mal compris le point de vue que vous m'aviez proposé. désolé.
Au moins, refaire le code avec ma version m'a permis de mieux cibler mon erreur et de la corriger. Maintenant, je vais tester un peu votre idée.

Dites moi, vous auriez pas bosser dans la chimie un peu ???

[gilims]

Bien bien bien. J'adore ce point de vue !!! merci !!!
Je l'ai un peu modifié de façon à mieux l'adapter au sujet. Il n'est pas nécessaire de créer la classe Link comme vous le proposiez, car celle-ci s'avère être la classe BondBase déjà existante. Je n'avais pas fait la connexion comme vous le proposiez, et je regrette amèrement de ne pas y avoir pensé plus tôt !!!

Donc j'ai repris votre idée de list de BondBase* cette fois.
Voici la sortie du programme :

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
 
-----------ATOME----------
Atome 0 :  C1 
Adresse : 0x100100110
Nbr liaison : 1
-----------ATOME----------
Atome 1 : H2 
Adresse : 0x100100160
Nbr liaison : 1
--------Liaison-------
Adresse : 0x1001001b0
Entre atome 0 et 1. Liaison de type 1
Adresse de 0 : 0x100100110
Adresse de 1 : 0x100100160
----------------------
 
 
 
Suppression de la liaison dont l'adresse est : 0x1001001b0
-----------ATOME----------
Atome 0 :  C1 
Adresse : 0x100100110
Nbr liaison : 1
-----------ATOME----------
Atome 1 : H2 
Adresse : 0x100100160
Nbr liaison : 1

Comme on peux le constater les relations atomes/liaison sont bien réalisés.
Le probleme qui se pose maintenant, je dirais le tout dernier avec une certaine confiance (j'epère ) c'est que le unlink que vous proposiez n'est pas réalisé. Et pour cause, je n'arrive pas à le programmer, le compilateur me le refuse.

Voici BondBase.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
19
20
21
22
23
24
25
26
27
28
29
30
 
class AtomBase;
 
class BondBase: public Coords
{
 
private: 
	unsigned int Type;
	unsigned int NAtom1; // N° de l'atome 1,  nécessaire
	unsigned int NAtom2;// N° de l'atome 2,  nécessaire
	AtomBase* Atom1;  // adresse de l'atome 1
	AtomBase* Atom2; // adresse de l'atome 2
public:
	BondBase(unsigned int _Type,int _Atom1,int _Atom2);
	~BondBase();
	int Get_Atom1();
	int Get_Atom2();
	int Get_BondType();
 
	void Set_AddrAtom1(AtomBase* At1);
	void Set_AddrAtom2(AtomBase* At2);
	AtomBase* Get_AddrAtom1();
	AtomBase* Get_AddrAtom2();
 
 
 
	void Set_BondType(unsigned int _Type);
 
	void __ToString();
};

et voici le code du destructeur :

Code :

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

1
2
3
4
5
 BondBase::~BondBase()
{
	cout << "Suppr bond :" <<this << endl;
	//cout << *Atom1->unlink() << endl;	
}

Le compilateur sort pour la ligne *Atom1->unlink() : invalid use of incomplete type 'stuct AtomBase'. Imcompréhensible vu que c'est une classe.
Je pense que le problème vient du fait que j'ai mis un prototype de la classe AtomBase dans BondBase.h. Je sais pas pourquoi il me casse les pieds avec, sachant que de toute façon, AtomBase utilise BondBase et réciproquement.

Ca c'est AtomBase

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
AtomBase::~AtomBase() {
	list<BondBase *>::iterator it;
	//cout << Nom <<Num <<  "  size : " <<linker.size()<< endl;
	for (int Ivar1 = 0; Ivar1 < linker.size(); Ivar1++)
	{
		if (!linker.empty()){ linker.pop_back(); }
	}
 
 
}
 
void AtomBase::link(BondBase *l)   { linker.push_back(l); }
void AtomBase::unlink(BondBase *l) {cout << "removing link"; linker.remove(l); }

Dernier coup de main .... please.
En tout cas, je sais que je me répète, mais merci encore, j'ai appris bien plus sur les pointeurs, les list, et les relations en 3 jours qu'en 3 mois.

[bruno_pages]

Bonjour,

cout << *Atom1->unlink() est triplement erroné :

• AtomBase::unlink prend un argument (un BondBase *)
• AtomBase::unlink ne retourne rien (void), donc * est invalide car on ne déréférence pas void
• et la chose ne peut être donnée à cout <<

la définition de ~AtomBase() n'est pas valide :

• lorsqu'un AtomBase est détruit il faut détruire les BondBase qui le relie
• it ne sert à rien
• le test de sortie sur IVar1 est invalide car linker.size() rend une valeur qui est décrémentée à chaque tours mais en même temps vous comparez cette taille avec IVar1 qui lui est incrémentez à chaque fois => la liste de sera pas vidée
• le fait que la boucle contienne if (!linker.empty()) est également incohérent puisque le test de sortie de boucle doit être ce qui décide qu'il faut continuer ou non

pourquoi ne pas avoir suivi ma définition de ~Atom ?

AtomBase::Type est encore un int, vous n'avez rien de plus parlant comme une énumération par exemple ?

Get_AddrAtom1/2 et Set_AddrAtom1/2 c'est vraiment pas de beaux noms d'opération à cause d'Addr.

Que représentent NAtom1/2 ? cela ne peut-il pas être défini au niveau de AtomBase ?

Les noms en xxBase c'est pas terrible non plus, je suppose que ce sont des interfaces héritées par d'autre classes, vous pouvez donnez des exemple de ces autres classes ?

[gilims]

désolé de retard... coincé par le boulot.

cout << *Atom1->unlink() est triplement erroné :

* AtomBase::unlink prend un argument (un BondBase *)
* AtomBase::unlink ne retourne rien (void), donc * est invalide car on ne déréférence pas void
* et la chose ne peut être donnée à cout <<

Oui, c'est juste que j'avais pas vérifié ce que j'avais copié. J'avais fait des suppressions entre 2 lignes et elles se sont concaténer.

AtomBase::Type est encore un int, vous n'avez rien de plus parlant comme une énumération par exemple ?

Si Si, pourquoi pas...

Que représentent NAtom1/2 ? cela ne peut-il pas être défini au niveau de AtomBase ?

En effet, ils sont définis au niveau de AtomBase. Il faut plutot que je fasse une petite fonction qui pointent vers NAtom d'AtomBase.

Les noms en xxBase c'est pas terrible non plus, je suppose que ce sont des interfaces héritées par d'autre classes, vous pouvez donnez des exemple de ces autres classes ?

Elles sont censées être hérité par d'autres classes. Mais je les ai pas commencé. Ca sert à rien de commencer les étages d'une maison sans les fondations.

--------------------------------------------------------
J'ai retravaillé mon code encore et encore et encore. Je l'ai recommencé 4 fois en tout et j'ai toujours les mêmes erreurs de M*****.

MolBase.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
19
20
21
22
23
24
25
26
27
#ifndef DefMolBase
#define DefMolBase
 
#include <vector>
#include "BondBase.h"
 
using namespace std;
 
class MolBase
{
	private :
 
 
	//vector<BondBase> Bonds;
	public : 
	vector<AtomBase*>::iterator Atome;
	//vector<AtomBase> Atoms;
	vector<AtomBase*> Atoms;
	vector<BondBase*> Bonds;
		MolBase();
	~MolBase();
	bool Atom_Empty();
	void List_AddrAtoms();
		void Add_Atom(AtomBase* _Atom1);
};
 
#endif

MolBase.cpp :

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
 
#include "MolBase.h"
#include <iostream>
using namespace std;
MolBase::MolBase() {};
 
bool MolBase::Atom_Empty() { return Atoms.empty();}
 
MolBase::~MolBase()
{
	//AtomBase* ptr;
	List_AddrAtoms();
	while (!Atom_Empty())
	{
		delete Atoms.back(); 
		Atoms.pop_back();
 
		//cout << ptr << " " << ptr->Num<< endl;
	List_AddrAtoms();
	}
}
 
void MolBase::Add_Atom(AtomBase *_Atome)
{
	cout << endl<< "Add Atom :          " << _Atome<<endl;
	Atoms.push_back(_Atome);
	cout << "Atoms.push_back :   " <<Atoms.back() << endl;
	cout << "Nombre d'element:   "<< Atoms.size() << endl;
	cout << "Mole->Atomes vide : " << Atom_Empty()<<endl;
}
 
 
void MolBase::List_AddrAtoms()
{
 
 
	cout << "Liste adresse atome contains:";
	for ( Atome=Atoms.begin() ; Atome < Atoms.end(); Atome++ )
		cout << " " << *Atome ;
 
	cout << endl;
 
}

BondBase.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
#ifndef DefBondBase
#define DefBondBase
 
#include "AtomBase.h"
 
using namespace std;
 
class BondBase
{
private:
	AtomBase* Atom1;
	AtomBase* Atom2;
public:
	BondBase();
 
};
 
#endif

AtomBase.cpp :

Code :

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

1
2
3
4
5
6
7
 
#include "AtomBase.h"
#include <iostream>
using namespace std;
 
AtomBase::AtomBase(int _Num):Num(_Num) {};
AtomBase::~AtomBase() {cout << "Suppr " << endl;};

AtomBase.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
19
20
21
22
23
#ifndef DefAtomBase
#define DefAtomBase
 
#include <vector>
 
using namespace std;
 
class BondBase;
 
class AtomBase
{
private:
 
	//vector <BondBase*> Link;
public:
	int Num;
 
	AtomBase(int _Num);
	~AtomBase();
};
 
 
#endif

Main.cpp

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
#include <iostream>
#include "MolBase.h"
int main (int argc, char * const argv[]) {	
    AtomBase Atom1(1);
    AtomBase Atom2(2);
	MolBase Mole;
	cout << "------------ ATOME 1 ----------- " <<endl;
	cout << "Adresse creation :  " << &Atom1<<endl;
	cout << "Mole-> Atomes    :  " << Mole.Atom_Empty()<<endl;
	Mole.Add_Atom(&Atom1);
	Mole.Add_Atom(&Atom2);
	//Mole.List_AddrAtoms();
	std::cout << "Hello, World!\n";
 
    return 0;
}

Le compilateur me sort une erreur du type : "freeing a pointer we didn't allocate that was not claimed by any registered zone". Tout ca pour dire que la commande delete Atoms.back(); dans MolBase.cpp ne supprime pas l'AtomBase alors qu'il est censé le faire. J'ai pourtant suivit toutes vos recommandations, et pas moyen de réussir. Comme je pense que le problème est identique pour l'histoire Liaison-Atome, je pense que régler l'un va me permettre de régler l'autre. J'avoue sérieusement que ca m'énerve de pas comprendre cette histoire ...

[bruno_pages]

Bonjour,

ce qui arrive est normal, en sortie le destructeur de MolBase est appelé pour Mole, et celui-ci fait delete Atoms.back() c'est à dire sur Atom1 et Atom2 alors que ceux-ci sont en pile

votre programme suppose que les AtomBase sont alloués dans le tas, pas placés en pile, le fait d'écrire Mole.Add_Atom(&Atom1) avec le '&' aurait du attirer votre attention

pour info voici que ce dit valgrind :

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
bruno@linux-ysqo:/tmp> valgrind ./a.out
==4557== Memcheck, a memory error detector.
==4557== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==4557== Using LibVEX rev 1732, a library for dynamic binary translation.
==4557== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==4557== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
==4557== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==4557== For more details, rerun with: -v
==4557==
------------ ATOME 1 -----------
Adresse creation :  0xbefede9c
Mole-> Atomes    :  1

Add Atom :          0xbefede9c
Atoms.push_back :   0xbefede9c
Nombre d'element:   1
Mole->Atomes vide : 0

Add Atom :          0xbefede98
Atoms.push_back :   0xbefede98
Nombre d'element:   2
Mole->Atomes vide : 0
Hello, World!
Liste adresse atome contains: 0xbefede9c 0xbefede98
Suppr
==4557== Invalid free() / delete / delete[]
==4557==    at 0x4022156: operator delete(void*) (in /usr/lib/valgrind/x86-linux/vgpreload_memcheck.so)
==4557==    by 0x8048E42: MolBase::~MolBase() (MolBase.cpp:14)
==4557==    by 0x804A101: main (Main.cpp:15)
==4557==  Address 0xBEFEDE98 is on thread 1's stack
Liste adresse atome contains: 0xbefede9c
Suppr
Liste adresse atome contains:
Suppr
Suppr
==4557==
==4557== ERROR SUMMARY: 2 errors from 1 contexts (suppressed: 3 from 1)
==4557== malloc/free: in use at exit: 0 bytes in 0 blocks.
==4557== malloc/free: 2 allocs, 4 frees, 12 bytes allocated.
==4557== For counts of detected errors, rerun with: -v
==4557== All heap blocks were freed -- no leaks are possible.

il suffit donc de changer votre main en :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main (int argc, char * const argv[]) {	
    AtomBase * Atom1 = new AtomBase(1);
    AtomBase * Atom2 = new AtomBase(2);
    MolBase Mole;
    cout << "------------ ATOME 1 ----------- " <<endl;
    cout << "Adresse creation :  " << Atom1<<endl;
    cout << "Mole-> Atomes    :  " << Mole.Atom_Empty()<<endl;
    Mole.Add_Atom(Atom1);
    Mole.Add_Atom(Atom2);
    //Mole.List_AddrAtoms();
    std::cout << "Hello, World!\n";
	
    return 0;
}

[gilims]

Eh ben, j'aurais jamais cru m'en sortir de ce problème. Tout marche, sans aucune fuite mémoire ... ou presque. J'ai juste un détail qui va paraître nul par rapport à tout ce qu'on a dit précédemment mais bon. J'ai réussi à bien faire les liens entre atomes->liaisons et liaisons->atomes. J'arrive à lire les données des atomes dans la classe liaison, mais pas l'inverse.

Tout ce que trouve mon compilateur à dire, avec cet AtomBase.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
19
20
21
22
23
24
25
 
class BondBase;
 
class AtomBase
{
private:
	unsigned int	 Num;
	list <BondBase*> Links;
public:
	void __ToString();
	~AtomBase();
 
	AtomBase(int _Num);
 
	unsigned int Get_Num();
 
	void Set_Num(unsigned int _Num);
 
	list<BondBase*>::iterator Link;
	void Add_link(BondBase* _Link);
	void Unlink(BondBase* _Link);
	bool Has_Link();
 
 
};

c'est : Forward declaration of 'struct BondBase' ...
Après ca, je mets en résolu.

[bruno_pages]

Dans AtomBase.h on déclare que BondBase est une classe (class BondBase), c'est une forward declaration.

Donc un fichier qui inclut AtomBase.h sait juste que BondBase est une classe, rien de plus, mais si le code utilise 'vraiment' la classe alors il y a un problème car sa définition est inconnue et le compilateur râle

il suffit donc de savoir quel est le .cpp qui ne se compile pas et d'ajouter dans celui-ci un #include "BondBase"

aucune fuite mémoire ... ou presque

il faut apprendre à corriger cela, c'est valgrind qui les signale ?

[gilims]

il faut apprendre à corriger cela, c'est valgrind qui les signale ?

C'était juste pour le plaisir.
En réalité j'en ai hélàs absolument aucune idée. valgrind ne marche pas avec mon système (Mac 10.6). J'utilise XCode pour trouver les fuites de mémoires, mais il avait pas réussi à me dire ce que j'attendais sur le problème précédent (problème que vous avez résolu avec Valgrind). Je vais continuer à chercher un programme équivalent qui fonctionne avec des programmes 64 bits.

Pour le petit probleme de BondBase.h c'est réglé, il était manquant dans AtomBase.cpp.

En tout cas, un grand merci à vous pour votre aide et vos petits conseils glissés par ci et là.