[Cours 04] Tableaux, Stuctures, Pointeurs sur fonction

Bonjour a tous pour ce nouveau cours .

Aujourd'hui nous allons aborder l'un des derniers cours de C, a savoir, les tableaux a X dimensions, les structures de donnees et les pointeurs sur fonctions.

A la fin de ce cours, vous saurez tout ce qu'il y a a savoir pour coder ce que vous voulez (si j'ai ete suffisament clair ).

Code:

-Tableau a X dimensions :

char  ***tab;


-Structures de donnees :

typedef struct   s_val
{
   int      i;
   int      j;
   char   *tab;
}            t_val;

-Pointeur sur fonction :

typedef struct   s_val
{
   int      i;
   void   (*f)();
}            t_val;

t_val   gl_key[]   =
   {
      {KEY_UP, keyup},
      {KEY_DOWN, keydown},
      {KEY_LEFT, keyleft},
      {KEY_RIGHT, keyright},
      {0, 0}
   };

Tableau à X dimensions

Qu'est-ce que tu appelles tableaux à X dimensions ? Et à quoi ça peut bien servir tout ça

Dans le cours precedents, je vous ai expliquer comment créer un tableau avec une plage de mémoire (malloc). C'est un peu comme un formulaire avec différent champs à remplir : Nom, Prenom, Age, Adresse, etc... avec une case par lettre.

Un tableau à 2 dimensions donnera donc une table sous excel, ou une table de multiplication avec les adresses de champs : 2 * 2 possède 4.

Un tableau à trois dimensions, c'est pareil, sauf qu'on rajoute la profondeur.

Et au-dessus, c'est physiquement impossible à réaliser, mais virtuellement possible

En fait, c'est possible, mais le terme de "tableau est trompeur". Il faudrait plutot parler d'index, ou de sous-catégorie :

(exemple de modélisation d'un tableau. Tout droit réservé )

Bon, une représentation, certe moche, mais j'espère assez claire .
L'indice "1" représente la première dimension du tableau : tab[i]. C'est le point de depart. Sur celle-ci, on peut voir qu'elle a été malloc-é à 2 (2 cases ).

Ensuite, les deuxièmes dimensions (indice 2 : tab[i][j]), ont chacun été chacun été malloc-é à 3.

Les troisièmes dimensions (tab[i][j][k]), ont un choix varié d'espace mémoire. Idem pour la quatrième : tab[i][j][k][l].

Vous pouvez avoir ainsi, quasiment autant de dimension qu'il vous reste de mémoire . Cependant, moi-même, je n'ai qu'une seule fois utilisée un tableau à 3 et 4 dimensions. Généralement je me sert de tableau à 2 dimensions (pour réaliser une map, un plateau de jeu, ou toutes les répliques d'un personnage, ...), et plus souvent des tableaux à une dimension (chaine de caractères, liste de nombre, ...).

Utilisation

Pour créer un tableau, il faut procéder de la même manière que pour un tableau simple. Je vais vous donner un exemple avec un tableau à 3 dimensions :

Code:

char   ***tab;
int      i;
int      j;
int      k;

tab = malloc(2 * sizeof(*tab));
for (i = 0; i < 2; i++)
   {
      tab[i] = malloc(5 * sizeof(**tab));
      for (j = 0; j < 5; j++)
         {
            tab[i][j] = malloc(3 * sizeof(***tab));
            for (k = 0; k < 3; k++)
               tab[i][j][k] = 'O';
         }
   }

//Toute votre application

for (i = 0; i < 2; i++)
   {
      for (j = 0; j < 5; j++)
         {
            free(tab[i][j]);
         }
      free(tab[i]);
   }
free(tab);

Au début, on alloue une plage de mémoire à 2 cases. Pour celà, même prototype que celui vu dans le cours précedent.

Puis, dans chaque case, au lieu de mettre un caractère, on réallouera des nouvelles dimensions qui contiendront chacune, 5 cases.

A nouveau, dans chacune de ces cases, on réalloura 3 cases dans lesquels on mettra le caractère 'O'.

Ainsi, notre dimension "k", contient tous les caractères de la chaines de caractère "j" appartenant elle-même à la réplique "i" d'un dialogue donné.

