Langage C

Cours

Le cours au format PDF est disponible ici.

Exemples

Code Listing 1: hello1.c

#include <stdio.h>

int main()
{
   printf("message change\n toto\n\n titi\n");
   return(0);
}

Code Listing 2: hello2.c

#include <stdio.h>

int main()
{
   printf("ligne1 ligne2\n");
    printf("lige1 ligne2\n");
   printf("lig1 ligne2\n");
   printf("ligne1\tligne2\n");
    printf("lige1\tligne2\n");
   printf("lig1\tligne2\n");
   printf("ligne2\n");
   printf("ligne3\r");
   printf("4\n");
   printf("ligne5\n");
   printf("ligne6\n");
   return(0);
}

Code Listing 3: hello3.c

#include <stdio.h>

int main()
{
   printf("%d\n", 1);
   printf("%f\n",0.10);
   printf("%e\n",0.10);
   printf("%E\n",0.10);
   printf("%g\n",0.10);
   printf("%f\n",0.0000010);
   printf("%e\n",0.0000010);
   printf("%g\n",0.0000010);
   printf("%G\n",0.0000010);

   printf("|12345| |12345| |12345|\n");
   printf("|%5d| |%-5d| |%d|\n",1,1,1);
   printf("|%5d| |%-5d| |%d|\n",10,10,10);
   printf("|%5d| |%-5d| |% d|\n",-10,-10,-10);
   printf("|%+5d| |%-5d| |%+d|\n",10,10,10);
   printf("|%5d| |%-5d| |%d|\n",1000,1000,1000);
   printf("|%5d| |%-5d| |%d|\n",1000000,1000000,1000000);

   printf("%10.4f\n",123.456789);

   printf("|%s|\n","toto");
   printf("|%10s|\n","toto");
   printf("|%-10s|\n","toto");
   return(0);
}

Code Listing 4: test1.c

#include <stdio.h>

int main()
{
   int x, y;
   x = 7;
   y = 5;
   printf("x = %d et y = %d\n",x,y);
   printf("x / y = %d\n", x /y);
   printf("(float) x/y = %d\n", (float)x/y);
   return(0);
}

Code Listing 5: test2.c

#include <stdio.h>

int main()
{
   printf("Taille d'un int :\t%d\n", sizeof(int));
   printf("Taille d'un char :\t%d\n", sizeof(char));
   printf("Taille d'un float :\t%d\n", sizeof(float));
   printf("Taille d'un double :\t%d\n", sizeof(double));
   printf("Taille d'un short int :\t%d\n", sizeof(short int));
   printf("Taille d'un long int :\t%d\n", sizeof(long int));
   printf("Taille d'un long double :\t%d\n", sizeof(long double));
   return(0);
}

Code Listing 6: test3.c

#include <stdio.h>


int main()
{
    /* ne pas confondre adresse et contenu */
    int n;
    int m;
    n = 5;
    m = 2;
    printf(" n vaut %d, son adresse est %p\n", n, &n);
    printf(" m vaut %d, son adresse est %p\n", m, &m);
    n = 10;
    printf(" n vaut %d, son adresse est %p\n", n, &n);
   return(0);
}

Code Listing 7: test4.c

#include <stdio.h>


int main()
{
    /* ne pas confondre adresse et contenu */
    int n;
    int m;
    n = 5;
    m = 2;
    printf(" n vaut %d, son adresse est %p\n", n, &n);
    printf(" m vaut %d, son adresse est %p\n", m, &m);
    n = 10;
    printf(" n vaut %d, son adresse est %p\n", n, &n);
   return(0);
}

Code Listing 8: test6.c

#include <stdio.h>


int main()
{
    int entier;        /* variable entiere */
    int *pointeur1;     /* pointeur sur un entier */
    int *pointeur2;     
    int **pointeur3;     

    entier = 5 ;

    printf(" entier = %d, son adresse est %p\n", entier, &entier);

    pointeur1 = &entier; 
    pointeur2 = &entier; 
   pointeur3 = &pointeur1;

    printf(" pointeur1 = %p, son adresse est %p, il pointe sur %d\n",
             pointeur1, &pointeur1, *pointeur1);
    printf(" pointeur2 = %p, son adresse est %p, il pointe sur %d\n",
             pointeur2, &pointeur2, *pointeur2);
    printf(" pointeur3 = %p, son adresse est %p, il pointe sur %p",
             pointeur3, &pointeur3, *pointeur3);
   printf(" qui pointe vers %d\n", **pointeur3);

   return(0);
}

