Petit problème de logique...

Version imprimable

Dans mon programme, cette fonction :

Code:

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
bool Sprite_Menu::OnClick(int numSprite, int xsouris, int ysouris, int click)
{
    if (xsouris > rect[numSprite].x && xsouris < rect[numSprite].x+rect[numSprite].w && ysouris > rect[numSprite].y && ysouris <  rect[numSprite].y+rect[numSprite].h)
    {
      if (click == 1)
      {
         if(Souris_T != 0)
         {
            Uint32 Dif = SDL_GetTicks() - Souris_T;
            if( Dif > Temp_MIN )
            if( Dif < Temp_MAX )
            {
            return true;
            }
            else
            {
            Souris_T = 0;
            return false;
            }
         }
       else
       {
       Souris_T = SDL_GetTicks();
       return false;
       }
      }
      else return false;
    }
    else return false;
}

retourne toujours true quand je clique, meme si je fais :

Code:

1
2
3
4
5
            if( Dif > Temp_MIN )
            if( Dif < Temp_MAX )
            {
            return false;
            }

D'ou peut venir la cause ?

31/10/2005, 16h31
dirty_boy

Salut,

ma réponse est totalement hypothétique mais bon. Je crois me souvenir que lorsque tu clique, il y a en fait un clic quand tu appuie mais aussi quand tu relache le bouton. Peut etre cela vient il de ca.

Cordialement.
31/10/2005, 17h14
Laurent Gomila
Moi ce qui me choque c'est que si tu fais
Code:

1 2 3 4 5 if( Dif > Temp_MIN ) if( Dif < Temp_MAX ) { return false; }
alors il n'y a plus aucun "return true" dans ta fonction, il est donc impossible qu'elle te renvoie true.

Le mieux est encore de faire une execution pas à pas pour voir par où passe ton code, et pourquoi il ne te renvoie pas ce que tu veux.
31/10/2005, 18h35
insomniak

Il me semble que quand une fonction ne peut rien retourner, elle retourne true ou 1 (en fonction que ce soit un int ou un bool)... Peut être que ça viendrait de là.

@Loulou24 Pourtant, elle retourne true, c'est bien ce qui pose problème...

EDIT : Quand je laisse le clic appuyé, la fonction retourne true, avant que je relache le bouton.
31/10/2005, 18h39
Médinoc