Bien entendu, ce n'est qu'un exemple d'utilisation (d'ailleur que je ne conseille pas trop pour un dialogue ). Aussi, les valeurs d'allocation de mémoire sont variables en fonction de vos besoins. J'ai déjà eu affaire à un tableau de 500 * 500 (250 Ko de RAM).

Vous avez pu constater que je ne dépasse pas la valeur d'allocation lors de mes déplacements dans les dimensions. Ainsi, la première dimension étant malloc-é à 2, je vais de 0 à 1 inclus. Et ainsi de suite. Je vous laisse deviner ce qui se passera si vous dépasser la limite .

Ensuite, une fois que vous avez fini toutes vos opérations avec votre tableau, il y a une chose d'important à faire : la libération de la mémoire.

RETENEZ qu'à chaque malloc que vous faites, vous devez faire le même nombre de free, en partant de la dernière dimension. Autrement, si vous ne free-ez que la première dimension, toutes les sous-dimensions sont perdues (ainsi que la plage de mémoire qui va avec).

Ainsi, les 4 Mo de RAM de la DS, n'aurait pu supporter que 16 maps de 500*500, avant que je n'éclate toute la mémoire.

Cependant, je n'ai pas free-é la dimension "k", tout simplement parce que je n'ai pas utiliser de malloc pour elle, mais uniquement une assignation de valeur .

Structures de données

Voici un point important et très intéressant du C : les structures. Pourquoi je vous dis ça ? car c'est la forme la plus proche de ce qu'on appelle l'Objet en C++. Sauf qu'il lui manque les choses propres aux Objets qui font ce qu'il est.

Mais en attendant, il reste très utile car il permet de transporter un ensemble de variable en une seule. De plus, il permet d'assigner un ensemble de mêmes valeurs à différents attributs, sans les redéclarer à la main.

Code:

typedef struct   s_val
{
   int      i;
   int      j;
   char   *tab;
}            t_val;

Je vais vous expliquer les différents mot-clés :
-typedef : permet de créer un nouveau genre de variable, de la même manière que les "int", les "char" et autres.
-struct : c'est pour signaler au C que l'on s'apprête à créer une structure (logique ).
-s_val : c'est le nom de base de la structure.
-entre les "{ }", on a la liste des variables que la structure possède.
-t_val : c'est le nom du type de variable.

Vous pouvez mettre le nom que vous voulez pour "s_val" et "t_val". Cependant j'aime bien mettre le "s_" et le "t_" en préfixe afin de bien voir qu'il s'agit ici d'une structure (caprice personnel ).

Les structures sont à prototyper entre le Header et les fonctions, au tout début du code source. Autrement, le C ne saura pas compiler dans le cas où certaines fonctions font appelles à cette structure. L'idéal serait de la déclarer dans un fichier "include", mais je reviendrai dans un prochain cours dessus .

Utilisation

Code:

/*
**   Cours_04.c for Cours 04
**   Sekoda
**   05/03/07
*/

typedef struct   s_val
{
   int      i;
   int      j;
   char   *tab;
}            t_val;

int   main()
{
   t_val   val;
   int      i;

   val.tab = "Coucou tout le monde.";
   val.i = 5;
   val.j = 10;
   i = 20;
   return (0);
}

Comme vous pouvez le constater, j'ai mis en préfixe le nom de ma structure sur toutes les variables qui la constitue. D'autre part, la variable ''i" et "val.i" sont totalement différentes.