Code Listing 9: test5.c

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


int main()
{
    int entier;        /* variable entiere */
    int *pointeur1  = NULL;     /* pointeur sur un entier */
    int *pointeur2  = NULL;     
    int **pointeur3 = NULL;     

    entier = 5 ;

    printf(" entier = %d, son adresse est %p\n", entier, &entier);
    printf(" pointeur1 = %p, son adresse est %p\n",
             pointeur1, &pointeur1);

    pointeur1 = &entier; 
    pointeur2 = &entier; 
   pointeur3 = &pointeur1;

    printf(" pointeur1 = %p, son adresse est %p, il pointe sur %d\n",
             pointeur1, &pointeur1, *pointeur1);
    printf(" pointeur2 = %p, son adresse est %p, il pointe sur %d\n",
             pointeur2, &pointeur2, *pointeur2);
    printf(" pointeur3 = %p, son adresse est %p, il pointe sur %p",
             pointeur3, &pointeur3, *pointeur3);
   printf(" qui pointe vers %d\n", **pointeur3);

   return(0);
}

Code Listing 10: test7.c

#include <stdio.h>

void fonction(int *var)
{
   printf("Fonction, avant modification, var = %d\n", *var);
   *var = 3;
   printf("Fonction, apres modification, var = %d\n", *var);
}

int main()
{
   int b;
   printf("Rentrez une valeur pour b: ");
   scanf("%d", &b);

   printf("Main, avant appel a fonction, b = %d\n", b);
   fonction(&b);
   printf("Main, apres appel a fonction, b = %d\n", b);
   return(0);
}

Code Listing 11: test8.c

#include <stdio.h>

int main()
{
   int v = -2345;
   int f = 0;
   printf("vrai ou faux : v || f : %d\n", v || f);
   printf("vrai et faux : v && f : %d\n", v && f);
   printf("non vrai     :   !v   : %d\n", !v);
   printf("non faux     :   !f   : %d\n", !f);
   return(0);
}

Code Listing 12: test9.c

#include <stdio.h>

int main()
{
   int x, y;
   double z;
   x = 7;
   y = 25;
   z = 24.46;
   printf(" x = %d, y = %d, z = %f\n",x, y, z);
   printf(" x >= y : %d\n", x >= y);
   printf(" x == y : %d\n", x == y);
   printf(" x <  z : %d\n", x <  z);
   printf(" y >  z : %d\n", y >  z);
   printf(" x != y - 18 : %d\n", x != (y - 18));
   printf(" x + y != z : %d\n", x + y != z);
   return(0);
}

Code Listing 13: test11.c

#include <stdio.h>

float valeur_absolue(float x) {
    float f_abs;

    if (x >= 0) {
        f_abs = x;
    }
    else {
        f_abs = -x;
        if (...) {
            ...
        }
        else {
            ...
        }
        y = sqrt(-x);
    }
    return(f_abs);
}

int main() {
   float x;

   printf("Valeur pour x: ");
   scanf("%f", &x);

   printf("la valeur absolue de %f est %f\n", x, valeur_absolue(x));
   return(0);
}

Code Listing 14: test10.c

#include <stdio.h>
#include <math.h>

int
main ()
{
  float x;

  printf ("Valeur pour x: ");
  scanf ("%f", &x);
  if (x >= 0)
    {
      printf ("la racine carree de %f est %f\n", x, sqrt (x));
    }
  else
    {
      printf ("votre nombre est negatif\n");
    }
  return (0);
}

Code Listing 15: ex1.c

#include <stdio.h>

void conversion(double * temp)
{
   /* cette fonction convertit les degrees Fahrenheit 
         en degrees Celsius 
      entree: temp: degree Fahrenheit (pointeur)
      sortie: temp: degree Celsius    (pointeur)
    */
   *temp = (*temp-32.0)*5.0/9.0;
}

int main()
{
   double temperature = 0.0;

   printf("Rentrer la temperature en degree Fahrenheit:");
   scanf("%f", &temperature);
   conversion(&temperature);
   printf("Temperature en degree Celsius = %f\n", temperature);

   return(0);
}

