Prise en main d'IPcute

IPcute est un outil d'apprentissage de l'algorithmique. Télécharger IPcute
Il est destiné aux débutants du langage Pascal pour leur permettre de visualiser pas à pas les modifications des variables, de la pile d'exécution et du tas. Il est basé sur une machine virtuelle interprétant le code au fur et à mesure pour représenter graphiquement l'état de la mémoire au cours de l'exécution.
Visualisation, dans le tas, des pointeurs constituants : une liste doublement chaînée, et un arbre binaire.

Visualisation des variables globales

Voici un code de permutation de deux variables grâce à une troisième variable auxiliaire :

program prgm1; 

var a,b,c:integer; 
begin 
     a:=1; 
     b:=2; 
      
     c:=a; 
     a:=b;   
     b:=c; 
end.

Après avoir vérifié la syntaxe [Maj+F7], lancez l'exécution pas à pas [Maj+F8].
Une fenêtre "Variables globales" apparaît, affichant un tableau avec le nom des variables et leurs valeurs actuelles (initialement vides). Utilisez le pas approfondi [F7] pour exécuter le code ligne par ligne et repérez les modifications de valeurs des variables (la dernière valeur modifiée est surlignée en jaune).
Etat des variables globales après l'instruction

c:=a;

Visualisation de la pile d'exécution

Lorsqu'une fonction ou une procédure est appelée, la fenêtre "Pile d'exécution" affiche un tableau avec le nom des paramètres et des variables locales (en notation pointée

NomFonction.NomParametre

) ainsi que leurs valeurs.

Voici un code de permutation de deux variables grâce à une procédure auxiliaire :

program prgm2; 

procedure permuter(var x,y:integer); 
var z:integer; 
begin 
     z:=x; 
     x:=y; 
     y:=z; 
end; 

var a,b:integer; 
begin 
     a:=1; 
     b:=2; 
      
     permuter(a,b); 
end.

Etat de la pile d'exécution après l'instruction

z:=x;

Remarque : si une fonction est appelée plusieurs fois, un indice d'appel est intercalé dans la notation pointée. Appels récursifs d'une fonction factorielle(n) avec n=5.

Visualisation du tas

La visualisation des interactions entre pointeurs dans le tas est surement le plus grand atout d'IPcute. Il est idéal pour apprendre à concevoir des algorithmes de manipulation des structures de données dynamiques (listes, arbres, graphes...)


Voici un code de permutation de deux pointeurs grâce à une procédure auxiliaire :

program prgm3; 

type pint = ^integer; 

procedure permuter(var x,y:pint); 
var z:pint; 
begin 
     z:=x; 
     x:=y; 
     y:=z; 
end; 

var pa,pb:pint; 
begin 
     new(pa); 
     pa^ := 1; 
      
     new(pb); 
     pb^ := 2; 
      
     permuter(pa,pb); 
      
     dispose(pa); 
     dispose(pb); 
end.

Il est important de remarquer que les cases bleues correspondent à l'espace mémoire, et les carrés verts aux pointeurs déclarés dans la liste des variables globales ou dans la pile d'exécution. La liste des pointeurs attachés à une adresse mémoire apparaissent en survolant le carré vert avec la souris. Deux espaces mémoires alloués dans le tas, celui du haut (survolé par la souris) est pointé par PA.

Attention : si un espace mémoire n'est plus pointé (et donc inaccessible) il disparaît de la visualisation du tas, mais cela ne signifie pas qu'il a été proprement désalloué de la mémoire (avec dispose).

Structures de données dans le tas

Lorsque l'on utilise des types record pour manipuler des données multiples, toute les informations ne sont pas affichées. L'étiquette de la visualisation est alors décrite par le champ déclaré sur la première ligne (le dernier de la ligne s'il y a plusieurs déclarations sur celle-ci). Des autres données, seuls les pointeurs sont représentés, par des cases à côté de l'étiquette (de gauche à droite dans l'ordre de déclaration) d'où sortent une flèche pour atteindre l'espace pointé.


Voici un code représentant l'arbre généalogique de Martin Dupond :

program prgm4; 

type ppersonne = ^personne; 

type personne = record 
                nom,prenom:string; 
                pere,mere:ppersonne; 
                end; 

var p:ppersonne; 
begin 
     new(p); 
     p^.nom:='DUPOND'; 
     p^.prenom:='Martin'; 

     new(p^.pere); 
     p^.pere^.nom:='DUPOND'; 
     p^.pere^.prenom:='Pierre'; 

     new(p^.mere); 
     p^.mere^.nom:='MOREAU'; 
     p^.mere^.prenom:='Nathalie'; 

     dispose(p^.pere); 
     dispose(p^.mere); 
     dispose(p); 
end.