I write a short code in c

it may work well, but when I add an if ... else ... structure, a computation before the structure can not give a correct result

compilation and run can do well, but the result is wrong. Very strange

(1)
y2 = expression; //y2 = 0 always 0 error
.................

add : if(a->is_root) c = m2 - y2;
else f = m2 - y2;


(2)

y2 = expression; //y2 = 0 always 0 error
.................

add : if(a->is_root) c = m2 - y2;
if(!a->is_root) f = m2 - y2;


(3)
y2 = expression; // y2 = normal value; normal
.................

add : //if(a->is_root) c = m2 - y2;
if(!a->is_root) f = m2 - y2;


(4)

y2 = expression; // y2 = normal value; normal
.................

add : if(a->is_root) c = m2 - y2;
//if(!a->is_root) f = m2 - y2;

(5)
y2 = expression; // y2 = normal value; normal

add : //if(a->is_root) c = m2 - y2;
//if(!a->is_root) f = m2 - y2;

Trouble: can not use if... else ... normally

Question: (1) if... else ... can influence a previous statement, why?
(2) How to solve the problem?

It would be helpful if you could provide an compilable example of your problem.

This happens in a large function, which has a relatively complicated algorithm.

Simply speaking, its structure is as such:
___________________________________________________________
some basic calculation
------------------------------

y = expression;

-------------------------------
____________________________________________________________
some operations
--------------------------------

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

if {
block 1;
}

else{
if { block 2; }
else { block 3; }
}

The structure of blocks 2 and 3 will change the way in which y is calculated. The result is wrong. I check it through gdb. The five results above are obtained at the same environment except for the changes in the two blocks

In many executions, y is always equal to 0. Otherwise, it will be far larger than a right value.

But when either or each of the two blocks is removed, y will obtain a normal value.

I can not understand

I'm afraid your description of the problem give no clue.
Without a compilable example, nobody is going to guess what is wrong with your code.

The only possible situation here is that block2 or block3 are overflowing a variable on your function's stack and your y var is being changed.

A function's stack is composed (growing from high memory to low memory) by variables (in reverse order), eip, esp, function name and esp.

Here is a simple example for your possible situation:
As you will be able to see, variable b overflows into variable a.

The mistaken value is assigned to y when execute 'y = expression;'

in gdb, 'p y' will give the mistaken value after runing the above statement.

but ' p expression' gives the right value.

block2 and block3 are like this:

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

As said before:
only one statement: if(a->is_root) c = m2 - y2; // y2 normal
only one statement: if(!a->is_root) f = m2 - y2; // y2 normal

but:

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

or

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

both make y2 abnormal. 'y2 = expression' is far away from if__ else __ structure

Thanks for your teaching

Hum! What kind of var is y2? What is the expression assigned to it? There are really several things that can cause that so is a bit hard to help you without the full compilable code.