Code Listing 16: ex1bis.c

#include <stdio.h>

double conversion(double fahrenheit)
{
   double celsius;
   celsius = (fahrenheit-32.0)*5.0/9.0;
   return(celsius);
}

int main()
{
   double deg_fahrenheit = 0.0;
   double deg_celsius = 0.0;
   float temp;

   printf("Rentrer la temperature en degree Fahrenheit:");
   scanf("%f", &temp);
   deg_fahrenheit = (double) temp;
   deg_celsius = conversion(deg_fahrenheit);
   printf("Temperature en degree Celsius = %f\n", deg_celsius);

   return(0);
}

Code Listing 17: ex2bis.c

#include <stdio.h>
#include <math.h>

double volume() {
   double zero   = 0.0e0;
   double quatre = 4.0e0;
   double trois  = 3.0e0;
   double un     = 1.0e0;
   double r = zero;
   double v      = zero;
   double pi     = zero;
   float tmp;

   printf("calcul v from r\n");
   printf("r = ?");

   scanf("%f", &tmp);
   r = (double) tmp;

   pi = quatre*atan(un);
   printf(" pi = %30.20f\n", pi);
   v = quatre/trois*pi*r*r*r;
   /* v  = quatre/trois*pi*power(r,trois); */
   return (v);
}

int main () {
   /* initialisation de la variable vr a l'execution */
   double vr = volume();
   printf("\n");
   printf(" v = %f\n", vr);
   return(0);
}

Code Listing 18: ex2.c

#include <stdio.h>
#include <math.h>

double volume(double r) {
   /* fonction qui prend un rayon 
      et qui calcule le volume d'une sphere */
   double zero   = 0.0e0;
   double quatre = 4.0e0;
   double trois  = 3.0e0;
   double un     = 1.0e0;
   double v      = zero;
   double pi     = zero;

   pi = quatre*atan(un);
   /* printf(" pi = %30.20f\n", pi); */
   v = quatre/trois*pi*r*r*r;
   /* autre possibilite:
   v  = quatre/trois*pi*power(r,trois); 
      A eviter car power prend deux arguments double 
      et est beaucoup plus lent */
   return (v);
}

int main () {
   double zero   = 0.0e0;
   double r = zero;
   float tmp;
   printf("calcul v from r\n");
   printf("r = ");
   scanf("%f", &tmp);
   r = (double) tmp;
   printf("\n");
   printf(" v = %f\n", volume(r));
   return(0);
}

Code Listing 19: switch.c

#include <stdio.h>

int main()
{
   int jour;

   printf("jour (entre 1 et 7):");
   scanf("%d", &jour);
   switch (jour)
   {
      case 7:
         printf("%d : dimanche\n",jour);
         break;
      case 6:
         printf("%d : samedi\n",jour);
         break;
      case 5:
         printf("%d : vendredi\n",jour);
         break;
      case 4:
         printf("%d : jeudi\n",jour);
         break;
      case 3:
         printf("%d : mercredi\n",jour);
         break;
      case 2:
         printf("%d : mardi\n",jour);
         break;
      case 1:
         printf("%d : lundi\n",jour);
         break;
      default:
         printf("default: rentre un nombre entre 1 et 7 !!!!\n");  
   }
   return(0);
}

Code Listing 20: switch2.c

#include <stdio.h>

int main() {
   int n;

   printf("n:");scanf("%d", &n);
   switch (n%10) {
      case 1 :
         ;
      case 3 :
         ;
      case 5 :
         ;
      case 7 :
         ;
      case 9 :
         printf("%d est impair\n",n);
         break;
      case 0 :
      case 2 :
      case 4 :
      case 6 :
      case 8 :
         printf("%d est pair\n",n);
         break;
      default :
         printf("Erreur de switch: vous ne devriez pas etre la !!!\n");
   }
   return(0);
}

Code Listing 21: while1.c

#include <stdio.h>

int main()
{
   int n;
   printf("Compte a rebours\n");
   printf(" n: ");
   scanf("%d", &n); /* initialisation */

   while (n >=0)
   {                       /* corps de la boucle */
      printf("%d\n", n);
      n = n-1;             /* decrementation qui permet a la condition
                              du while de devenir "Faux" un jour */
   }
   printf("Partez ! (%d)\n",n);  /* terminaison */

   return(0);
}

