Pawn (langage)

Les types de variables sont plus restreints qu'en C et leur déclaration est différente.

Effectivement, on va introduire le mot-clé « new » suivi du type (s'il y a) ainsi que le nom de la variable.

Par défaut, les variables sont déclarées comme des entiers, il n'est donc pas nécessaire de préciser un type dans ce cas-là.

Il est préférable d'initialiser chaque variable que l'on déclare afin qu'elle ne contienne pas une valeur erronée même si une valeur par défaut leur est attribuée.

new a = 3;

new Float:pi = 3.14;

new bool:lightOn = false;

new lettreB = 'B';

new monEncyclopedie[] = "Wikipédia";

main()
{
   new Float:pi = 3.14;
   printf("Une valeur approchée de pi est %f", pi);
}

On distinguera deux principales structures conditionnelles : « if » ainsi que le « switch ».

Cette structure se compose du mot-clé « if » précédant une expression booléenne.

Une première forme de cette structure se définit en une simple vérification comme ci-dessous :

main()
{
   new a = -4;
   if(a < 0)
   {
      printf("Le nombre est négatif ! (%d)", a);
   }
}

Néanmoins, nous pouvons tout aussi gérer la négation de la condition entrée avec le mot-clé « else ».

main()
{
   new a = -4;
   if(a < 0)
   {
      printf("Le nombre est négatif ! (%d)", a);
   }
   else
   {
      printf("Le nombre est positif ! (%d)", a);
   }
}

Un dernier mot-clé qui permet de vérifier une expression si jamais la précédente renvoyait la valeur « faux » : « else if ».

main()
{
   new a = -4;
   if(a < 0)
   {
      printf("Le nombre est négatif ! (%d)", a);
   }
   else if(a == 0)
   {
      printf("Le nombre est nul !");
   }
   else
   {
      printf("Le nombre est strictement positif ! (%d)", a);
   }
}

Remarque : en utilisant le « else » à la fin, je vérifie si aucune des conditions le précédant n'ont été remplies.

La structure globale débute, quoi qu'il en soit, par un « if ».

La structure « switch » (ou « cas..parmi » en terme algorithmique) est utilisée dans le cas où vous auriez à vérifier successivement les valeurs d'une variable. Vous pourrez utiliser une structure « if » avec un nombre considérable de « else if ».

Cependant, la structure « switch » s'adapte bien à ce genre de cas.

main()
{
   new a = 3;
   switch(a)
   {
       case 1:
       {
          printf("La variable 'a' stocke la valeur 1");
       }
       case 0, -1:
       {
          printf("La variable 'a' stocke la valeur 0 ou -1");
       }
       case 2..5:
       {
          printf("La variable 'a' stocke une valeur comprise entre 2 et 5");
       }
       default:
       {
          printf("La variable 'a' stocke une valeur différente de celles vérifiées précédemment");
       }
   }
}

Une structure itérative (ou boucle) va répéter un certain nombre de fois une ou plusieurs instructions (on parle d'itérations).

On distingue également deux principales structures itératives, chacune caractérisée par un nombre d'itérations déterminé.

La boucle « pour » va conventionnellement exécuter un nombre de fois déterminé les instructions imbriquées dans celle-ci.

On parle alors de boucle déterministe[5].

Dans une telle boucle, on utilisera souvent un incrément. Elle est particulièrement utile quand il faut répéter une instruction plusieurs fois comme un message à afficher ou des calculs successifs.

main()
{
   new somme = 0;
   for(new i = 0; i < 10; i++)
   {
       somme += i; // Équivalent à somme = somme + i;
   }
   printf("La somme des 10 premiers entiers est égale à %d.", somme);
/*
Ici on calcule la somme des 10 premiers entiers.
*/
}

La boucle «while» est, quant à elle, une boucle indéterministe.

Elle est généralement guidée par une condition qui ne vérifie pas un nombre d'itérations effectuées.

Une telle boucle ne nécessite pas forcément d'un incrément comme celle présentée ci-dessus.

main()
{
    new nb = 17;
    while(nb > 0)
    {
        nb /= 2;   // Équivalent à nb = nb / 2;
    }
/*
Dans cet exemple, on divise le nombre de départ successivement par 2 jusqu'à ce qu'il atteigne 0.
*/
}

La boucle «do..while» est, elle aussi, indéterministe.

Contrairement à la boucle «while», elle va exécuter les instructions qu'elles comportent avant de vérifier la condition.

Cela garantit au moins un passage dans la boucle. Elle est particulièrement sollicitée lors de contrôles de saisie utilisateur.

/* Programme calculant la somme des N premiers entiers non nuls (où N est saisi par l'utilisateur) */
main()
{
    new n_entiers = 0, sum = 0;
    /* Contrôle de la saisie utilisateur */
    do
    {
        printf("Saisissez jusqu'à quel entier la somme s'effectuera (nombre > 1): ");
        n_entiers = getvalue(); // La fonction getvalue() récupère la valeur entière saisie par l'utilisateur dans la console

    }
    while(n_entiers <= 1);

    /* Calcul de la somme des entiers consécutifs jusqu'à n_entiers */
    for(new i = 0; i <= n_entiers; i++)
        sum += i;

    /* Affichage des résultats */
    printf("La somme des entiers allant de 1 à %d est égale à %d", n_entiers, sum);
}

En algorithmique, on distingue souvent la fonction d'une procédure par l'existence ou non d'une valeur de retour. En C, la distinction s'effectue par le mot-clé mis devant la définition de la fonction (void ou un type de données). Le PAWN applique cependant une confusion entre les deux termes puisqu'il ne permet pas d'établir explicitement la différence entre ces deux notions.

Ainsi, la déclaration d'une fonction en PAWN se fait de la manière suivante :

main()
{
    /* Saisies de l'utilisateur */
    new a = getvalue();
    new b = getvalue();
    /* Affichage du résultat */
    printf("La multiplication de a par b retourne : %d", multiplie(a, b)); // Appel de la fonction créée
}
multiplie(a, b) // Multiplie un entier a par b
{
    return a * b; // On invoque ici le mot-clé return afin d'attribuer une valeur de retour à la fonction.
}

De même, si l'on souhaite renvoyer une donnée d'un type différent de l'entier il suffira de préciser le type devant la déclaration :

bool:AreEquals(a, b) // La fonction renvoie ici vrai ou faux
{
    return a == b; // Renvoie la valeur du test d'égalité
}

Il sera cependant nécessaire de préciser que la fonction renvoie un type différent de celui par défaut : l'entier. De ce fait, il faudra créer le prototype (ou encore entête) de votre fonction avant de l'appeler. On aura ainsi :

forward bool:AreEquals(a, b); // Création d'une entête en invoquant le mot-clé forward

main()
{
   new a = 5, b = 3;
   printf("A et B égaux ? %b\n", AreEquals(a, b));
}
bool:AreEquals(a, b)
{
   return a == b;
}

Une fonction peut présenter (ou non) des arguments dans la déclaration de sa fonction. Le langage Pawn propose deux types pour transmettre des paramètres à la fonction.

Le premier étant le passage de paramètres par valeur qui a la particularité de créer une copie de la variable passée en paramètre lors de l'appel de la fonction. Une telle copie ne peut donc affecter la valeur de la variable de départ.

main()
{
    new a = 2;
    square(a);
    printf("a vaut maintenant : %d", a); // a vaudra 2, avec un tel passage de paramètre
}
square(value)
{
   value *= value; // On ne retourne pas de résultat ici, on essaie d'agir directement sur la variable.
}

Ce passage de paramètres est favorisé pour des traitements sur la valeur d'une variable ou sa lecture. Néanmoins, si l'on veut modifier la valeur de la variable passée en paramètre il faudra favoriser le second passage de paramètres : par référence. Un tel passage implique la transmission à la fonction non pas de la valeur de la variable mais de son adresse mémoire permettant donc d'agir sur la variable en mémoire sans passer par une duplication de celle-ci[6].

main()
{
   new a = 2;
   square(a);
   printf("a vaut maintenant : %d", a); // a vaudra 4 en ayant changé le type de passage de paramètre
}
square(&value) // Il suffira d'ajouter un & qui récupèrera l'adresse mémoire de la variable et non pas la donnée qu'elle stocke.
{
   value *= value;
}

Ce type de passage est largement favorisé quand on est contraint de retourner plus d'une valeur (exemple : fonction qui convertit le nombre de secondes en hh-mm-ss)[6].