Discussion :

[pacolito]

Bonjour bonjour !!

voici une petite question qui me tarraude ! Quelle est la meilleure solution parmi les 3 codes suivants pour supprimer mes objets :

Solution 1:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
Banque b;
Compte* c;
 
while(condition)
{
    ... // récupération des paramètres nécessaires à la création d'un objet Compte
 
    c = new Compte(id, solde);
    b.addCompte(c);
}
delete c;

Solution 2:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
Banque b;
Compte* c;
 
while(condition)
{
    ... // récupération des paramètres nécessaires à la création d'un objet Compte
 
    c = new Compte(id, solde);
    b.addCompte(c);
    delete c;
}

Solution 3:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Banque b;
 
while(condition)
{
    ... // récupération des paramètres nécessaires à la création d'un objet Compte
 
    Compte* c = new Compte(id, solde);
    b.addCompte(c);
    delete c;
}

Je ne sais pas quelle solution est la mieux... d'ailleurs je ne suis pas sûr que la première soit correcte (on créé plusieurs pointeurs sur Compte et on ne fait qu'un seul delete !! C'est correct ça ??)

Merci pour votre aide !!

[dragonjoker59]

Je suis tenté de dire aucune des 3.
Tout dépend de ce que fait ta fonction addCompte.
Soit elle crée en interne un objet de type Compte pour elle même, à ce moment un passage par référence fait aussi bien l'affaire que le passage d'un pointeur et il devient inutile de créer dynamiquement ton Compte.
Soit elle stocke le pointeur que tu lui donnes et tu ne dois alors surtout pas détruire le pointeur que tu lui as passé.

Evidemment la première méthode est fausse, pour X new, il faut X delete. là tu as X new et 1 delete => memory leak.

Voici 2 méthodes que je pourrais utiliser :

Code :

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

1
2
3
4
5
6
 
while(condition)
{
    ... // récupération des paramètres nécessaires à la création d'un objet Compte
    b.addCompte(id, solde); // on passe directement les arguments du constructeur du Compte qui est alors construit par banque
}

Code :

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

1
2
3
4
5
6
 
while(condition)
{
    ... // récupération des paramètres nécessaires à la création d'un objet Compte
    b.addCompte( Compte( id, solde)); // on passe une référence sur un Compte construit statiquement à la volée.
}

[pacolito]

Merci dragonjoker59 pour ces précisions sur les pointeurs !! Du coup j'ai utilisé ta première solution, mais je n'ai pas le bon résultat et je ne sais vraiment pas pourquoi !! Pour mieux comprendre la suite, voici des indices

Code :

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

1
2
Attribut de Banque : vector<Compte*> m_comptes;
Attributs Compte : string id; double solde;

Voici le code et le résultat :

dans main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
int main()
{
    Banque b;
    b.loadBanque();
 
    for(unsigned int i(0); i < b.getComptes().size(); i++)
        cout << "Solde in main : " << (b.getComptes().at(i))->getSolde() << endl;
 
    return 0;
}

dans Banque.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
void Banque::addCompte(string id, double solde)
{
    Compte c(id, solde);
    m_comptes.push_back(&c);
}
 
void Banque::loadBanque()
{
    string id;
    double solde;
 
    while(conditions)
    {
        /* récupération de id et solde */
        cout << "Solde in function load : " << solde << endl;
        addCompte(id, solde);
    }
 
    for(unsigned int i(0); i < m_comptes.size(); i++)
        cout << "Solde end load : " << (m_comptes.at(i))->getSolde() << endl;
}

Voici les résultats :

Code :

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

1
2
3
4
5
6
Solde in function load : 1210 // ok
Solde in function load : 2042.3 // ok
Solde end load : 5.44973e+025 // où est passé 1210 ?
Solde end load : 6.52786e-039 // où est passé 2042.3 ?
Solde in main : 3.76419e-039 // ??
Solde in main : 3.76419e-039 // ??

Donc je ne comprends pas pourquoi mon vector ne se remplit pas correctement

Merci pour l'aide...

[dragonjoker59]

C'est ta fonction addCompte qui est fausse :

Code :

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

1
2
3
4
5
6
 
void Banque::addCompte(string id, double solde)
{
    Compte c(id, solde);
    m_comptes.push_back(&c);
}

Là tu crées statiquement un Compte et tu passes son adresse à ton vecteur, hors ce compte est une variable temporaire, et dès que tu sors de la fonction, la valeur pointée par le pointeur ajouté au vecteur est indéfinie. Tu stockes des pointeurs dans ton vecteur, je te conseille donc de créer dynamiquement (avec un new) le compte :

Code :

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

1
2
3
4
5
6
 
void Banque::addCompte(string id, double solde)
{
    Compte * c = new Compte(id, solde);
    m_comptes.push_back(c);
}

Et dans ton destructeur de Banque, il ne faut pas oublier de détruire tes pointeurs de comptes :

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
 
Banque::~Banque()
{
   for (size_t i = 0 ; i < m_comptes.size() ; i++)
   {
      delete m_comptes[i];
   }
   m_comptes.clear();
 
//OU
 
   for (vector<Compte*>::iterator it = m_comptes.begin() ; it != m_comptes.end() ; ++it)
   {
      delete ( * it);
   }
   m_comptes.clear();
}

[pacolito]

Edit : nous avons répondu au même moment Et puis tu as devancé mes questions... Donc j'ai toutes les réponses qu'il me fallait !!!

Merci merci beaucoup, j'ai compris maintenant !!!!!!!!!! yes !!! Merci




Je viens de modifier ma fonction addCompte et maintenant ça marche, mais...

Ancienne fonction addCompte:

Code :

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

1
2
3
4
5
void Banque::addCompte(string id, float solde)
{
    Compte c(id, solde);
    m_comptes.push_back(&c);
}

