Discussion :

[bob2356]

Bonjour à tous,

débutant en C++ (mais déjà confirmé en Java, donc pas débutant en programmation), je suis confronté à un problème de mémoire que je ne comprend pas (n'ayant jamais eu à gêrer la mémoire auparavent). Le programme est un petit jeu en 2D.

J'utilise Visual C++ .net, et mon problème se situe dans une liste (std::list). J'utilise une liste de pointeurs vers des objets (list<GameObject*>) dont j'actualise l'état et que j'affiche grâce à la méthode GameObject::refresh().

voici le code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void GameState::render()
{
    list<GameObject*>::iterator iter;
 
    for( iter = m_renderable_objects.begin(); iter != m_renderable_objects.end(); iter++) 
    {
        if(!((*iter)->getParent()))
            (*iter)->refresh(SDL_GetTicks());
    }
}

Parmis ces GameObject à actualiser et afficher, deux sous-classe sont incriminée : Sea et Boat.
Boat possède une liste de GameObject enfants. On a donc (en simplifiant le vrai code) :

Code :

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

1
2
3
4
5
6
7
8
 
void Boat::refresh(int _time)
{
    list <GameObject *>::iterator end = m_children.end();
    for (list <GameObject *>::iterator iter = m_children.begin(); iter != end; ++iter)
    {
        (*iter)->refresh(_time);
}

Sea, quand à elle, dessine dans son Sea::refresh() une spline, et donc possède un double *m_second_derivative qui sert à stocker un tableau de double représentant la dérivée seconde des points de contrôles de la spline (il s'agit d'une spline cubique).
Voilà donc le code (simplifié là encore) :

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
53
 
void Sea::refresh(int _time)
{
    animate();
    calculateSecondDerivative();
    display();
}
 
void Sea::calculateSecondDerivative()
{
    double yp0 = (m_ctrl_points[1].getY()-m_ctrl_points[0].getY()) /
                 (m_ctrl_points[1].getX()-m_ctrl_points[0].getX());
    double ypnm1 = (m_ctrl_points[m_nb_ctrl_points-1].getY()-m_ctrl_points[m_nb_ctrl_points-2].getY()) /
                   (m_ctrl_points[m_nb_ctrl_points-1].getX()-m_ctrl_points[m_nb_ctrl_points-2].getX());
    int i,k;
    double p,qn,sig,un,*u;
 
    u = new double[m_nb_ctrl_points];
 
    //evite la pente initiale trop importante
    if (yp0 > 1e30)
        m_second_derivative[0]=u[0]=0.0;
    else
    {
        m_second_derivative[0] = -0.5;
        u[0]=(3.0/(double)(m_ctrl_points[1].getX()-m_ctrl_points[0].getX()))*((double)(m_ctrl_points[1].getY()-m_ctrl_points[0].getY()) /
             (double)(m_ctrl_points[1].getX()-m_ctrl_points[0].getX())-yp0);
    }
 
    for (i=1;i<m_nb_ctrl_points-1;i++)
    {
        sig=(double)(m_ctrl_points[i].getX()-m_ctrl_points[i-1].getX())/(double)(m_ctrl_points[i+1].getX()-m_ctrl_points[i-1].getX());
        p=sig*m_second_derivative[i-1]+2.0;
        m_second_derivative[i]=(sig-1.0)/p;
        u[i]=(double)(m_ctrl_points[i+1].getY()-m_ctrl_points[i].getY())/(float)(m_ctrl_points[i+1].getX()-m_ctrl_points[i].getX()) -
             (double)(m_ctrl_points[i].getY()-m_ctrl_points[i-1].getY())/(double)(m_ctrl_points[i].getX()-m_ctrl_points[i-1].getX());
        u[i]=(6.0*u[i]/(double)(m_ctrl_points[i+1].getX()-m_ctrl_points[i-1].getX())-sig*u[i-1])/p;
    }
 
    //evite la pente finale trop importante
    if (ypnm1 > 0.99e30)
        qn=un=0.0;
    else {
        qn=0.5;
        un=(3.0/(double)(m_ctrl_points[m_nb_ctrl_points-1].getX()-m_ctrl_points[m_nb_ctrl_points-2].getX()))*(ypnm1-(double)(m_ctrl_points[m_nb_ctrl_points-1].getY() -
           m_ctrl_points[m_nb_ctrl_points-2].getY())/(double)(m_ctrl_points[m_nb_ctrl_points-1].getX()-m_ctrl_points[m_nb_ctrl_points-2].getX()));
    }
 
    m_second_derivative[m_nb_ctrl_points-1]=(un-qn*u[m_nb_ctrl_points-2])/(qn*m_second_derivative[m_nb_ctrl_points-2]+1.0);
    for (k=m_nb_ctrl_points-2;k>=0;k--)        m_second_derivative[k]=m_second_derivative[k]*m_second_derivative[k+1]+u[k];
 
    delete [] u;
}

Et si vous êtes encore là (je sais que cet exposé est un peu long, mais j'ai peur de ne pas être clair !), voilà où est le problème :

lors de la première itération de ma boucle principale de jeu, les adresses mémoires de la liste Boat::m_children sont les suivantes (d'après le debugger) :

Code :

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

1
2
3
4
 
m_children::Myhead 0x003e2b60
m_children::_Next 0x003e5bd8
m_children::_Prev 0x003e5bd8

la liste ne contient qu'un élément et j'observe bien m_children::_Mysize = 1

eh bien juste après le passage dans Sea::calculateSecondDerivative(), qui est affiché juste après, ces valeurs changent pour des valeurs bizarres :

Code :

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

1
2
3
4
 
m_children::Myhead 0x003e2b60
m_children::_Next 0x503e382b
m_children::_Prev 0xbeccc318

evidemment, dès la deuxième itération, le programme plante avec un joli "Access violation reading location 0x503e382b", ce qui me parait logique.

Ce qui m'est incompréhensible, c'est comment le remplissage d'un tableau de double dans une classe peut agir sur les adresses d'une liste qui est dans une autre classe...

Peut-être est-ce le symptôme d'un problème qui vient d'ailleur, mais je ne sais pas du tout où regarder...

Quelqu'un aurait-il une piste ?

Antoine

[loufoque]

Tes fonctions membres sont bien virtuelles ?

[tut]

ça sent le "jardinage"...
Vérifie que tu n'écries pas au-delà des limites de tes tableaux, parce que si c'est le cas, tu peux très bien aller écrire dans ta liste.... et alors là...

[bob2356]

Malheureusement, il me semble bien que je ne sors pas des bornes du tableau.
Voilà un extrait du constructeur de Sea :

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
 
Sea::Sea(const float _width, const float _height, const int _sampling)
{
    m_nb_ctrl_points = (int)ceilf(m_width/145);
    m_ctrl_points = new Position[m_nb_ctrl_points];
    m_ctrl_points_ref = new Position[m_nb_ctrl_points];
 
    float step = m_width / (m_nb_ctrl_points-1);
 
    m_second_derivative = new double[m_nb_ctrl_points];
 
    for (int i = 0; i < m_nb_ctrl_points; ++ i)
    {
        m_ctrl_points[i] = Position(i * step, 0);
        m_ctrl_points_ref[i] = m_ctrl_points[i];
        m_second_derivative[i]=0;
    }
 
}

et voilà à quoi ressemble la boucle dans laquelle les adresses changent de manière suspecte, dans Sea::calculateSecondDerivative()

Code :

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

1
2
3
4
5
 
    for (i=1;i<m_nb_ctrl_points-1;i++)
    {
        ...
    }

donc là, je boucle à partir du deuxième élément jusqu'à l'avant dernier. Aucune raison de sortir des bornes donc... J'ai tout de même vérifié si m_nb_ctrl_points ne change pas de valeur, et sa valeur reste toujours la même.

Donc je reste bloqué sur cette erreur. Des idées ?

Antoine

EDIT: GameObject::refresh() est déclarée virtuelle, ainsi que Boat::refresh() et Sea::refresh().

[mat.M]

for (int i = 0; i < m_nb_ctrl_points; ++ i)



En C pour remplir un tableau de 10 éléments on procéde comme cela :
i est d'abord initialisé à 0 puis si i=10 alors on sort de la boucle

int entiers[10];
int i;
for(i=0;i<10;i++) entiers[i]=0;

pour la boucle que tu as donnée précedemment , i est incrémenté AVANT d'être affecté donc les bornes de m_ctrl_points[i] vont être dépassées

[Jan Rendek]

Non Mat.M. for(int i=0; i < 10; ++i) et for(int i=0; i < 10; i++) donne 10 itérations avec i variant de 0 à 9.
Si tu veux t'en convaincre, écris un programme de test