Discussion :

[gilims]

Salut à tous !!!
Voici le défi :
J'ai une structure de données :

Code :

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

1
2
3
4
5
struct Links
{
	AtomBase &Atome;
	int Type;
};

et j'ai une classe qui possède un attribut vector définit comme cela :

Code :

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

vector<Links*> Linked;

Dans cette même classe, existe une fonction permettant d'ajouter un nouvel élément Links dans l'attribut vector :

Code :

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

1
2
3
4
5
void Add_Bond(AtomBase i_AtomBonded,  int BondType){ 
	Links Link1 = {i_AtomBonded, BondType};
	Linked.push_back(&(Link1));
 
}

Ca compile bien, pas de souci mais au moment de l'exécution : EXC_BAD_ACCESS !!!!
J'ai beau chercher, je sais que ca vient de Linked.push_back(&(Link1)); qu'il aime pas mais j'arrive pas à savoir pourquoi ....
Un petit coup de main s'il-vous-plait !! Ca fait 1h30 que je cherche à je commence à désesperer. Merci d'avance !

[koala01]

Salut, et bienvenue sur le forum.

Le fait est que tu te laisse avoir à une erreur classique lorsque l'on manipule des pointeurs: tu prend l'adresse d'une variable locale à ta fonction et qui est donc détruite... lorsque l'on atteint l'accolade fermante:

Code :

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

1
2
3
4
5
6
7
8
9
void Add_Bond(AtomBase i_AtomBonded,  int BondType){ 
     // ceci est une variable locale... elle n'existe que pour la
     //  durée de l'exécution de Add_bond
    Links Link1 = {i_AtomBonded, BondType}; // ca compile, ca?
 
	Linked.push_back(&(Link1)); // tu prend l'adresse mémoire de link1, 
                                    // mais...
 
} //link1 est détruit ici, son adresse devient donc invalide

Tu dois donc faire en sorte que la variable continue d'exister une fois que l'on a quitté la fonction, et, pour ce faire, il n'y a pas trente six solutions: il faut passer par l'allocation dynamique de la mémoire

Code :

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

1
2
3
4
5
6
7
void Add_Bond(AtomBase i_AtomBonded,  int BondType){ 
    Links *Link1 = new Links(/*...*/);
 
	Linked.push_back(Link1); // on ajoute le pointeur
 
} // on a pris la responsabilité de la gestion de la durée de vie de Link1...
  // la variable continue donc d'exister...

Par contre, cela implique qu'il faut être particulièrement vigilent pour le reste de la gestion de Linked:

1. Si la mémoire allouée à un pointeur contenu dans Linked est libérée, la classe qui utilise Linked doit en être tenue informée et... supprimer le pointeur invalidé
2. Lorsque l'on supprime un élément de Linked, il faut veiller à... libérer la mémoire au plus tard avant de perdre toute référence à l'emplacement mémoire utilisé, sous peine d'observer une fuite mémoire

[gilims]

Merci Koala pour la rapidité de la réponse.
J'ai cru voir la réponse d'un modérateur qui a enlevé son com' y'a 30 secondes disant que toutes utilisations ultérieures seraient faussées. En effet, c'est bien le cas.

J'ai essayé l'utilisation de Links *Link1 = new Links(i_AtomBonded,BondType);
mais ca ne marche pas. Au risque de paraitre faignant et abusif sur ce coup là, un dernier coup de main. Désolé mais je sature completement de ce probleme.

Pour le reste je vais m'arranger dans le destructeur pour bien vérifier que tout est bien désalloué. Merci encore.

[koala01]

Merci Koala pour la rapidité de la réponse.
J'ai cru voir la réponse d'un modérateur qui a enlevé son com' y'a 30 secondes disant que toutes utilisations ultérieures seraient faussées. En effet, c'est bien le cas.

Effectivement, Bruno a posté une réponse et l'a retirée tout de suite après avoir remarqué (bien que n'y étant pas obligé) que j'avais répondu moins succinctement mais dans le même sens que lui...