Nouvelle fonction addCompte:

Code :

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

1
2
3
4
void Banque::addCompte(string id, float solde)
{
    m_comptes.push_back( new Compte(id, solde) );
}

Du coup, comme je fais un "new" faut-il que je fasse un delete ?? Parce que là il y a une fuite mémoire non ??

Et puis c'est quoi la différence entre les 2 méthodes ?? Pourquoi avec la première je n'ai pas les bons résultats, et avec la seconde j'ai les bons ?? Comprends pas...

Merci !

[NoIdea]

Pourquoi des new partout ?
Le vecteurs de Compte* c'est pour le polymorphisme ou pour une raison inconnue ?
Si c'est pour le polymorphisme, alors il est justifié. Sinon, tu devrais voir si un std::vector<Compte> ne suffirait pas.

Du coup, comme je fais un "new" faut-il que je fasse un delete ?? Parce que là il y a une fuite mémoire non ??

Voir le code du destructeur de Banque poster par dragonjoker.

Et puis c'est quoi la différence entre les 2 méthodes ?? Pourquoi avec la première je n'ai pas les bons résultats, et avec la seconde j'ai les bons ?? Comprends pas...

Dans la première, voici ce que tu fais :

Création d'un objet Compte à une adresse A.
Stockage de l'adresse A dans le vector.
Destruction de l'objet compte qui se trouve à l'adresse A.

Question : il reste quoi à l'adresse A ?

Dans le deuxième, voici ce que tu fais.

Création d'un pointeur P.
Affectation de P à l'adresse A qui contient un objet Compte.
Passage de l'adresse A au vector.
Destruction du pointeur P.

Reste quoi à l'adresse A ?

[JolyLoic]

Pourquoi des new partout ?
Le vecteurs de Compte* c'est pour le polymorphisme ou pour une raison inconnue ?
Si c'est pour le polymorphisme, alors il est justifié. Sinon, tu devrais voir si un std::vector<Compte> ne suffirait pas.

Une autre justification serait que Compte est une classe avec une sémantique d'entité, non de valeur, pour laquelle la copie n'aurait pas de sens, voire serait néfaste. Ce qui est probablement le cas avec un compte...

Après, il y a sûrement moyen dans ce cas de travailler plus agréablement qu'avec un vector<Compte*>, par exemple avec un vector<shared_ptr<compte>>.

[NoIdea]

Une autre justification serait que Compte est une classe avec une sémantique d'entité, non de valeur, pour laquelle la copie n'aurait pas de sens, voire serait néfaste. Ce qui est probablement le cas avec un compte...

Pas tel qu'il est présenté. J'ai plutôt l'impression que compte n'est pas vraiment une classe C++ mais plutôt une structure C.

[JolyLoic]

Pas tel qu'il est présenté. J'ai plutôt l'impression que compte n'est pas vraiment une classe C++ mais plutôt une structure C.

Que ce soit une structure ou une classe me semble un peu accessoire en l'occurence (surtout dans un programme clairement à but pédagogique). ce qui me semble plus important, c'est qu'un compte a un identifiant, probablement unique, et un solde, qu'il ne faut probablement pas dupliquer non plus.

[pacolito]

A vrai dire je n'ai pas trop réfléchi pour utiliser vector<Compte> ou vector<Compte*> !

J'ai utilisé des pointeurs sur Compte* pour utiliser les pointeurs... c'était plus pour m'entraîner et pour manipuler des pointeurs !!

Si c'est pour le polymorphisme, alors il est justifié.

NoIdea, peux-tu expliquer pourquoi tu dis ça ?? Je ne vois pas quelle est la différence entre l'utilisation de pointeurs ou non...

Une autre justification serait que Compte est une classe avec une sémantique d'entité, non de valeur, pour laquelle la copie n'aurait pas de sens, voire serait néfaste.

ça veut dire quoi cette phrase ??

Excusez-moi pour toutes ces questions mais... je débute en C++ Donc j'ai pas mal de questions !! En tout cas merci pour votre aide !!

[Emmanuel Deloget]

A vrai dire je n'ai pas trop réfléchi pour utiliser vector<Compte> ou vector<Compte*> !

J'ai utilisé des pointeurs sur Compte* pour utiliser les pointeurs... c'était plus pour m'entraîner et pour manipuler des pointeurs !!


NoIdea, peux-tu expliquer pourquoi tu dis ça ?? Je ne vois pas quelle est la différence entre l'utilisation de pointeurs ou non...

ça veut dire quoi cette phrase ??

Excusez-moi pour toutes ces questions mais... je débute en C++ Donc j'ai pas mal de questions !! En tout cas merci pour votre aide !!

Ces phrases un peu absconses signifient :

1) pour la première, que lorsqu'on souhaite stocker dans un vecteur des objets dit polymorphiques (c'est à dire des instances de classes possédant des fonctions virtuelles) alors il est nécessaire de passer par un pointeur.

2) pour la seconde, qu'il existe (au moins) deux types d'objets au niveau conceptuels : les objets qui permettent le stockage de valeurs (par exemple un objet chaine de caractère) : on préfère ne pas les manipuler sous la forme de pointeurs, de manière à pouvoir les copier aisément si nécessaire ; les objets à sémantique d'entité, qui représente une entité particulière dans un système (par exemple une chaise spécifique dans un salon), qui sont pas définition des choses qu'on ne copie pas (va copier la chaise en question ; tu obtiendra une autre chaise, mais ce n'est plus celle que tu as copié).

Les histoires de sémantiques sont très liées au notions de conception - bien différencier la sémantique des objets qui composent une application permet de mieux définir leurs propriétés et la façon dont on va s'en servir, ce qui permet alors de proposer une conception plus proche des besoins exprimés pour cette application.