Imaginons que le programme que l'on est en train de déboguer comporte la définition d'une fonction carre, qui effectue le carré de deux entiers, définie de la manière suivante :
int carre(int x) { return x*x; }
int main(){
int a = 2;
carre(a);
return 0;
}
Au moment où la fonction main fait l'appel carre(a) (a étant une variable locale à main), on affecte x de la valeur de a dans le corps de la fonction carre et on évalue x*x. Si l'on a choisi de tracer la fonction carre comme indiqué plus haut, le programme s'interrompra à chaque appel à carre au niveau de la ligne << return x*x >>. Cependant, par exemple lors de l'appel carre(a), on ne pourra savoir au niveau du point d'arrêt la valeur de la variable a, qui est inconnue dans la fonction carre : carre ne connaît en fait que la variable x, et ne travaille qu'avec elle. Par conséquent, tenter de faire un << Print a >> provoquera un message d'erreur.
Il existe ainsi une notion de contexte associé à la pile d'appel : pour pouvoir connaître la valeur de a au moment de l'appel, il faut remonter d'un cran, au niveau de l'appel à la fonction carre (et non dans le corps même de cette fonction). Il faut donc changer de contexte, ce qui se fait en cliquant sur le bouton Up dans la fenêtre annexe : on revient ainsi au contexte où a été effectué l'appel à la fonction, contexte dans lequel la variable a est connue (on << remonte >> dans la pile d'appel d'un niveau, d'où le Up). Il faut être assez familier avec les notions de contexte et de niveau dans la pile d'appel pour manier le bouton Up (et son inverse Down, évidemment) avec dextérité. Une bonne manière de s'habituer à ces concepts est de lancer la fenêtre Backtrace, en choisissant Show Backtrace dans le menu Stack : ceci lance une nouvelle fenêtre dans laquelle est affichée la pile d'appel, et en cliquant sur les différentes lignes correspondant aux appels on a accès à une manière plus visuelle de naviguer entre les niveaux.