Code Listing 22: while2.c

#include <stdio.h>

int main()
{
   int n;
   printf("Compte a rebours\n");
   printf(" n: ");
   scanf("%d", &n); /* initialisation */

   while (1)
   {                       /* corps de la boucle */
      printf("%d\n", n);
      if (n <= 0)
      {
         break;
      }
      printf("je decremente n\n");
      n = n-1;             /* decrementation qui permet a la condition
                              du while de devenir "Faux" un jour */
   }
   printf("Partez ! (%d)\n",n);  /* terminaison */

   return(0);
}

Code Listing 23: while3.c

#include <stdio.h>

int main() {

   int n;
   printf("Compte a rebours\n");
   printf(" n: ");
   scanf("%d", &n); /* initialisation */

   while (n >= 0) {
      if ( n%2 == 1) {
         n = n - 1;
         continue;
      }
        printf("%d\n", n);
        n = n - 1;
   }
   printf("Partez ! (%d)\n",n);  /* terminaison */

   return(0);
}

Code Listing 24: while4.c

#include <stdio.h>

int main()
{
   int n;
   printf("Compte a rebours\n");
   printf(" n: ");
   scanf("%d", &n); /* initialisation */

   do
   {                       /* corps de la boucle */
      printf("%d\n", n);
      n = n-1;             /* decrementation qui permet a la condition
                              du while de devenir "Faux" un jour */
   }
   while (n >=0) ;
   printf("Partez ! (%d)\n",n);  /* terminaison */

   return(0);
}

Code Listing 25: for1.c

#include <stdio.h>

int main()
{
   int n;

   for (n = 10; n <= 0; n = n-1)
   {
      printf("n vaut: %d\n", n);
   }
   return(0);
}

Code Listing 26: for2.c

/* rechercher les multiples de 7 entre 0 a 100 */

#include <stdio.h>

int main()
{
   int n;

   for (n = 0; n <= 100; n++)
   {
      if (n%7 == 0)
      {
         printf("%3d ", n);
      }
   }
   printf("\n");
   printf("fin de boucle, n vaut %d\n",n);
   return(0);
}

Code Listing 27: for3.c

#include <stdio.h>

int main()
{
   int i;
   int j;

   for (i = 8, j = 0; i >= 0; i--, j++)
   {
      printf(" %d = %d + %d\n", i+j, i, j);
   }

   return(0);
}

Code Listing 28: for4.c

#include <stdio.h>


int main()
{
   int n = 0;

   for ( ; ; ) 
   {
      n =  n + 1;     
      printf("toto\n");
      if (n > 10) break;
   }
   return(0);
}

Code Listing 29: for5.c

#include <stdio.h>

int main()
{
   int i, j ;

   for (i = 0; i < 4; i++)
   {
      printf("boucle externe: debut: i = %d\n", i);
      for (j = 0; j < 4; j++)
      {
         printf("boucle interne: i = %d, j = %d\n", i, j);
      }
      printf("boucle externe: fin: i = %d\n", i);
   }
   return(0);
}

Code Listing 30: bissectile.c

#include <stdio.h>

int bissectile(int annee)
{
   if (annee%4 == 0) {
      if (annee % 100 == 0) {
         if (annee % 400 == 0) {
            return(1);
         }
         else {
            return(0);
         }
      }
      else {
         return(1);
      }
   }
   else {
      return(0);
   }
   /*
   if (((annee % 4 == 0) && ! (annee % 100 == 0) ) ||
       (annee % 400 == 0) )
      return (1);
   else
      return(0);
   */
}

int main()
{
   int annee = 0, reponse = 0;

   printf("Entrez l'annee que vous voulez tester: \n");
   scanf("%d", &annee);
   reponse = bissectile(annee);
   if (reponse != 0)
   {
      printf("oui\n");
   }
   else
   {
      printf("non\n");
   }
   return(0);
}

Code Listing 31: premier.c

#include <stdio.h>

int premier(int i)
{
   int j = 0;
   int prem = 1;  /* i est premier */

   /*
   for (j = 2; j < i; j++)
   {
      ** autre version possible (mais moins belle !)
      prem = ((prem) && (i%j !=0));
      if (! prem)
      {break;}
      **
      if (i%j==0) {prem = 0; break;}
   }
   */
   /* autre version possible (encore !) */

   j = 2;                          /* initialisation */
   while ((i%j != 0) && (j < i))   /* boucle */
   {
      j = j + 1;
   }
   if (i==j)                       /* terminaison */
   { prem = 1;}
   else
   { prem = 0;}

   return(prem);
}

