Prise en main d'IPcute

Septembre 2016

IPcute est un outil d'apprentissage de l'algorithmique. 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.

Télécharger IPcute


top
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).
top
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 appellé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.

top
Etat de la pile d'exécution après l'instruction z:=x;

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

Visualisation du tas


La visualisation des intéractions 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.
top
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.
top

A voir également :

Ce document intitulé «  Prise en main d'IPcute  » issu de CommentCaMarche (www.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.