On pourra dire que la structure est le nom de famille. Ainsi, on a la variable "i de la fonction main" et "i de la structure val" (drôle de nom de famille, mais ils ont le mérite d'être noble ).

Concernant les pointeurs sur structures, il suffit de remplacer le préfixe "val." par "val->" (une magnifique flêche pour symboliser le pointage, elle n'est pas belle la vie de developpeur ? ).
Ainsi :

Code:

/*
**   Cours_04.c for Cours 04
**   Sekoda
**   05/03/07
*/

typedef struct   s_val
{
   int      i;
   int      j;
   char   *tab;
}            t_val;

void      point_struct(t_val *val)
{
   val->i = 10;
   val->j = 500;
}

int         main()
{
   t_val   val;
   int      i;

   val.tab = "Coucou tout le monde.";
   val.i = 5;
   val.j = 10;
   i = 20;
   // Avant la fonction suivante, i et j valent respectivement 5 et 10
   point_struct(&val);
   // Apres la fonction, i et j valent 10 et 500
   return (0);
}

Cool, en gros c'est juste pour nous simplifier la vie pour l'écriture des variables

En premier lieu, oui .

En deuxième lieu, toujours oui , mais ça va encore plus loin

Il est vrai que les exemples que je vous ai donné n'était pas très concrêtes. Mais si je vous donne ce code, vous comprenez mieux ?

Code:

/*
**   Cours_04.c for Cours 04
**   Sekoda
**   05/03/07
*/

#include <stdlib.h>

typedef struct   s_perso
{
   int      force;
   int      defense;
   int      vitesse;
   int      sagesse;
   int      esquive;
   int      vie;
   int      magie;
   int      niveau;
   char   *nom;
   char   *prenom;
   char   *classe;
}            t_perso;

void      create_perso(t_perso *perso, int i, char *prenom, char *name, \\
                  char *classe)
{
   srand(i);
   perso[i]->force = rand() % 10;
   perso[i]->defence = rand() % 6;
   perso[i]->vitesse = rand() % 7;
   perso[i]->sagesse = rand() % 5;
   perso[i]->esquive = rand() % 2;
   perso[i]->vie = rand() % 30;
   perso[i]->magie = rand() % 10;
   perso[i]->niveau = rand() % 2;
   perso[i]->nom = name;
   perso[i]->prenom = prenom;
   perso[i]->classe = classe;
}

int         main()
{
   t_perso   *perso;

   perso = malloc(6 * sizeof(*perso))
   /*
   ** Attribution de la memoire pour toutes
   ** les variables statistiques des 6 personnages.
   */
   create_perso(perso, 0, "Sekoda", "MasGaNo", "Magicien");
   create_perso(perso, 1, "Dark", "Vador", "Sith");
   create_perso(perso, 2, "Atr", "Desmit", "Guerrier");
   create_perso(perso, 3, "V!p€r", "Dodge", "Voleur");
   create_perso(perso, 4, "Illusion", "Asena", "Illusionniste");
   create_perso(perso, 5, "KaZu", "Blondin", "Alchimiste");
   free(perso);
   return (0);
}

Plus simple comme ça, non ?

Pointeurs sur fonction

Nous attaquons avec ce qui vous facilitera la vie avec la gestion d'évenement .

Voici ma réponse au "switch", aux longues listes "if... else if... else" et autre cas de figure possible .

Voici un "extrait" de code que j'ai fait pour un petit projet en SDL (comparable à la PAlib) :

Code:

/*
** my_events.c for sdl in c:\sdl
**
** Made by sekoda masgano
** Login  <Sekoda>
**
** Started on  Wed Dec 13 14:44:34 2006
** Last update Thu Dec 14 20:33:00 2006
*/

typedef   struct   s_prog
{
   SDL_Event   event;
   t_perso      perso;
}            t_prog;

typedef struct   s_keys
{
   SDLKey      keys;
   void      (*f)();
}            t_keys;

t_keys   gl_keys[] =
  {
    {SDLK_ESCAPE, my_quit},
    {SDLK_UP, moveup},
    {SDLK_DOWN, movedown},
    {SDLK_LEFT, moveleft},
    {SDLK_RIGHT, moveright},
    {0, 0}
  };

void      my_quit(t_prog *prog)
{
   free(prog->perso);
   SDL_Quit();
   exit(0);
}

void      moveup(t_prog *prog)
{
   prog->perso.posy--;
   anime_perso(prog, "up");
}

void      moveleft(t_prog *prog)
{
   prog->perso.posx--;
   anime_perso(prog, "left");
}

void      moveright(t_prog *prog)
{
   prog->perso.posx++;
   anime_perso(prog, "right");
}

void      movedown(t_prog *prog)
{
   prog->perso.posy++;
   anime_perso(prog, "down");
}

void      my_keys(t_prog *prog)
{
  int      i;

  for (i = 0; i < 6; i++)
    if (prog->event.key.keysym.sym == gl_keys[i].keys)
      {
        gl_keys[i].f(prog);
      }
}

int         main()
{
   t_prog   prog;
   int      i;

   SDL_Init(SDL_INIT_VIDEO);
   create_perso(&prog)
   while (42)
      {
         SDL_WaitEvent(&prog.event);
         for (i = 0; i < 4; i++)
            if (prog->event.key.keysym.sym == gl_keys[i].keys)
               {
                  gl_keys[i].f(prog);
               }
      }
   SDL_Quit();
   return (0);
}

Déjà quelques explication au niveau de la SDL, afin de comprendre les fonctions inédites (mais inutile pour la PAlib ) que j'ai utilisé ici, afin de vous faire comprendre que je ne cherche pas à vous cacher des choses .

Code:

-SDL_Init = PA_Init() : déclencher le mode SDL du programme.

-SDL_Quit : commande à utiliser afin de libérer toute la mémoire occupée par la SDL et de quitter celle-ci.

-SDL_WaitEvent : permet d'attendre qu'un évenement se passe avant de poursuivre son programme. Celà évite que le programme ne tourne pour rien. Comparable à PA_WaitForVBL.

-SDL_Event : est une structure qui contient toutes les données sur le moindre evenement qu'il puisse se passer (appuie sur une touche, déplacement de la souris, ...).

-SDL_Key : est une structure qui donne l'état des touches du clavier.

-t_prog prog : est une structure qui contient non seulement la strucure t_perso, et la structure d'évenement. Et oui les structures peuvent contenir d'autre structure ^_^.

Pour le reste, vous pouvez reconnaître les fonctions du chapitre précedent, notamment la structure "t_perso", et la fonction "create_perso" modifiée.

Utilisation

On va extraire la partie du code qui nous intéresse :

Code:

typedef struct   s_keys
{
   SDLKey      keys;
   void      (*f)();
}            t_keys;

t_keys   gl_keys[] =
  {
    {SDLK_ESCAPE, my_quit},
    {SDLK_UP, moveup},
    {SDLK_DOWN, movedown},
    {SDLK_RETURN, choix},
    {SDLK_LEFT, moveleft},
    {SDLK_RIGHT, moveright},
    {0, 0}
  };

-------------------------------------------------------------------------------------
   while (42)
      {
         SDL_WaitEvent(&prog.event);
         for (i = 0; i < 4; i++)
            if (prog->event.key.keysym.sym == gl_keys[i].keys)
               {
                  gl_keys[i].f(prog);
               }
      }

Pour commencer, on doit déclarer une structure qui contiendra toutes les valeurs de comparaisons et d'execution.
A savoir :

Code:

typedef struct   s_keys
{
   SDLKey      keys;
   void      (*f)();
}            t_keys;

Dans cette structure, on peut voir qu'elle contient la structure d'état des touches du clavier et un pointeur sur une fonction. Vous pouvez bien entendu remplacer la structure SDLKey par une variable de comparaison de votre choix.

Juste après, et en dehors de toute fonction, on déclare en globale cette structure :

Code:

t_keys   gl_keys[] =
  {
    {SDLK_ESCAPE, my_quit},
    {SDLK_UP, moveup},
    {SDLK_DOWN, movedown},
    {SDLK_RETURN, choix},
    {SDLK_LEFT, moveleft},
    {SDLK_RIGHT, moveright},
    {0, 0}
  };

Attends ! Tu vas trop vite. Détail ce que tu as fait

-Déclarer une variable en global, c'est vouloir faire en sorte qu'une variable soit disponible pour n'importe quelle fonction sans être à nouveau déclarée ou passée en paramètre. Cependant, je vous déconseille fortement de déclarer vos variables en globale, car même s'il est vrai que celà permet de gagner du temps sur les pointeurs et autre, quand vous attaquerez de gros projets, vous allez vite vous emmelez les pinceaux et provoquez des erreurs inattendues. Modérez donc vos déclarations globales.

-Dans cette déclaration globale de la structure, nous l'initialisons en dur. C'est à dire sans malloc-é. Le prototype :

Code:

t_keys   gl_keys[] =

signifie que l'on duplique la structure de la même manière que la structure de personnage à l'aide de malloc.
Cependant, on le fait ici en dur, donc on n'a pas à connaître le nombre de comparaison, mais on ne peut changer le contenu de la structure. De plus, vu que c'est en global, la mémoire ne sera libérée qu'à la fin du programme. Donc ne faites qu'une fois cette opération pour toutes les touches que vous uilisez afin de ne pas prendre davantage de mémoire qu'il n'en faut.

Ici, nous créons donc une structure à 7 cases, et nous attibuons à chaque case, les valeurs mises entre "{ }" et dans l'ordre d'apparition. Ici, nous avons deux variables : la structure des touches, et la fonction appelée. Nous allons donc attribuez les touches que l'on veut utiliser, et la fonction à appelée en cas de comparaison positive de la touche appuyée.

Ainsi, par ce code :

Code:

         for (i = 0; i < 6; i++)
            if (prog->event.key.keysym.sym == gl_keys[i].keys)
               {
                  gl_keys[i].f(prog);
               }

On teste pour chaque structure la touche appuyée. Si la comparaison est bonne, on appelle la fonction qui est associée à la touche, en lui envoyant les arguments qu'elle attend, autrement, on passe à la case suivante.

Vous pouvez constatez qu'il y a toujours en préfixe, le nom de la structure, ainsi que son numéro d'adresse, vu qu'on la dupliquée.

Faites attention à l'incrémentation, afin qu'elle ne dépasse pas le nombre limite de la structure. Autrement, vous allez avoir des problèmes de mémoire .

Remarques


C'est quoi le "void" que tu as utilisé

Bonne remarque .
Il est désormais temps de vous en parler.
Vous avez pu consatez qu'il y a des fois des retours de valeur qui ne servent complètement à rien, car on utilise pas l'état de sortie de la fonction. Ainsi, pour éviter de devoir taper la ligne "return (0)", alors que l'on connaît pertinement son inutilité si elle n'est pas récupérée et traitée dans la fonction qui l'a appelée, on met donc dans le prototypage de la fonction un "void", afin de ne rien retourner .


On ne peut comparer qu'une seule valeure

Non . Vous pouvez comparer autant de valeur que vous voulez.
Cependant, il faut penser à rajouter celà dans le contenu de la structure et dans son remplissage :

Code:

typedef struct   s_keys
{
   SDLKey      keys;
   int         lifehero;
   void      (*f)();
}            t_keys;

t_keys   gl_keys[] =
  {
    {SDLK_ESCAPE, NULL, my_quit},
    {SDLK_UP, 50, moveup},
    {SDLK_DOWN, NULL, movedown},
    {SDLK_LEFT, 50, moveleft},
    {SDLK_RIGHT, 50, moveright},
    {0, 0}
  };

Ainsi, j'ai rajouté la vie du héros dans son déplacement. Mais si jamais j'appuie sur la touche "Echap" pour quitter mon programme, je n'ai pas besoin de savoir la valeur de la vie de mon perso. Ainsi, je met "NULL" pour lui faire comprendre que je n'en ai pas besoin. Idem si jamais j'appuise sur la flèche du bas, j'ai envie que mon personnage rentre à la base quelque soit la vie qui lui reste. Autrement, il part à l'affront si il possède 50 points de vie .

Et c'est quoi l'utilité

Comme je l'ai déjà dit, celà permet d'éviter la longue liste d'argument de "switch" ainsi que l'usage repétée des "break". Cette méthode permet de gagner plus de temps et de ligne, afin de rendre plus lisible le code, et en cas de modification, il n'y a qu'une ligne à ajouter ou à retirer en début de fichier, au lieu de chercher dans le code, le moment où "switch" est appelée.
Après, cela reste du confort personnel et si vous voulez quand même utiliser cette commande, ce n'est pas moi qui vous l'interdirais

Conclusion

Et voilà, ce cours est désormais terminé .

J'espère avoir été suffisament clair.

Autrement, n'hésitez pas à m'en faire part dans le sujet de discussion associé afin que j'apporte des éclaircissements sur ces derniers chapitres qui sont assez important pour vous facilitez la tâche.

Ce serait un comble si ces méthodes devaient vous rendre la vie plus compliquée .

A la prochaine .

Prochain cours : les Listes Chainées.