int main()
{
   int n = 0;
   int i = 0;

   printf("Nombres premiers\n");
   printf("n = ");
   scanf("%d", &n);

   for (i = 2; i <= n; i++)
   {
      if (premier(i))
      {
         printf("%d\n", i);
      }
   }
   return(0);
}

Code Listing 32: tab1.c

#include <stdio.h>

int main()
{
   int tab[100];

   printf("taille du tableau: \t%d\n", sizeof(tab));
   printf("taille d'un element du tableau: %d\n", sizeof(int));
   printf("nombre d'element du tableau:\t %d\n", sizeof(tab)/sizeof(int));
   return(0);
}

Code Listing 33: tab3.c

#include <stdio.h>

int main()
{
   int i;
   char chaine[]="Une tres longue chaine de caractere\navec un retour chariot";

   printf("taille de la chaine \"%s\": %d\n", chaine, sizeof(chaine));
   for (i = 0; i < sizeof(chaine); i++)
   {
      printf(" caractere %d de \"%s\" est: '%c' %d\n", 
             i, chaine, chaine[i], chaine[i]);
   }
   return(0);
}

Code Listing 34: tab5.c

#include <stdio.h>

int main()
{
   double list_double[10] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};

   printf("list_double = %p\n", list_double);
   printf("&list_double[0] = %p\n", &list_double[0]);
   printf("&list_double[9] = %p\n", &list_double[9]);
   printf("sizeof(list_double) = %d\n", sizeof(list_double));
   printf("&list_double[9]-&list_double[0] = %d\n", &list_double[9]-&list_double[0]);
   printf("&list_double[0]+1 = %p\n", &list_double[0]+1);
   return(0);
}

Code Listing 35: malloc1.c

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

int main()
{
   int n;
   int *tableau;

   printf("Taille du tableau: ");
   scanf("%d", &n);

   tableau = (int *) malloc(n*sizeof(int));

   if (tableau == NULL)
   {
      printf("Probleme allocation memoire\n");
      exit(1);
   }
   else
   {
      printf("adresse de tableau: %p\n", tableau);
      printf("taille de tableau:  %d\n", sizeof(tableau));
   }
   return(0);
}

Code Listing 36: tab2.c

#include <stdio.h>

int main()
{
   int tab[100];

   printf("taille du tableau: \t%d\n", sizeof(tab));
   printf("taille d'un element du tableau: %d\n", sizeof(int));
   printf("nombre d'element du tableau:\t %d\n", sizeof(tab)/sizeof(int));
   return(0);
}

Code Listing 37: tab4.c

#include <stdio.h>

