Valeur innatendue avec std::queue::front()

Bonjour!
Pour testes quelques petits truc j'ai écrit un petit prog:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <glib.h>
 
class B;
 
class A
{
    public:
 
    /*  constructeurs   */
    A();
    virtual ~A();
 
    protected:
 
    /*  Membres protégés    */
    B* m_pb;
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <iostream>
#include <glib.h>
#include <queue>
 
class B
{
    friend class A;
    public:
    B();
    virtual ~B();
    protected:
 
    /*  Membres protégés    */
    std::queue<int> m_qint;
 
    /*  Fonctions protégées */
    bool _push(int);
    void _affiche();
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "CA.h"
#include "CB.h"
 
/*  construct et destruct   */
A::A():m_pb(new B)
{
    char fin='n';
    int i;
    do{
    std::cout<<"Entrez un entier (Attention aucun test d'erreur impléménté!!):";
    std::cin>>i;
    m_pb->_push(i);
    std::cout<<"Voulez-vous continuer?(o/n):"<<std::endl;
    std::cin>>fin;
    }while(fin!='n' && fin!='N');
    std::cout<<"Voulez-vous dépiler le conteneur?(o/n):";
    std::cin>>fin;
    if(fin=='o' || fin=='O')m_pb->_affiche();
}
A::~A(){}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include "CB.h"
 
/* construct et destruct    */
B::B(){}
B::~B(){}
 
/* Fonctins protégées   */
void B::_affiche()
{
    while(m_qint.size())
    {
        std::cout<<"Message de B:\nTaille du conteneur: "<<m_qint.size();
        std::cout<<"\nJe dépile mon conteneur:\t"<<m_qint.front()<<std::cout<<std::endl;
        m_qint.pop();
    }
}
 
/* Fonctions */
bool B::_push(int i)
{
    m_qint.push(i);
    return true;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <queue>
 
#include "CA.h"
 
int main()
{
    std::queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    while(q.size()){
        std::cout<<"taile de q:"<<q.size()<<"\nelement:\t"<<q.front()<<std::endl;
        q.pop();
    }
    A a;
    return 0;
}

Citation:

taile de q:3
element: 1
taile de q:2
element: 2
taile de q:1
element: 3
Entrez un entier (Attention aucun test d'erreur impléménté!!):1
Voulez-vous continuer?(o/n):
o
Entrez un entier (Attention aucun test d'erreur impléménté!!):2
Voulez-vous continuer?(o/n):
o
Entrez un entier (Attention aucun test d'erreur impléménté!!):3
Voulez-vous continuer?(o/n):
n
Voulez-vous dépiler le conteneur?(o/n):o
Message de B:
Taille du conteneur: 3
Je dépile mon conteneur: 10x604ca8
Message de B:
Taille du conteneur: 2
Je dépile mon conteneur: 20x604ca8
Message de B:
Taille du conteneur: 1
Je dépile mon conteneur: 30x604ca8

Press ENTER to continue.

Beaucoup de code pour pas grand chose, si ce n'est ce petit lièvre...
Quelle explication se cache derrière ces valeurs?

Citation:

Envoyé par Krishna

Beaucoup de code pour pas grand chose, si ce n'est ce petit lièvre...
Quelle explication se cache derrière ces valeurs?
Code:

1 2 std::cout<<"\nJe dépile mon conteneur:\t"<<m_qint.front()<<std::cout<<std::endl;

:oops: eu...merci

Salut,

Au passage, et bien que cela n'ai pas énormément de rapport avec ta question...

Si la classe A prend la responsabilité de demander l'allocation dynamique de la mémoire pour contenir un B, il semblerait cohérent qu'elle prenne aussi la responsabilité... d'en demander la libération ;)

En effet, il ne faut pas oublier qu'à chaque new (ou new[]) doit correspondre ... un delete (ou delete[])

Si tu n'invoque pas delete sur le membre m_pb de ta classe A, au plus tard lors de la destruction de A, tu te dirige droit vers une fuite mémoire, ce qui, à terme, risque de mener à des catastrophes...

C'est pourquoi, dans le code que tu présentes, il faudrait modifier le destructeur de ta classe A en
Code:

1 2 3 4 5 6 A::~A() { delete m_pb; /* d'aucuns estiment que c'est inutile ;) */ m_pb=NULL; }
De même, pourquoi as tu déclaré le destructeur de A comme étant virtuel :question:

Comme il n'y a pas d'héritage déclaré avec comme base la classe A, c'est totalement inutile ;):D