J'ai essayé l'utilisation de Links *Link1 = new Links(i_AtomBonded,BondType);
mais ca ne marche pas. Au risque de paraitre faignant et abusif sur ce coup là, un dernier coup de main. Désolé mais je sature completement de ce probleme.

Et pour cause, il n'existe aucun constructeur de Links prenant deux arguments

J'avais perdu de vue qu'il s'agissait d'une structure pour laquelle il n'y a aucun constructeur défini par toi, ce qui fait que les Big Four sont de mise.

Essaye peut être avec:

Code :

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

1
2
3
Links *Link1 = new Links;
Link1->Atome = i_AtomBonded;
Link1->Type = BondType;

(au passage, on peut signaler que l'utilisation d'une référence pour le membre Atome de ta structure risque très fortement de poser des problèmes par la suite )

[gilims]

Ok j'ai réussi à faire le constructeur de la structure

Code :

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

Links::Links(AtomBase Atome1,int Type1) { Atome=&Atome1; Type= Type1;}

J'ai un peu modifier la structure

Code :

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

1
2
3
4
5
6
7
8
struct Links
{
	Links(AtomBase Atome1,int Type1);
public:
	AtomBase *Atome;
	int Type;
 
	};

Et le code d'ajout :

Code :

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

1
2
3
4
5
6
7
void AtomBase::Add_Bond(AtomBase i_AtomBonded,  int BondType){ 
	Links *Link1 = new Links(i_AtomBonded,BondType);
 
	//(*Link1).Atome = i_AtomBonded;
	Linked.push_back(Link1);
 
}

Cependant, on en reviens à ce que Bruno et toi disiez, l'accès aux données pose un problème :

Code :

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

cout << Linked[0].Type << endl;

Ca continue à me renvoyer un EXC_BAS_ACCESS.

Et là on parle même pas de l'élément Atome, mais juste d'un integer.
Je suis désespéré .... ^^

[nikko34]

Pourquoi tu utilises des pointeurs si tu ne sais pas t'en servir?

Est-ce qu'il y en a besoin?

Est-ce que tu as vraiment besoin d'une référence/pointeur sur AtomBase? Dans ce cas là, pourquoi tu en passes un paramètre par copie lors de la construction?

voilà mon conseil: commence simple et réfléchis à ce que tu veux faire.

La solution simple:

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
 
struct Link
{
    Link( const AtomBase & atome, 
            int type )
    : atome_( atome),
      type_( type )
    {}
 
    AtomBase atome_;
    int type_;
};
 
std::vector<Link> links;
 
void add_bond( const AtomBase & atomBonded,  int bondType)
{ 
	links.push_back( Link( atomBonded, bondType )  ); 
}

Bon par contre, le C++, ce n'est pas du C, ce n'est pas du Java, va falloir revoir quelques bases (la FAQ C++ developpez.com?)

[gilims]

Au moins c'est de la réponse !!!

Pourquoi tu utilises des pointeurs si tu ne sais pas t'en servir?

Pas trop le choix pour bien gêrer le programme. Je sais que je déteste ca et que je comprends pas forcément mais c'est en forgeant qu'on devient forgeron.

Est-ce qu'il y en a besoin?
Est-ce que tu as vraiment besoin d'une référence/pointeur sur AtomBase?

Définitivement oui. 2 atomes sont reliés par 1 Bond (liaison). Si je n'utilise pas des références/pointeurs, je perds sur le controle sur toute possibilité de modification.

Dans ce cas là, pourquoi tu en passes un paramètre par copie lors de la construction?

C'est bien ce que je me disais, mais j'avoue je n'étais pas sur.

Bon par contre, le C++, ce n'est pas du C, ce n'est pas du Java,

Juste pour être certain, on a le droit d'utiliser des structures de données en C++, ca je pense. Mais que vaut-il mieux faire pour ce cas là ??

[nikko34]

