Programmer en vrai

Si vous abordez ce dernier tutoriel, c’est que vous connaissez déjà les principaux concepts de la programmation. Mais AlgoTouch reste un outil pédagogique et son langage est limité pour cette raison. Pour continuer dans la formation à la programmation, il faut s’investir dans l’apprentissage de vrais langages de programmation comme C, C++, Python ou Java. Les notions abordées avec AlgoTouch se retrouvent dans tous ces langages de programmation : variables, tableaux, index, affectations, opérations, conditionnelles, boucles et macro-instructions. Des notions nouvelles seront abordées :
  • les fonctions et procédures avec les notions de paramètres en remplacement des macros, qui permettent notamment de créer des bibliothèques de programmes réutilisables
  • la récursivité, une alternative à la boucle dans certains cas, qui autorise qu’une fonction s’appelle elle-même
  • la création dynamique de mémoire, qui permet par exemple de créer des nouveaux tableaux à l’exécution
  • la programmation par objets qui permet de créer à l’infini des nouveaux types, autres que les entiers ou les caractères.
Cependant, la réalisation de logiciels nécessite toujours la conception d’algorithmes. Même si de nombreux algorithmes sont déjà disponibles dans les bibliothèques de programmes, il y a toujours des cas spécifiques à développer. Concevoir un algorithme est une activité indépendante du langage de programmation. En ce sens, AlgoTouch peut rester un outil de conception d’algorithme. Les outils de transformation des programmes AlgoTouch dans l’un des langages cités plus haut, permettent de poursuivre le travail de programmation dans un environnement approprié.

AlgoTouch permet de transformer les programmes réalisés dans différents langages de programmation. Les codes produits sont directement exécutables dans les environnements adaptés. Les sections suivantes illustrent les différents cas.

Exportation du programme Agt en texte

  • Fichier → Exporter : enregistrer les programmes de toutes les macros utilisées dans la macro courante en tant que fichier texte dans le langage AlgoTouch (extension .prg)

Programme

 

Le programme commence par une entête,

/*
* Program generated automatically by AlgoTouch
* 06/05/2020 16:06:54
*/

suivie de la déclaration des variables, constantes, tableaux index, puis de la définition de chaque macro.

Les variables
/*
 *  Variables
 */
  int prod ; // produit coef par note
  int som ; // somme des notes avec coefficient
  int c ; // coeff à lire
  int somCo ; // Somme des coeff
  char etud ; // Nom etudiant (différent de .)
  char TOTO ; // Etudiant fictif
  int moy ; // moyenne calculée
  int recu ; // Seuil pour etre recu
  int colle ; // Seuil pour etre colle
  int note ; // notes saisies
  // Coefficients
  int coef[3] = {
    1, 2, 1 } ;
  index i of coef ;
  const int coef.length = 3 ; // Coefficients

Les macros

Elle commencent par un commentaire puis la définition de la macro.

/*
 * Verifie si une note est comprise entre 0 et 20
 * 
 * Sortie : note
 * 
 */
Define SaisieNote
  From
    // ...
  Until
    // ...
  Loop
    // ...
  Terminate
    // ...
End

Le code à l’intérieur des blocs est le même que celui affiché sur la zone Instructions.

Exportation en Java

  • Fichier → Exporter en Java… : transforme la macro courante en programme Java (extension .java), en substituant chaque appel de macro par le code Java correspondant.
Programme
  • une classe portant le nom du fichier Java est construite
  • le code du programme se trouve dans la méthode main
  • le programme est indenté correctement
  • les macros sont remplacées par leur code lors d’un appel (leur rôle est conservé en commentaire)

Variables, constantes, tableaux, index

  • les variables sont déclarées localement à la méthode main
  • les constantes sont transformées en final int ou char
  • les constantes définissant la taille d’un tableau sont éliminées  (car elles sont définies automatiquement)
  • les index sont transformés en int

Entrées et sorties

  • les entrées/sorties sont gérées sur la console (le terminal).

Boucle

  • la boucle Until … Loop  est remplacée par un while
  • la condition de continuation du while est recalculée automatiquement à partir des conditions de sortie

Exportation en Python

  • Fichier → Exporter en Python… : transforme la macro courante en programme Python (extension .py), en substituant chaque appel de macro par le code Python correspondant.
Variables, constantes, tableaux, index
  •  les variables sont déclarées avec leur valeur courante pour typage
  •  les constantes sont déclarées comme les variables
  •  les tableaux sont initialisés avec leurs valeurs
  •  les constantes définissant la taille d’un tableau sont renommées et initialisées. Exemple tab.length est déclaré ainsi :
    tab_length = len(tab)
    Dans le code, tab_length remplace tab.length
  •  les index sont des entiers initialisés à 0
Programme
  • les points virgule de fin d’instructions sont supprimés
  • le programme est indenté correctement
    • obligatoire en Python
    • les blocs (entre accolades) sont indentés (accolades supprimées)
  • le code vide dans un then est remplacé par pass, instruction vide en Python
  • les macros sont remplacées par leur code lors d’un appel
Entrées et sorties
  • les opérations read sont remplacées
    • pour les caractères par
      c = input("message")
    • pour les entiers
      i = int(input("message"))
  • les opérations write sont remplacées par
    print("message", x)
Boucle
  • la boucle Loop until est remplacée par un while
    • la condition de continuation du while est recalculée automatiquement à partir des conditions de sortie
    • les sorties multiples sont gérées avec l’opérateur and

Exportation en C/C++

  • Fichier → Exporter en C/C++… : transforme la macro courante en programme C++ (extension .cc), en substituant chaque appel de macro par le code C++ correspondant. En fait, le programme est un programme en C dans lequel les opérations de saisie et d’affichage utilisent les instructions cin et cout du langage C++.
Variables, constantes, tableaux, index
  • les tableaux respectent la syntaxe du langage C
    int x[]
  • les constantes définissant la taille d’un tableau sont renommées et initialisées. Pour les entiers :
    tab_length = sizeof(tab)/sizeof(int) ;
    Pour les caractères :
    tab_length = sizeof(tab)/sizeof(char) ;
    Dans le code, tab_length remplace tab.length
Programme
  • entếte pour E/S
    #include
    using namespace std ;

  •  
Entrées et sorties
  • l’opération
    read "message" x
    est remplacée par
    cout << "message" << endl; 
    cin >> x ;
  • l’opération
    write "message" y
      est remplacée par
    cout << "message" << y << endl;
Boucle
La boucle Loop until est remplacée par un while
  • la condition de continuation du while est recalculée automatiquement à partir des conditions de sortie
  • les sorties multiples sont gérées avec l’opérateur &&

Exportation en C

  • Fichier → Exporter en C… : transforme la macro courante en programme C (extension .c), en substituant chaque appel de macro par le code C correspondant. Le code produit est très proche du code C/C++ seules les E/S changent.
Pour un entier x
  • l’opération
    read "message" x
    est remplacée par :
    printf("message\n");
    scanf("%d", &x);
  • et l’opération
    write "message" x
    est remplacée par :
    printf("message %d\n", x);
Pour un caractère y
  • l’opération
    read "message" y
    est remplacée par :
    scanf(" %c",&y);
  • et l’opération
    write "message" y
    est remplacée par :
    printf("message %c\n", y);
  • Dans les deux cas, à noter l’espace avant %c