Je vous écris un petit code en c

mai, il fonctionne bien, mais quand je ajouter une si ... else ... structure, un calcul avant que la structure ne peut pas donner un résultat correct

la compilation et l'exécution peuvent faire bien, mais le résultat est mauvais. Très étrange

(1)
y2 \u003d expression; / / y2 \u003d 0 toujours 0 erreur
.................

ajouter: if (a-> is_root) c \u003d m2 - y2;
else f \u003d m2 - y2;


(2)

y2 \u003d expression; / / y2 \u003d 0 toujours 0 erreur
.................

ajouter: if (a-> is_root) c \u003d m2 - y2;
if (! a-> is_root) f \u003d m2 - y2;


(3)
y2 \u003d expression; / / y2 \u003d valeur normale, normale
.................

ajouter: / / if (a-> is_root) c \u003d m2 - y2;
if (! a-> is_root) f \u003d m2 - y2;


(4)

y2 \u003d expression; / / y2 \u003d valeur normale, normale
.................

ajouter: if (a-> is_root) c \u003d m2 - y2;
/ / if (! a-> is_root) f \u003d m2 - y2;

(5)
y2 \u003d expression; / / y2 \u003d valeur normale, normale

ajouter: / / if (a-> is_root) c \u003d m2 - y2;
/ / if (! a-> is_root) f \u003d m2 - y2;

Problème: ne peut pas utiliser en cas de ... else ... normalement

Question: (1) si ... else ... peuvent influer sur une précédente déclaration, pourquoi?
(2) Comment faire pour résoudre le problème?

Il serait utile si vous pouviez donner un exemple compilable de votre problème.

Cela se passe dans une grande fonction, qui dispose d'un algorithme relativement complexe.

En bref, sa structure est comme tel:
___________________________________________________________
base de calcul
------------------------------

y \u003d expression;

-------------------------------
____________________________________________________________
certaines opérations
--------------------------------

--------------------------------

if (
bloc 1;
)

else (
(si le bloc 2;)
else (bloc 3;)
)

La structure des blocs 2 et 3 vont changer la façon dont y est calculé. Le résultat est faux. Je vérifie par gdb. Les cinq résultats ci-dessus sont obtenus dans le même environnement, sauf pour les changements dans les deux blocs

Dans de nombreuses exécutions, y est toujours égal à 0. Sinon, il sera beaucoup plus grande que la valeur d'un droit.

Mais quand l'un ou chacun des deux blocs est enlevé, y aura une valeur normale.

Je ne comprends pas

J'ai bien peur que votre description du problème ne donne pas la moindre idée.
Sans compilable par exemple, personne ne va à deviner quel est le problème avec votre code.

La seule situation ici est que block2 ou block3 regorgent d'une variable sur la pile de votre fonction et votre y var est en train de changer.

Une fonction de la pile est composée (de plus en plus grande quantité de mémoire à peu de mémoire) par variables (dans l'ordre inverse), eip, esp, Nom de fonction et esp.

Voici un exemple simple possible pour votre situation:
Comme vous pourrez le voir, la variable b déborde dans la variable a.

La valeur est attribuée à tort à y exécuter quand 'y \u003d expression; "

dans gdb, 'py' va donner la fausse valeur runing après la déclaration ci-dessus.

mais' p expression donne le droit de valeur.

block2 et block3 sont comme ceci:

if (a-> is_root) c \u003d m2 - y2;
else f \u003d m2 - y2;

Comme dit auparavant:
une seule déclaration: si (a-> is_root) c \u003d m2 - y2 / / y2 normal
une seule déclaration: if (! a-> is_root) f \u003d m2 - y2 / / y2 normal

mais:

if (a-> is_root) c \u003d m2 - y2;
else f \u003d m2 - y2;

ou

if (a-> is_root) c \u003d m2 - y2;
if (! a-> is_root) f \u003d m2 - y2;

les deux font y2 anormal. 'y2 \u003d expression »est loin de if__ autre structure __

Merci pour votre enseignement

Hum! Quel type de la variable est y2? Quelle est la expression qui lui sont assignées? Il ya en fait plusieurs choses qui peuvent causer de sorte que c'est un peu difficile de vous aider sans le code compilable.