Les pointeurs ne sont pas une fatalité, tu pourrais très bien avoir un id pour chaque Atom et un Link qui contient l'id de deux Atom par exemple. Comme dans une base de données relationelle.

[bruno_pages]

Bonjour,

Ok j'ai réussi à faire le constructeur de la structure

Code :

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

Links::Links(AtomBase Atome1,int Type1) { Atome=&Atome1; Type= Type1;}

vous avez encore fait la même erreur : vous mémorisez l'adresse d'une variable locale, ici Atome1

Définitivement oui. 2 atomes sont reliés par 1 Bond (liaison). Si je n'utilise pas des références/pointeurs, je perds sur le controle sur toute possibilité de modification.

A partir du moment ou un atome peut être relié à plusieurs autres il faut bien-sûr que vous passiez par des pointeurs, ni par valeur, ni par référence non plus.

cela veut dire que le contructeur de Link doit recevoir des AtomBase *, surtout pas de paramètre de type AtomBase &, et pas d'attribut AtomBase & atomxx; mais AtomBase * atomxx;

Les pointeurs ne sont pas une fatalité, tu pourrais très bien avoir un id pour chaque Atom et un Link qui contient l'id de deux Atom par exemple. Comme dans une base de données relationelle.

non, inutile de faire compliqué, de plus cela ne résout rien car vous vous retrouverez par exemple avec un id correspondant à un élément qui n'existe plus par exemple. Ici il faut utiliser des pointeurs.

Dans ton cas, que tu utilises des pointeurs ou des références, si ton vector d'atom change, il va falloir mettrre à jour ton vector de links avant de supprimer les atoms.

il faut effectivement décider de "qui sait quoi" c'est à dire "qui référence qui". Par exemple est-ce qu'un atome à besoin de connaitre ses liaisons avec les autres ?
il n'est pas possible de répondre à cette question dans l'absolu, il faut savoir ce que vous comptez faire avec vos atomes et liaisons

La version avec des références par 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
 
struct Link
{
    Link( AtomBase & atom1, 
           AtomBase & atom2
           int type )
    : atom1_( atom1),
      atom2_( atom2),
      type_( type )
    {}
 
    AtomBase & atom1;
    AtomBase & atom2;
    int type_;
};
...

cette solution est catastrophique

une référence est un pointeur 'déguisé', dans les deux cas il s'agit de l'adresse de l'objet pointé, une référence c'est juste du sucre syntaxique permettant une utilisation plus souple et automatisée qu'un simple pointeur, mais à la base il n'y a pas de différence.

[nikko34]

ah oui mince je suis bête t'as raison le std::vector va tout changer à la moindre manip'. Yavait donc bien une raison pour laquelle je ne faisais pas ça Je vais arrêter les exemples mal reveillé

Donc oui des pointeurs.

[gilims]

Ok bon, là j'avoue, je capitule....
Récapitulons ^^.
On a donc la structure Links avec son constructeur :

Code :

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

1
2
3
4
5
6
struct Links
{
    Links( AtomBase & atom1, int type ) : Atome( atom1), Type( type ){ }
    AtomBase & Atome;
    int Type;
};

Et la fonction Add_bond :

Code :

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

1
2
3
4
5
6
7
void AtomBase::Add_Bond(AtomBase *i_AtomBonded,  int BondType){ 
	Links *p;
	p = new Links( *i_AtomBonded, BondType );
	Linked.push_back( p  );
	cout << Linked.back()->Type << endl;
 
}

Alors là, le probleme qui se pose, et que j'ai bien compris maintenant, c'est que je crée un pointeur Links que j'ajoute à mon vecteur Linked. Le cout << Linked.back()->Type << endl; m'affichera bien la valeur voulue, mais dès que je sors de la fonction ... pouf !!! envolé. Ce qui est normale vu que c'est une variable localement crée. Comment faire pour qu'elle reste en l'état ???!!! Je commence à comprendre le principe , manque encore ce point à régler... ou alors j'ai tout faux

[bruno_pages]

pourquoi continuez-vous à utiliser des références dans Links ?