On pourrait voir dans quel contexte elle est appelée? (je sens un truc louche, dans le genre c'est-même-pas-cette-fonction-là-qui-est-appelée où une mauvaise mémorisation du résultat...)

Voila, dans le contexte :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
        switch (menu.mode)
                 {
                 case 0:
                 menu.Destination(0, 310, 200, true);
                 menu.Destination(1, 250, 300, true);
                 menu.OnMouse(0, xsouris, ysouris, boutons[0]);
                 menu.OnMouse(1, xsouris, ysouris, boutons[0]);
            if (menu.OnClick(0, xsouris, ysouris, boutons[0]) == true) menu.mode = 1;/////////////LA VOILA//////////////
                 menu.affich(screen, 0);
                 menu.affich(screen, 1);
                 break;
                 case 1:
                 menu.Destination(0, 310, 200, true);
                 menu.Destination(2, 280, 250, false);
                 menu.Destination(3, 320, 300, false);
                 menu.OnMouse(0, xsouris, ysouris, boutons[0]);
                 menu.OnMouse(2, xsouris, ysouris, boutons[0]);
                 menu.OnMouse(3, xsouris, ysouris, boutons[0]);
                 menu.affich(screen, 0);
                 menu.affich(screen, 2);
                 menu.affich(screen, 3);
                 break;

Ce code est dans un boucle while(1).

EDIT : Si je définit
#define Temp_MIN 40000
#define Temp_MAX 40000

il suffit d'un clic de meme pas une seconde pour que ça le fasse...

31/10/2005, 18h46
Laurent Gomila

Citation:

Il me semble que quand une fonction ne peut rien retourner, elle retourne true ou 1 (en fonction que ce soit un int ou un bool)... Peut être que ça viendrait de là.

Qu'est-ce que tu entends par "quand une fonction ne peut rien retourner" ? Une fonction non void doit toujours retourner quelque chose, si tu oublies un return dans tous tes if le compilo ne le laissera pas passer.

Mais comme je te l'ai dit, avec une execution pas à pas tu verrais tout de suite ce qui cloche...
31/10/2005, 18h47
insomniak

J'ai essayé, je n'arrive pas à comprendre le fonctionnement du pas à pas (sous devc++)
31/10/2005, 18h50
insomniak

Ah si, c'est bon, j'ai réussi. Mais je ne comprend plus rien... Ca retourne bien false pourtant...
31/10/2005, 18h55
insomniak

Excusez moi pour le triple post...

Mais est-ce qu'il existe un moyen pour quitter une fonction en cours ?
31/10/2005, 18h59
Laurent Gomila

Citation:

Excusez moi pour le triple post...

Tu peux éditer tes posts, au lieu d'en ajouter :wink:

Citation:

Mais est-ce qu'il existe un moyen pour quitter une fonction en cours ?

Ben... Un return ?
31/10/2005, 19h00
insomniak

Mmmmh... C'est bien ce qu'il em semblait, il n'y a pas d'autre moyens...

Bon, il va falloirt que je cherche une autre solution...
31/10/2005, 19h09
insomniak

Ca y est !! J'ai finalement régler le problème en enlevant le dernier else, en laissant seulement return false. Ca ne me dit pas pourquoi ça buggait avant, mais au moins ça marche.
31/10/2005, 19h29
Médinoc

J'ai trouvé!
Quand ce test:

Citation:

Uint32 Dif = SDL_GetTicks() - Souris_T;
if( Dif > Temp_MIN )
if( Dif < Temp_MAX )

était faux, le programme ne passait par aucun return (c'était peut-être un peu complexe pour que le compilo signale que "not all control paths return a value"....)

Il me semble que tu avais oublié un return (bizarre que le compilo n'ait rien dit...) :

Code:

1
2
3
4
5
6
7
8
9
10
if( Dif > Temp_MIN )
            if( Dif < Temp_MAX )
            {
            return true;
            }
            else
            {
            Souris_T = 0;
            return false;
            }

Tu as deux if mais le premier n'a pas sa clause else. Donc, si Dif >= Temp_MIN, il n'y a aucun return, et apparamment le compilo ne dit rien et renvoie quelque chose d'assimilable à true.

Tu peux simplement faire ça :

Code:

1
2
3
4
5
6
7
8
9
if( Dif > Temp_MIN && Dif < Temp_MAX )
            {
            return true;
            }
            else
            {
            Souris_T = 0;
            return false;
            }

Ou encore, comme c'est parfois conseillé, utiliser la règle dont je ne sais plus le nom, qui dit "un point d'entrée, un point de sortie". Ca donnerait quelque chose comme ç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
24
25
26
27
28
29
30
31
32
bool Sprite_Menu::OnClick(int numSprite, int xsouris, int ysouris, int click)
{
    // Un point d'entrée
    bool Ret = false;
 
    if (xsouris > rect[numSprite].x && xsouris < rect[numSprite].x+rect[numSprite].w && ysouris > rect[numSprite].y && ysouris <  rect[numSprite].y+rect[numSprite].h)
    {
      if (click == 1)
      {
         if(Souris_T != 0)
         {
            Uint32 Dif = SDL_GetTicks() - Souris_T;
            if( Dif > Temp_MIN )
            if( Dif < Temp_MAX )
            {
                Ret = true;
            }
            else
            {
                Souris_T = 0;
            }
         }
       else
       {
           Souris_T = SDL_GetTicks();
       }
      }
    }
 
    // Un point de sortie
    return Ret;
}

Comme ça tu es sûr de renvoyer quelque chose.

31/10/2005, 20h13
insomniak

Oui, c'est sur. Je vais arranger mon code un petit peu.