int main()
{
   int list_int[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   int *ptr;

   printf("list_int = %p\n", list_int);
   printf("&list_int[0] = %p\n", &list_int[0]);
   printf("&list_int[9] = %p\n", &list_int[9]);
   printf("sizeof(list_int) = %d\n", sizeof(list_int));
   printf("&list_int[9]-&list_int[0] = %d\n", &list_int[9]-&list_int[0]);

   /* les trois lignes suivantes sont equivalentes */
   printf("&list_int[2] = %p\n", &list_int[2]);
   printf("&list_int[0]+2 = %p\n", &list_int[0]+2);
   printf("list_int+2 = %p\n", list_int+2);

   /* autre notation possible (a eviter ???) */
   printf("&2[list_int] = %p\n", &2[list_int]);
   printf("2+list_int = %p\n", 2+list_int);

   /* difference entre un pointeur et un tableau */
   /* ptr = &list_int[0]; */
   ptr = list_int;
   printf("sizeof(ptr) = %d\n", sizeof(ptr));

   return(0);
}

Code Listing 38: malloc2.c

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

void initialise(int *tableau, int taille)
{
   int i;

   printf("dans initialise: %d\n", sizeof(tableau));
   for (i = 0; i < taille; i++)
   {
      tableau[i] = i*2-5;
      /* autre possibilite equivalente */
      *(tableau+i) = i*2-5;
   }
}

int main()
{
   int n;
   int *tableau;
   int i;

   printf("Taille du tableau: ");
   scanf("%d", &n);

   tableau = (int *) malloc(n*sizeof(int));

   if (tableau == NULL)
   {
      printf("Probleme allocation memoire\n");
      exit(1);
   }
   else
   {
      printf("adresse de tableau: %p\n", tableau);
      printf("taille de tableau:  %d\n", sizeof(tableau));
   }

   initialise(tableau, n);
   for (i = 0; i < n; i++)
      printf("tableau[%d] = %d\n", i, tableau[i]);
   return(0);
}

Code Listing 39: tablemul.c

#include <stdio.h>

void affiche_ligne_pleine(int n)
{
   int i;

   for (i = 1; i <= n; i++)
   {
      printf("+-----");
   }
   printf("+\n");
}

void affiche_ligne_vide(int n)
{
   int i;

   for (i = 1; i <= n; i++)
   {
      printf("|     ");
   }
   printf("|\n");
}


int main()
{
   int n, i, j;

   scanf("%d", &n);

   for (i = 1; i <= n; i++)
   {
      affiche_ligne_pleine(n);
      affiche_ligne_vide(n);
      for (j = 1; j <= n; j++)
      {
         printf("| %3d ",i*j);
      }
      printf("|\n");
      affiche_ligne_vide(n);
   }
   affiche_ligne_pleine(n);

   return(0);
}

Code Listing 40: table_mul.c

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

void calcul(int x, int *tab)
{
   int i,j;

   for (i = 0; i <=x-1; i++)
   {
      for (j = 0; j <= x-1; j++)
      {
         tab[i*x+j] = (i+1)*(j+1);
      }
   }
}

void affiche(int x, int *table)
{
   int i,j;
   /* 1ere ligne */
   printf("     ");
   for (i=1; i <= x; i++)
   {
      if (i !=x)
         printf(" %3d ", i);
      else
         printf(" %3d \n", i);
   }

   for (i=1; i <= x; i++) /* i: numero de ligne */
   {
      printf(" %3d ", i);
      for (j=1; j <= x; j++) /* j: numero de colonne */
      {
         if (j != x)
           printf(" %3d ", table[(i-1)*x+(j-1)]);
         else
           printf(" %3d \n", table[(i-1)*x+(j-1)]);
      }
   }
}

int main()
{
  int n= 0;
  int *table=NULL;

  printf("Table des multiplications de n\n");
  printf(" n = ");
  scanf("%d",&n);
  table = (int *) malloc(n*n*sizeof(int));
  if (table == NULL)
  {
     printf("Pb memoire\n");
     exit(1);
  }
  calcul(n, table);
  affiche(n, table);
  free(table);
  return(0);
}

Code Listing 41: table_mul2.c

/* deuxieme version */
#include <stdio.h>
#include <stdlib.h>

int f(int n, int i, int j)
{
   return(i*n+j);
}

void calcul(int x, int *tab)
{
   int i,j;

   for (i = 0; i <=x-1; i++)
   {
      for (j = 0; j <= x-1; j++)
      {
         tab[f(x,i,j)] = (i+1)*(j+1);
      }
   }
}

void ligne_a(int x)
{
   int j;

   for (j=0; j <= x; j++) /* j: numero de colonne */
   {  
      printf("-----+");
   }
   printf("\n"); /* fin de la ligne de multiplication */
}

void ligne_b(int x)
{
   int j;

   for (j=0; j <= x; j++) /* j: numero de colonne */
   {  
      printf("     |");
   }
   printf("\n"); /* fin de la ligne de multiplication */
}

void affiche(int x, int *table)
{
   int i,j;
   /* 1ere ligne */
   ligne_b(x);
   printf("     |");
   for (j=1; j <= x; j++)
   {
      printf(" %3d |", j);
   }
   printf("\n");
   ligne_b(x);

   for (i=1; i <= x; i++) /* i: numero de ligne */
   {
      ligne_a(x);
      ligne_b(x);
      printf(" %3d |", i);
      for (j=1; j <= x; j++) /* j: numero de colonne */
      {  /* ligne c */
         printf(" %3d |", table[f(x,i-1, j-1)]);
      }
      printf("\n"); /* fin de la ligne de multiplication */
      ligne_b(x);
   }
}

int main()
{
  int n= 0;
  int *table=NULL;

  printf("Table des multiplications de n\n");
  printf(" n = ");
  scanf("%d",&n);
  table = (int *) malloc(n*n*sizeof(int));
  if (table == NULL)
  {
     printf("Pb memoire\n");
     exit(1);
  }
  calcul(n, table);
  affiche(n, table);
  printf("valeur du pointeur de table avant free: %p\n", table);
  free(table);  table = NULL; /* une (tres) bonne habitude: affecter NULL 
                                 a un pointeur apres un free */
  printf("valeur du pointeur de table apres free: %p\n", table);
  /* la suite "crashe" !
  calcul(n, table);
  affiche(n, table);
  printf("valeur du pointeur de table: %p\n", table);
   */
  return(0);
}

Code Listing 42: malloc3.c

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

int main()
{
   int mat[3][2];
   int **tab = NULL;
   int ligne = 0;
   int nligne = 0;
   int ncolonne = 0;

   printf("mat: %p\n", mat);
   printf("mat[0]: %p\n", mat[0]);
   printf("mat[1]: %p\n", mat[1]);
   printf("mat[2]: %p\n", mat[2]);

   nligne = 3;
   ncolonne = 40;
   tab = (int **)malloc(nligne*sizeof(int *));
   for (ligne = 0; ligne < nligne; ligne++)
   {
      tab[ligne] = (int *)malloc(ncolonne*sizeof(int));
   }
   tab[1][2] = 0;
   tab[1][3] = 4;

   /* on s'en va proprement */
   for (ligne = 0; ligne < nligne; ligne++)
   { 
      free(tab[ligne]); tab[ligne] = NULL;
   }
   free(tab); tab = NULL;
   return(0);
}

Code Listing 43: enum2.c

#include <stdio.h>

int main()
{
   enum jour_semaine {lundi, mardi, mercredi,
                      jeudi, vendredi, samedi, dimanche} jour1, jour2;

   printf("Rentrez un jour (entre 0 et 6): ");
   scanf("%d", &jour1);

   switch (jour1)
   {
      case lundi:
         printf("Eureka: c'est lundi !\n"); break;
      case mardi: 
         printf("Eureka: c'est mardi !\n"); break;
      case mercredi:
         printf("Eureka: c'est mercredi !\n"); break;
      case jeudi:
         printf("Eureka: c'est jeudi !\n"); break;
      case vendredi:
         printf("Eureka: c'est vendredi !\n"); break;
      default:
         printf("Vous bossez aujourd'hui ?\n");
   }
   return(0);
}

Code Listing 44: enum1.c

#include <stdio.h>

int main()
{
   enum jour_semaine {lundi, mardi, mercredi=10,
                      jeudi, vendredi, samedi=30, dimanche} jour1, jour2;
   jour1 = lundi;
   jour2 = vendredi;
   printf("lundi:    %d\n", lundi);
   printf("mardi:    %d\n", mardi);
   printf("mercredi: %d\n", mercredi);
   printf("jeudi:    %d\n", jeudi);
   printf("vendredi: %d\n", vendredi);
   printf("samedi:   %d\n", samedi);
   printf("dimanche: %d\n", dimanche);
   printf("\n");
   printf("jour1: %d\n", jour1);
   printf("jour2: %d\n", jour2);
   printf("nombre de jour entre jour1 et jour2: %d\n", jour2-jour1);
   return(0);
}

Code Listing 45: enum3.c

#include <stdio.h>

int main()
{
   enum jour_semaine {lundi, mardi, mercredi=10,
                      jeudi, vendredi, samedi=30, dimanche} jour1, jour2;
   enum mois {janvier, fevrier, mars, avril, mai , juin,
              juillet, aout, septembre, octobre, novembre, decembre} mois1, mois2;

   jour1 = lundi;
   jour2 = vendredi;
   mois1 = aout;
   mois2 = 14; /* ATTENTION: ce est "faux",
                  mais est compilable et executable en C */

   printf("lundi:    %d\n", lundi);
   printf("mardi:    %d\n", mardi);
   printf("mercredi: %d\n", mercredi);
   printf("jeudi:    %d\n", jeudi);
   printf("vendredi: %d\n", vendredi);
   printf("samedi:   %d\n", samedi);
   printf("dimanche: %d\n", dimanche);
   printf("\n");
   printf("jour1: %d\n", jour1);
   printf("jour2: %d\n", jour2);
   printf("nombre de jour entre jour1 et jour2: %d\n", jour2-jour1);
   printf("mois1: %d\n",mois1);
   printf("mois2: %d\n",mois2);
   return(0);
}

Code Listing 46: typedef.c

#include <stdio.h>

int main()
{
   typedef enum {lundi, mardi, mercredi,
                 jeudi, vendredi, samedi, dimanche} Jour, *PointeurJour;
   typedef enum {janvier, fevrier, mars, avril, mai , juin,
              juillet, aout, septembre, octobre, novembre, decembre} Mois;
   typedef int *PointeurEntier;

   Jour jour1, jour2;
   Mois mois1;

   PointeurEntier ptr_i;
   PointeurJour ptr_j;

   jour1 = lundi;
   jour2 = vendredi;
   ptr_j = &jour1;
   ptr_i = (PointeurEntier)&jour1;
   mois1 = aout;
   printf("lundi:    %d\n", lundi);
   printf("mardi:    %d\n", mardi);
   printf("mercredi: %d\n", mercredi);
   printf("jeudi:    %d\n", jeudi);
   printf("vendredi: %d\n", vendredi);
   printf("samedi:   %d\n", samedi);
   printf("dimanche: %d\n", dimanche);
   printf("\n");
   printf("jour1: %d\n", jour1);
   printf("jour2: %d\n", jour2);
   printf("nombre de jour entre jour1 et jour2: %d\n", jour2-jour1);
   printf("mois1: %d\n",mois1);
   printf("%p\n", ptr_i);
   printf("%p\n", ptr_j);
   return(0);
}

Code Listing 47: argc.c

#include <stdio.h>

int main(int argc, char *argv[])
{
   int i = 0;
   printf("Nombre d'arguments = %d\n", argc);
   printf("Nom de la fonction = %s\n", argv[0]);
   for (i = 1; i < argc; i++)
   {
      printf("argument %d : %s\n", i, argv[i]);
   }
   return(0);
}

Code Listing 48: table_mul3.c

/* troisime version */
#include <stdio.h>
#include <stdlib.h>

int f(int n, int i, int j)
{
   return(i*n+j);
}

void calcul(int x, int *tab)
{
   int i,j;

   for (i = 0; i <=x-1; i++)
   {
      for (j = 0; j <= x-1; j++)
      {
         tab[f(x,i,j)] = (i+1)*(j+1);
      }
   }
}

void ligne_a(int x)
{
   int j;

   for (j=0; j <= x; j++) /* j: numero de colonne */
   {  
      printf("-----+");
   }
   printf("\n"); /* fin de la ligne de multiplication */
}

void ligne_b(int x)
{
   int j;

   for (j=0; j <= x; j++) /* j: numero de colonne */
   {  
      printf("     |");
   }
   printf("\n"); /* fin de la ligne de multiplication */
}

void affiche(int x, int *table)
{
   int i,j;
   /* 1ere ligne */
   ligne_b(x);
   printf("     |");
   for (j=1; j <= x; j++)
   {
      printf(" %3d |", j);
   }
   printf("\n");
   ligne_b(x);

   for (i=1; i <= x; i++) /* i: numero de ligne */
   {
      ligne_a(x);
      ligne_b(x);
      printf(" %3d |", i);
      for (j=1; j <= x; j++) /* j: numero de colonne */
      {  /* ligne c */
         printf(" %3d |", table[f(x,i-1, j-1)]);
      }
      printf("\n"); /* fin de la ligne de multiplication */
      ligne_b(x);
   }
   ligne_a(x);
}

int main(int argc, char *argv[])
{
  int n= 0;
  int *table=NULL;

  /*
  printf(" n = ");
  scanf("%d",&n);
   */
  if (argc != 2)
  {
     printf("Nombre d'arguments incorrects\n");
     exit(1);
  }

  sscanf(argv[1],"%d", &n);

  printf("Table des multiplications de %d\n", n);
  table = (int *) malloc(n*n*sizeof(int));
  if (table == NULL)
  {
     printf("Pb memoire\n");
     exit(1);
  }
  calcul(n, table);
  affiche(n, table);
  free(table);  table = NULL; /* une (tres) bonne habitude: affecter NULL 
                                 a un pointeur apres un free */
  return(0);
}