Why is my variable not being updated?

Question

I have defined a variable with an initial value.
When stepping through the code:

• I can see the initial value
• My function changes the value
• When I use the variable later it has the wrong value

What is happening?

_{Note: this is intended as a reference question for common problems. If the generic answers here don't help you, post a question containing your complete, actual code.}

Answer 1

I'd like to add another possible reason to Zack's excellent answer.

Optimisation

This one frequently surprises me. A good optimising compiler will notice when two different variables are never used at the same time, and will optimise the program by giving those variables the same address in memory. When you are stepping through the code, you may see a variable apparently changing in the watch window. But what's really happening is that the variable that shares its address is being written to.

The other trick the compiler pulls is simply getting rid of a variable that it realises isn't necessary. Sometimes you might be doing the equivalent of this in your code:

force_a = mass_a * acceleration_a
force_b = mass_b * acceleration_b
total_force = force_a + force_b

The compiler sees that there's no real need for the variables force_a and force_b, and so changes the code to this:

total_force = (mass_a * acceleration_a) + (mass_b * acceleration_b)

You'll never see force_a and force_b being updates, but you'll still be able to add them to the watch window.

When I step through my program, I'm convinced that some variable or other has the wrong value in it, but when I let my program run through without stepping, it seems to work. Check that this isn't happening to you.

Added:

As Ashish Kulkarni mentioned, you can check this by turning off optimisation.

Answer 2

There are several reasons why a variable might not keep a value. While some are arcane and difficult to debug, some of the most common reasons include:

The variable is modified by an interrupt

//---in main()---
unint8_t rxByte = 0;
printf("%d", rxByte);   //prints "0"

//---later in Uart0_Rx_Handler()---
rxByte = U0RXREG;       //rxByte set to (for example) 55

//---later in main()---
printf("%d", rxByte);   //still prints "0"!!!

If a variable is modified by an interrupt handler, it needs to be declared volatile. Volatile lets the compiler know that the variable could be modified asynchronously and that it shouldn't used a cached copy in a register.

//---in main()---
volatile unint8_t rxByte = 0;
printf("%d", rxByte);   //prints "0"

//---later in Uart0_Rx_Handler()---
rxByte = U0RXREG;       //rxByte set to 55

//---later in main()---
printf("%d", rxByte);   //corectly prints 55

Overrunning an array's bounds

There are no checks in C to prevent you from going beyond the bounds of an array.

int array[10];
int my_var = 55;

printf("%d", my_var);   //prints "55"
for(i=0; i<11; i++)   // eleven is one too many indexes for this array
{
  array[i] = i;
}
printf("%d", my_var);   // prints "11"!!!

In this case, we go through the loop 11 times, which is one index bigger than the array. In most compilers, this will result in overwriting variables declared after the array (anywhere on the page, they don't even have to be declared on the next line). This scenario can occur in many different circumstances, including multi-dimensional arrays and stack corruption.

Forgetting to dereference a pointer

While trivial, forgetting the asterisk on a pointer when making assignments will not set the variable correctly

int* pCount;
pCount = 10;   //forgot the asterisk!!!
printf("%d", *pCount);   //prints ??

Masking a variable with the same name

Reusing a variable name in an inner scope (like inside an if/for/while block or inside a function) hides a variable with the same name elsewhere.

int count = 10;   //count is 10
if(byteRecevied)
{
  int count = U0RXREG;   //count redeclared!!!
  DoSomething(count); 
  printf("%d", count);   //prints "55"
}
printf("%d", count);   //prints "10"