MagPI 10 Page 22

De Le French MagPi
Aller à : Navigation, rechercher

Sommaire

Programmation modulaire

Le concept de module est la clé de la compréhension de Charm (N.B. dans ce contexte, les modules Charm sont différents des modules Risc OS !). Chaque module est ouvert par le mot-clef module et chaque fichier source compilé par Charm contient la définition d'un seul module. Il peut cependant importer des déclarations exportées par un nombre quelconque d'autres modules dont il dépend.

Les références pointent généralement vers d'autres modules du projet et vers les modules de la bibliothèque d'exécution (Run Time Library ou RTL en anglais) qui fournissent des fonctions essentielles à la gestion des fenêtres, des fichiers, du clavier et de l'écran. Ces dernières sont documentées sur le site web de Charm. L'ordre de compilation des modules est déterminé par le fichier de build du projet qui spécifie aussi le nom et l'emplacement de l'application ou du module lié.

Pour commencer

Voyons maintenant les premiers bouts de code Charm. Chaque projet doit contenir un et un seul module exposant une procédure ~start ayant une des deux signatures possibles.

Si aucun paramètre en ligne de commande n'est nécessaire la procédure ~start est définie comme suit :

module Main {
  export proc ~start() {...startup code }
}

Par conséquent, le programme hello world classique en Charm, qui utilise le flux vdu de la bibliothèque runtime Out, peut être codé de la manière suivante dans le fichier src.hello :

import lib.Out;
module Hello {
  export proc ~start () {
    Out.vdu.str ("Hello World!\n");
  }
}

Le fichier de build du projet doit contenir :

module hello
program hello

afin de construire le programme avant de pouvoir le lancer (l'éditeur de liens trouvera automatiquement la bibliothèque Out pour vous).

Un projet concret

Si vous êtes partant pour un défi, je vous suggère de remplacer le module par défaut !NewProject MyProject avec le code suivant pour afficher les douze premières factorielles :

import lib.Out;

module MyProject
{
  proc factorial (int n) int
  {
    if n <= 1 return 1;
    return n * factorial (n - 1);
  }
  export proc start (ref array ref array char argv)
  {
    for int i := 1 step inc (i) while i <= 12
    Out.vdu.num_fld (i, 2).str ("! = ").num (factorial (i)).nl ();
  }
}

Ce code illustre l'utilisation de la récursivité pour calculer chaque valeur à partir de la précédente au moyen d'une multiplication, en partant du principe que 1! = 1.

Finalement, comme exercice, essayez de modifier le programme pour qu'il soit capable de calculer les 20 premières factorielles sans être affecté par la taille limitée des entiers sur 32 bits (indice : retournez une factorielle comme un réel et utilisez .float au lieu de .num pour l'afficher).

La prochaine fois

La prochaine fois, j'ai l'intention de traiter les types de données de Charm, les variables, les chaînes et la portée.

Outils personnels
Espaces de noms

Variantes
Actions
Navigation
Boîte à outils