renommez aussi Links en Link puisque chaque instance de la classe ne concerne qu'un lien

vous avez modifié Link(s) qui ne mémorise plus qu'un des atomes relié, est-ce Linked est un attribut de AtomBase ?

[gilims]

Bon c'est officiel j'y comprends plus rien !!!
On va essayer de recadrer un peu le probleme. J'ai donc 1 atome, représenté par la classe AtomeBase. Dans cette classe se trouve, l'attribut Linked définit de la facon suivante : vector<Links*> Linked;
Puisqu'un atome est relié à un autre atome par une liaison, cette liaison est enregistré avec son type et avec la référence à l'atome rélié, ce qui permettra par la suite de pouvoir accéder facilement aux informations de l'atome relié.
Bon j'avoue j'ai fait des modifs qui doivent être encore pire, mais au point où j'en suis je teste tout :
Voici la structure Links (que je pourrais très bien nommé Link)

Code :

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

1
2
3
4
5
6
struct Links
{
    Links( AtomBase * atom1, int type ): Atome( atom1), Type( type ){ }
    AtomBase * Atome;
    int Type;
};

Et voici le code d'ajout d'un nouvel élément Links dans le vector Linked.

Code :

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

1
2
3
4
5
6
7
8
 
void AtomBase::Add_Bond(AtomBase *i_AtomBonded,  int BondType){ 
	//Links *p;
	//p = new Links( *i_AtomBonded, BondType );
	Linked.push_back( Links( i_AtomBonded, BondType )  );
	cout << Linked.back().Type << endl;
 
}

Pourquoi ca marche pas !!!!

[bruno_pages]

la définition de Add_Bond suppose que l'on a vector<Links> Linked et non pas vector<Links*> Linked

et en fait vector<Links> Linked est la bonne solution à partir du moment où un Links n'est pas référencé par plusieurs éléments (ce qui serait le cas si deux atomes reliés mémorisait chacun le lien les reliant)

vous n'avez pas répondu à ma question est-ce Linked est un attribut de AtomBase, si ce n'est pas le cas alors bien-sûr votre système ne marche pas

P.S. mauvaise idée d'utiliser une majuscule en premier caractère d'un attribut d'instance, utilisez cela plutôt pour les attributs de classe ou les variables globales (C)

[gilims]

Merci d'être aussi persévérant, c'est sympa ^^.

et en fait vector<Links> Linked est la bonne solution à partir du moment où un Links n'est pas référencé par plusieurs éléments (ce qui serait le cas si deux atomes reliés mémorisait chacun le lien les reliant)

Links n'est pas référencé par plusieurs éléments. En effet dans ma tete, si on a la liaison A-B, on aurait alors dans la classe AtomBase A, le Linked qui contiendrait de facon schématique A->( adresse de B, type de liaison) et B-> (adresse de A, type de liaison). Les 2 linked formait serait donc différent.

vous n'avez pas répondu à ma question est-ce Linked est un attribut de AtomBase, si ce n'est pas le cas alors bien-sûr votre système ne marche pas

Oui, Linked est un attribut d'AtomBase. Mais dans ce cas pourquoi le systeme ne marcherait pas ?


Pour les majuscules, je tacherais d'y penser à l'avenir. Force de l'habitude.

[bruno_pages]

Oui, Linked est un attribut d'AtomBase. Mais dans ce cas pourquoi le systeme ne marcherait pas ?

c'est l'inverse, si Linked n'avait pas été un attribut d'instance d'AtomBase alors un atom ne saurait pas à qui il est relié

puis-je savoir pourquoi vous aviez changé Links pour qu'il ne référence plus les deux atomes qu'il relie ?

[gilims]

c'est l'inverse, si Linked n'avait pas été un attribut d'instance d'AtomBase alors un atom ne saurait pas à qui il est relié

Au moins on est d'accord sur un point !!!

puis-je savoir pourquoi vous aviez changé Links pour qu'il ne référence plus les deux atomes qu'il relie ?

