Bien programmer en langage C

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
   int ret;
   char temp[20];

   do
   {
      char saisie[20];

      printf("Entrez un nombre : ");
      fflush (stdout);

      fgets (saisie, sizeof saisie, stdin);

      /* Filtrage des caracteres (entier decimal)
       * Nota : la saisie s'arrete a la premiere erreur.
       * Ce qui est saisi avant est considere comme valide.
       *
       * "123a" -> "123" : ret = 1
       *
       * "a123" -> ""    : ret = 0
       */
      ret = sscanf (saisie, "%[0-9-]s", temp);
   }
   while (ret != 1);

   {
      long n = strtol (temp, NULL, 10);

      printf ("La chaine est '%s', soit %ld\n", temp, n);
   }
   return 0;
}

#include <stdio.h>

int main (void)
{

   int x = fgetc(stdin);

   printf ("x = %d ('%c')\n", x, x);

   return 0;
}

<enter>
x = 10 ('
')

a<enter>
x = 97 ('a')

a<backspace>b<enter>
x = 98 ('b')

abcd<enter>
x = 97 ('a')

#include <stdio.h>

int main (void)
{
   int x;

   do
   {
      x = fgetc(stdin);
      printf ("x = %d ('%c')\n", x, x);
   }
   while (1);

   return 0;
}

 /* Definition d'un pointeur sur int */
   int *p_int;

/* Definition de la variable 'a' valant 4 */
   int a = 4;

   /* Definition d'un pointeur 'p' initialise' avec l'adresse de la variable 'a' */
   int *p = &a;

   /* Definition de la variable 'b' non initialisee */
   int b;

   /* recuperation de la valeur de 'a' dans 'b' via le pointeur 'p' */
   b = *p;

   /* 'b' vaut maintenant 4 */

/* pointeur sur une fonction avec 2 parametres */
   int (*pf) (int, char **);

   /* prototype d'un fonction ayant un pointeur de fonction comme parametre */
   int fun (int (*pf) (int, char **));

/* definition d'un alias */
   typedef int fun_f (int, char **);

   /* definition d'un pointeur de fonction de ce type */
   fun_f *pf;

   /* prototype d'une fonction ayant un pointeur de fonction comme parametre */
   int fun (fun_f *pf);

   /* tableau de pointeurs de fonction */
   fun_f *pf[10];

   /* prototype d'une fonction retournant un pointeur de fonction */
   fun_f *getfunc (int);

/* definition d'un alias */
   typedef int fun_f (int);

   /* definition d'un pointeur de fonction de ce type */
   fun_f *pf;

   /* prototype d'une fonction du meme type */
   int function (int);

   /* NOTA : on peut aussi utiliser le type */
   fun_f function;

   /* initialisation du pointeur de fonction */
   pf = fonction;

   /* appel de la fonction via le pointeur de fonction */
   pf (123);

/* Definition du pointeur. Il est initialise a l'etat invalide */
   int *p = NULL;

   /* le pointeur est initialise avec l'adresse d'un tableau
    * dynamique de 4 elements
    */
   p = malloc (4 * sizeof *p);

   /* en cas d'échec d'allocation, malloc() retourne NULL */
   if (p != NULL)
   {
      /* ... */

      /* apres utilisation, l'espace memoire est libere */
      free (p);

      /* le pointeur est force a l'etat invalide */
      p = NULL;
   }

int main (void)
{
   int tab[5];

   clear (tab);

   return 0;
}

void clear (int *p);

void clear (int *p)
{
   *(p + 0) = 0; /* premier element, */
   *(p + 1) = 0; /* deuxieme element, */
   *(p + 2) = 0; /* troisieme element, */
   *(p + 3) = 0; /* quatrieme element, */
   *(p + 4) = 0; /* dernier element (cinquieme) */
}

void clear (int *p)
{
   p[0] = 0; /* premier element, */
   p[1] = 0; /* deuxieme element, */
   p[2] = 0; /* troisieme element, */
   p[3] = 0; /* quatrieme element, */
   p[4] = 0; /* dernier element (cinquieme) */
}

void clear (int *p, size_t nb)
{
   size_t i;

   for (i = 0; i < nb; i++)
   {
      p[i] = 0;
   }
}

int main (void)
{
   int tab[5];

   clear (tab, 5);

   return 0;
}

 type_retour fonction (int p[])
  type_retour fonction (int p[12])
  type_retour fonction (int p[][34])
  type_retour fonction (int p[56][78])
  etc.

#define NB_ELEM(a) (sizeof (a) / sizeof *(a))

     /* interdit */
   "hello"[2] = 'x';

   /* autorise' */
   char s[] = "hello";

   s[2] = 'x';

char c;
   char *pa = &c;

   char *pb = 0;
   char *pc = NULL;

   char s[] = "hello";

   char *pd = s;
   char *pe = s + 3;

   /* une chaine litterale n'etant pas modifiable,
    * il est conseille de qualifier l'objet avec
    * 'const' (read-only)
    */
   char const *pf = "hello";
   char const *pg = "hello" + 2;

char c;

   :---------:--------:
   : adresse : valeur :
   :         :        :
   :---------:--------:
   : &c      : ???    :
   :---------:--------:

c = 'A';

   :---------:--------:
   : adresse : valeur :
   :         :        :
   :---------:--------:
   : &c      : 'A'    :
   :---------:--------:

char *p;

   :---------:--------:---------:
   : adresse : valeur : valeur  :
   :         :        : pointée :
   :---------:--------:---------:
   : &p      : ???    : ???     :
   :---------:--------:---------:

p = NULL;

   :---------:--------:---------:
   : adresse : valeur : valeur  :
   :         :        : pointée :
   :---------:--------:---------:
   : &p      : NULL   : ???     : --> NULL
   :---------:--------:---------:

p = &c;

   :---------:--------:---------:     :---------:--------:
   : adresse : valeur : valeur  :     : adresse : valeur :
   :         :        : pointée :     :         :        :
   :---------:--------:---------:     :---------:--------:
   : &p      : &c     : 'A'     : --> : &c      : 'A'    :
   :---------:--------:---------:     :---------:--------:

char s[]="ab";
   p = s;

   :---------:---------:---------:     :---------:--------:
   : adresse : valeur  : valeur  :     : adresse : valeur :
   :         :         : pointée :     :         :        :
   :---------:---------:---------:     :---------:--------:
   : &p      : &s[0]   : 'a'     : --> : s+0     : 'a'    :
   :         : ou s+0  :         :     :---------:--------:
   :         : ou s    :         :     : s+1     : 'b'    :
   :---------:---------:---------:     :---------:--------:
                                       : s+2     : 0      :
                                       :---------:--------:

:----------------:--------------:----------------:
: Système        : Fin de ligne : Fin de fichier :
:----------------:--------------:----------------:
: Unix           :              :                :
: Mac X          : 0x0A LF      : Sans objet     :
: Linux          :              :                :
:----------------:--------------:----------------:
: Mac (non unix) : 0x0D CR      : Sans objet     :
:----------------:--------------:----------------:
: MS-DOS         : 0x0D CR      : 0x1A           :
: Windows        : 0x0A LF      : ^Z             :
: Windows NT     :              :                :
:----------------:--------------:----------------:
: VMS STREAM_CR  : 0x0D CR      : Sans objet     :
:----------------:--------------:----------------:
: VMS STREAM_LF  : 0x0A LF      : Sans objet     :
:----------------:--------------:----------------:
: VMS STREAM_CRLF: 0x0D CR      : Sans objet     :
:                : 0x0A LF      :                :
:----------------:--------------:----------------:

FILE *fopen (char const *filename, char const *mode);

     "r"  : mode texte en lecture
   "w"  : mode texte en écriture (création)
   "a"  : mode texte en écriture (ajout)

   "rb" : mode binaire en lecture
   "wb" : mode binaire en écriture (création)
   "ab" : mode binaire en écriture (ajout)

Ceci est un simple fichier
texte de 2 lignes.

/* fichier1.c */
#include <stdio.h>

int main (void)
{
   /* ouverture du fichier en mode texte */
   FILE *fp = fopen ("data.txt", "r");

   /* L'ouverture du fichier est-elle realisee ? */
   if (fp != NULL)
   {
      /* definition d'un tableau de char destine a recevoir la ligne
       * La taille est arbitraire. Elle doit etre cependant adaptee * aux besoins courants.
       * Pour les grandes tailles (disons > 256 char),
       * il est preferable d'utiliser une allocation dynamique.
       */
      char ligne[32];

      /* lecture de la premiere ligne */
      fgets (ligne, sizeof ligne, fp);

      /* Affichage de la premiere ligne */
      printf ("1: %s\n", ligne);

      /* lecture de la deuxieme ligne */
      fgets (ligne, sizeof ligne, fp);

      /* Affichage de la deuxieme ligne */
      printf ("2: %s\n", ligne);

      /* Fermeture du fichier */
      fclose (fp);
   }
   else
   {
      printf ("Erreur d'ouverture du fichier\n");
   }
   return 0;
}
   

1: Ceci est un simple fichier

2: texte de 2 lignes.

     while (fonction_de_lecture(fp) != ERREUR)
   {
      ...
   }

   if (feof(fp))
   {
      /* la fin de fichier a ete detectee */
      puts ("EOF");
   }

   if (ferror(fp))
   {
      /* une erreur s'est produite */
      perror (NOM_DU_FICHIER);
   }

   fclose (fp);

#include <stdio.h>
#include <string.h>
   ...
{
   char ligne[123];

   /* test d'erreur omis */
   fgets (ligne, sizeof ligne, fp);

   {
      /* chercher le '\n' */
      char *p = strchr(ligne, '\n');

      if (p != NULL)
      {
         /* si on l'a trouve, on l'elimine. */
         *p = 0;
      }
      else
      {
         /* Le traitement depend de l'application.
          * Par exemple, ici, on choisi d'ignorer
          * les autres caracteres.
          */

         /* sinon, on lit tous les caracteres restants */
         int c;

         while ((c = fgetc(fp)) != '\n' && c != EOF)
         {
         }
      }
   }
}

/* fichier2.c */
#include <stdio.h>

int main (void)
{
   FILE *fp = fopen ("data.txt", "r");

   if (fp != NULL)
   {
      char ligne[32];

      /* definition d'un compteur de lignes et initialisation */
      int cpt = 0;

      /* lecture des lignes */
      while (fgets (ligne, sizeof ligne, fp) != NULL)
      {
         /* Mise a jour du compteur */
         cpt++;

         /* Affichage des lignes */
         printf ("%d: %s\n", cpt, ligne);
      }

      /* On peut ajouter ici la detection de la cause
       * de l'erreur decrite ci-dessus
       */

      fclose (fp);
   }
   else
   {
      printf ("Erreur d'ouverture du fichier\n");
   }

   return 0;
}

     <...>
      char ligne[16];
   <...>
  

1: Ceci est un sim
2: ple fichier

3: texte de 2 lign
4: es.
  

0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15 : Indice
'C' 'e' 'c' 'i' ' ' 'e' 's' 't' ' ' 'u' 'n' ' ' 's' 'i' 'm'  0 : Données

0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15 : Indice
'p' 'l' 'e' ' ' 'f' 'i' 'c' 'h' 'i' 'e' 'r' '\n' 0             : Données
  

#include <stdlib.h>
...
{
   /* creation d'un tableau de 10 int */
   size_t n = 10;
   int *p = (int*) malloc (sizeof (int) * n);

   if (p != NULL)
   {
      ...
}

{
   int *p = malloc (sizeof (int) * n);
}

{
   int *p = malloc (sizeof (int));
}

{
   long *p = malloc (sizeof (long));
}

{
   int *p = malloc (sizeof *p);
}

{
   long *p = malloc (sizeof *p);
}

#include <stdlib.h>

<...>
{
   /* allocation d'un tableau de 10 int
    * Pour pouvoir gerer la taille, on utilise
    * une variable 'taille'. Une structure comprenant
    * l'adresse du tableau et sa taille est aussi envisageable.
    */

   size_t size = 10;
   int *p = malloc (size * sizeof *p);

<...>

   /* Agrandissement du tableau a 15 int */
   {
      /* reallocation. Le resultat est stocke'
       * dans une variable temporaire
       */
      size = 15;
      type_s *p_tmp = realloc (p, size * sizeof *p_tmp);

      if (p_tmp != NULL)
      {
         /* si la nouvelle valeur est valide,
          * le pointeur original est mis a jour.
          */
         p = p_tmp;
      }
      else
      {
         /* l'ancien bloc est valide, mais il n'a pas ete agrandi */
      }
   }
}

scanf : floating point formats not linked
Abnormal program termination

#ifdef __BORLANDC__
/* The pesky "floating point formats not linked" killer hack : */
extern unsigned _floatconvert;
#pragma extref _floatconvert
#endif
   

/* data.c */

#include "data.h"

int G_x;

/* la taille du tableau est definie
 * dans la declaration.
 */
double G_a[];

data_s G_data;

#ifndef H_DATA
#define H_DATA

/* data.h */

typedef struct
{
   int a;
   char b[123];
}
data_s;

extern int G_x;

/* la defintion de la taille du tableau est unique. Elle est faite ici. */
extern double G_a[12];

extern data_s G_data;

#endif /* guard */
   

/* appli.c */

#include "data.h"

int main (void)
{
   G_x = 123;

   G_data.a = 456;

   G_a[3] = 123.456;

   return 0;
}
   

typedef struct
{
   unsigned a:1; /* variable de largeur 1 bit */
   unsigned b:3; /* variable de largeur 3 bits */

   /* etc. */
}
data_s;

typedef unsigned int uint;
<...>
typedef struct
{
   /* 16 bits */
   int year;        /* -32767..+32767 */
   uint month:4;    /* 0-15 */
   uint day:5;      /* 0-31 */

   uint hour:5;     /* 0-31 */
   uint minute:6;   /* 0-63 */
   uint second:6;   /* 0-63 */
}
sDATE;

void main (void)
{
}

main()
{
   return 0;
}

int main (void)

int main (int argc, char **argv)

 printf("Entrez un nombre : ");
   fflush (stdout);

int function (int a, char *b)
{
}

int function ();

int function (int a, char *b);

static int function (int a, char *b)
{
}

+--------------------+    +--------------------+
| Bloc fonctionnel A |    | Bloc Fonctionnel B |
+--------------------+    +--------------------+
               |               |
               v               v
             +--------------------+
             |       Outils       |
             +--------------------+

/* objet de portee globale */
int x;

int f (void)
{
   /* la globale x est masque'e par une locale du meme nom */
   int x = 0;

   /* la globale x n'est pas modifie'e. */
   x++;
}

int main (void)
{
   /* la globale x est modifie'e */
   x = 2;

   f();

   /* la globale x vaut toujours 2 */

   return 0;
}

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

int main (void)
{
   time_t now = time (NULL);
   struct tm tm_now = *localtime (&now);
   char s[64];

   strftime (s, sizeof s, "%d/%m/%Y", &tm_now);
   printf ("Aujourd'hui : %s\n", s);


   /* prochain Noel */
   {
      struct tm tm_xmas =
      {0};

      tm_xmas.tm_year = tm_now.tm_year;
      tm_xmas.tm_mon = 12 - 1;
      tm_xmas.tm_mday = 25;

      /* ajustement */
      {
         time_t xmas = mktime (&tm_xmas);

         strftime (s, sizeof s, "%d/%m/%Y", &tm_xmas);
         printf ("Noel : %s\n", s);

         {
            time_t diff = difftime (xmas, now);
            struct tm tm_diff = *gmtime (&diff);

            printf ("Plus que %d jours avant Noel\n", tm_diff.tm_yday);
         }
      }
   }

   return 0;
}

char s[4] = "ab";

char s[4] = "abc";

char s[4] = "abcd";

char s[4] = "abcde";

extern int x;
<...>
{
   x = 2;
}

int x;

<...>
{
   x = 2;
}

{
   int x;
<...>
   x = 2;
}

int f();

extern int g(void);

static int h();

static int i(int a)
{
}

int j(char *b)
{
}

int a;
static float b[12];
{
   struct xxx c;
   static long d;
}

int f()
{
}

int g(void)
{
}

/* permanente de portee illimitee */
int a;

/* permanente de portee limitee a l'unite de compilation */
static int b;

<...>
{
/* locale (de portee limitee au bloc) */
   int c;

/* permanente de portee limitee au bloc */
   static int d;

/* controlee de portee limitee a la validite du pointeur (non NULL) */
   int *p = malloc (sizeof *p * 3);


   free (p), p = NULL;
}

modem> _

modem> ATD0123456789
_

CONNECTED AT 9600 BAUDS

+---------------------+----------------+---------------------+----------------+
 | Les identificateurs |                | Exemple             | Exemple        |
 | commençant par      | suivi de       | valide              | Reservé        |
 +---------------------+----------------+---------------------+----------------+
 | "_"                 | "_A-Z"         | _123                | _ABC           |
 +---------------------+----------------+---------------------+----------------+
 | "is"                | "a-z"          | is_abc              | isabc          |
 +---------------------+----------------+---------------------+----------------+
 | "mem"               | "a-z"          |                     |                |
 +---------------------+----------------+---------------------+----------------+
 | "str"               | "a-z"          |                     |                |
 +---------------------+----------------+---------------------+----------------+
 | "to"                | "a-z           |                     |                |
 +---------------------+----------------+---------------------+----------------+
 | "wcs"               | "a-z"          |                     |                |
 +---------------------+----------------+---------------------+----------------+
 | "E"                 | "A-Z" ou "0-9" | Eabc                | E123 EABC      |
 +---------------------+----------------+---------------------+----------------+
 | "LC_"               | "A-Z"          | LC_abc LC_123 LCABC | LC_ABC         |
 +---------------------+----------------+---------------------+----------------+
 | "SIG"               | "_A-Z"         | SIGabc              | SIGABC SIG_ABC |
 +---------------------+----------------+---------------------+----------------+

+--------+   +------------+   +--------+
| entrée |-->| traitement |-->| sortie |
+--------+   +------------+   +--------+

MOV AH, 09h
   MOV AL, character
   MOV BH, 00h
   MOV BL, attributes
   MOV CX, 01h
   INT 10h

#if defined (__BORLANDC__)
#include <dos.h>
#else
#error Undefined for this platform
#endif

<...>

/* ---------------------------------------------------------------------
   VIDEO_putch()
   ---------------------------------------------------------------------
   ecriture d'un caractere a la position courante du curseur avec
   la couleur specifiee
   ---------------------------------------------------------------------
   E : caractere (0-255)
   E : couleur texte
   E : couleur fond
   S :
   --------------------------------------------------------------------- */
void VIDEO_putch (int c, eCOU ct, eCOU cf)
{
#if defined (__BORLANDC__)
   union REGS reg;

   /* caractere a écrire */
   reg.h.al = (uchar) c;

   /* putch avec attribut */
   reg.h.ah = 0x09;

   /* page 0 */
   reg.h.bh = 0;

   /* attributs 08h : clignotement */
   reg.h.bl = (uchar) (ct | ((cf & ~0x08) << 4));

   /* pas de repetitions */
   reg.x.cx = 1;

   /* Bios Video */
   int86 (0x10, &reg, &reg);
#endif
}

tab    : |---------------|
tab[0] : |---|
tab[1] :     |---|
tab[2] :         |---|
tab[3] :             |---|

#include <stdio.h>

static void afficher (int const t[], size_t n)
{
   size_t i;
   for (i = 0; i <= n; i++)
   {
      printf ("%4d", t[i]);
   }
   printf ("\n");
}


int main (void)
{
   int tab[] = {1, 2, 3, 4};

   afficher (tab, sizeof tab / sizeof *tab);
   return 0;
}

1   2   3   4   2

Press ENTER to continue.

assert (i < n);

#include <stdio.h>
#include <assert.h>

static void afficher (int const t[], size_t n)
{
   size_t i;
   for (i = 0; i <= n; i++)
   {
      /* ajout du piege */
      assert (i < n);
      printf ("%4d", t[i]);
   }
   printf ("\n");
}

int main (void)
{
   int tab[] = {1, 2, 3, 4};

   afficher (tab, sizeof tab / sizeof *tab);
   return 0;
}

1   2   3   4Assertion failed: i < n, file main.c, line 10

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

Press ENTER to continue.

#include <stdio.h>
#include <assert.h>

static void afficher (int const t[], size_t n)
{
   size_t i;
   /* correction */
   for (i = 0; i < n; i++)
   {
      /* ajout du piege */
      assert (i < n);
      printf ("%4d", t[i]);
   }
   printf ("\n");
}

int main (void)
{
   int tab[] = {1, 2, 3, 4};

   afficher (tab, sizeof tab / sizeof *tab);
   return 0;
}
			

1   2   3   4

Press ENTER to continue.

#include <stdio.h>
#include <stdlib.h>

int main (void)
{
   int i;
   printf ("Les valeurs vont de 0 a %d\n", RAND_MAX);
   for (i = 0; i < 10; i++)
   {
      int val = rand ();
      printf ("%d ", val);
   }
   printf ("\n");
   return 0;
}

Les valeurs vont de 0 a 32767
41 18467 6334 26500 19169 15724 11478 29358 26962 24464

#include <stdio.h>
#include <stdlib.h>

int main (void)
{
   int i;

   srand(10); /* MODIF */

   printf ("Les valeurs vont de 0 a %d\n", RAND_MAX);
   for (i = 0; i < 10; i++)
   {
      int val = rand ();
      printf ("%d ", val);
   }
   printf ("\n");
   return 0;
}

Les valeurs vont de 0 a 32767
71 16899 3272 13694 13697 18296 6722 3012 11726 1899

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main (void)
{
   int i;

   srand((unsigned) time(NULL)); /* MODIF */

   printf ("Les valeurs vont de 0 a %d\n", RAND_MAX);
   for (i = 0; i < 10; i++)
   {
      int val = rand ();
      printf ("%d ", val);
   }
   printf ("\n");
   return 0;
}

25985 16903 23861 29724 17917 23752 17039 25712 20507 30816
26197 27421 5384 20976 236 16846 22741 32047 12417 24408
26433 14874 13653 16830 21990 4658 17461 17892 21603 7731

int f (char *s)
{
  ...
}

int f (char *s)
{
  ...
}

int main (void)
{
   int x = f("hello");
}

/* f.h */
int f (char *s);

/* f.c */
#include "f.h"
int f (char *s)
{
  ...
}

/* main.c */
#include "f.h"

int main (void)
{
   int x = f("hello");
}

#ifndef H_F
#define H_F
/* f.h */

int f (char *s);

#endif

DO
   temperature := read_temperature()
   IF temperature > threshold
      alarm (ON)
   ENDIF
FOREVER

{
   for (;;)
   {
      int temperature = read_temperature();
      if (temperature > threshold)
      {
         alarm (ON);
      }
   }
}

{
   int x = 123;
   f (x);
}

void f (int a)
{
   a++;
}

{
   int x = 123;
   int *p = &x;
   (*p)++;
}

{
   int x = 123;
   f (&x);
}

void f (int *p)
{
   (*p)++;
}

"hello"

char s[] = "hello";

static char const identificateur_connu_seulement_du_compilateur[] = {'h','e','l','l','o',0};

f ("hello");

void f (char const *s);

char const *p = "hello";

   p = "bye";

#include <stdio.h>

struct data
{
   char nom[32];
   int age;
};

int main (void)
{
#define FNAME "data.txt"

   struct data data = { "Emmanuel", 50 };

   FILE *fp = fopen (FNAME, "wb");
   if (fp != NULL)
   {
      fwrite (&data, sizeof data, 1, fp);

      fclose (fp), fp = NULL;
   }
   else
   {
      perror (FNAME);
   }
   return 0;
}

T *f();

#include <stdio.h>

int main (void)
{
   int i = 0;

   printf ("i = %d\n", i);
   return 0;
}

i = 0

int main (void)
{
   int i = 0;

   printf ("i = %d\n", i);
   return 0;
}

#include <stdio.h>

int main (void)
{
   int i;

   printf ("i = %d\n", i);
   return 0;
}

#include <stdio.h>

int main (void)
{
   int num = 12;
   char num_text[] = "";

   sprintf (num_text, "%d", num);
   printf ("Voici num_text : %s\n", num_text);
   return 0;
}

static int f(void)

static int x;

int counter(void)
{
   static int x;
   x++;
   return x;
}

int x = f();

int x;
   x = f();

int f(void);

int x;
   f(&x);

void f(int *);

int *px = f();

 int *f(void);

int *px;
   f(&px);

void f(int **);

     int x;
   f(x);

 int *px;
   f(px);

T* *pp = malloc (sizeof (T*) * N);

size_t i;
   for (i = 0; i < N; i++)
   {
      pp[i] = malloc (sizeof (T) * M);
   }

T **pp = malloc (sizeof *pp * N);

size_t i;
   for (i = 0; i < N; i++)
   {
      pp[i] = malloc (sizeof *pp[i] * M);
   }

size_t i;
   for (i = 0; i < N; i++)
   {
     free(pp[i]), pp[i] = NULL;
   }
   free(pp), pp = NULL;

int x = 3;
   int const y = 4;

   x = 5; /* acces en ecriture possible */
   y = 6; /* acces en ecriture interdit */

int const a = 7;
   const int b = 8;

int const c;

int a;
   int * const pa = &a;

   pa++; /* interdit */
   *pa = 123; /* OK */

int a = 123;
   int const * pa = &a;
   const int * pb = &a;