Tout simplement parce que je suis perdu. Ce fichu problème d'adresse m'a enlevé toute optique logique et correcte du point de vue fonctionnel de l'histoire.

[gilims]

Ne vous embêtez pas Bruno_pages, je suis en train de reconstruire mon fichier, et avec les informations données ici, j'y verrais surement plus clair. Je posterais la réponse dès que je l'ai trouvé. Merci pour tout

[bruno_pages]

ce qui me gène dans la solution actuelle c'est que pour relier deux atomes vous devez creer deux liens, et bien-sûr ces deux liens doivent avoir le même type.

l'autre solution c'est donc quelque chose comme cela :

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
#include <list>
using namespace std;
 
class Atom;
 
class Link {
  public:
    Link(Atom * a1, Atom * a2, int type);
    ~Link();
 
  private:
    Atom * _a1;
    Atom * _a2;
    int _type;	// rien de mieux qu'un int ?
};
 
class Atom {
  public:
    Atom() {}
    ~Atom();
    void link(Link *);
    void unlink(Link *);
 
  private:
    list<Link *> _links;
};
 
Link::Link(Atom * a1, Atom * a2, int type)
    : _a1(a1), _a2(a2), _type(type) {
  a1->link(this);
  a2->link(this);
}
 
Link::~Link() {
  _a1->unlink(this);
  _a2->unlink(this);
}
 
Atom::~Atom() {
  list<Link *>::iterator it;
 
  while (! _links.empty())
    delete _links.front();
}
 
void Atom::link(Link * l) {
  _links.push_back(l);
}
 
void Atom::unlink(Link * l) {
  _links.remove(l);
}

ce qui précède n'est pas fini et comporte des lacunes graves, si cela vous intéresse de les chercher

[gilims]

Je suis d'accord sur la redondance des données pour Type. Hélàs, celle-ci est nécessaire pour assurer la cohérence des calculs futurs.

En tout cas, après avoir recommencé à zéro, j'ai finalement réussi.
En relisant, j'ai remarqué que j'avais pas réussi à mettre de minuscules aux attributs, les habitudes ont la vie dure ...

Bref, je vous soumets mon code pour critique :
Structure Link:

struct Link
{
AtomBase *Atom;
unsigned int Type;
Link(AtomBase *_Atom, unsigned int _Type): Atom(_Atom),Type(_Type) {};
};

La classe AtomBase:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class AtomBase
{
private: 
        int Num;
        string Nom;
	vector<Link> Linker;
public:
        AtomBase();
	void AddLink(Link *_Linker);
 
};

La fonction AddLink() :

Code :

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

1
2
3
4
5
 
void AtomBase::AddLink(Link *_Linker)
{
	Linker.push_back(*_Linker);
}

Et la fonction appelante :

Code :

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

1
2
3
4
5
6
7
8
9
 
void MolBase::Add(BondBase _Bond)
{
	Bonds.push_back(_Bond);
	Link *p = new Link(&Atoms.at(_Bond.Get_Atom1()), _Bond.Get_BondType());
	Atoms.at(_Bond.Get_Atom2()).AddLink(p);
	Link *p2 = new Link(&Atoms.at(_Bond.Get_Atom2()), _Bond.Get_BondType());
	Atoms.at(_Bond.Get_Atom1()).AddLink(p2);
}

Et la classe BondBase :

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
 
class BondBase
{
 
private: 
	unsigned int Type;
	unsigned int Atom1;
	unsigned int Atom2;
public:
	BondBase(unsigned int _Type,int _Atom1,int _Atom2);
 
	int Get_Atom1();
	int Get_Atom2();
	int Get_BondType();
	void __ToString();
};

Mon idée éventuelle pour éviter la rédondance serait d'utiliser l'adresse de Type contenu dans BondBase, comme ca, on n'aurais qu'une seule fois le Type de liaison et il serait identique pour tous. Mais j'ai du mal à récupérer l'adresse de cet attributs
Sinon, place aux critiques !!!