Introduction au langage C/Double pointeur de double 2

Début de la boite de navigation du chapitre

fin de la boite de navigation du chapitre

Introduction (deuxième partie)

• Un exemple complet à tester (sans sortie).
• Puis nous étudirons la fonction i_mR().

Le code

Exemple indépendant de la librairie

• Ce fichier est complet.
• Il crée une matrice et la détruit.
• Certains "include" et "define" sont inutiles pour le code présenté, mais indispensables si on décide de rajouter certaines fonctions de la librairie.

/* ------------------------------ */
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <ctype.h>
#include <time.h>
#include <math.h>
/* ------------------------------ */
#define C0 0
#define C1 1
#define C2 2
#define C3 3
#define C4 4

#define R0 0
#define R1 1
#define R2 2
#define R3 3
#define R4 4

#define RC0 0
#define RC1 1
#define RC2 2
#define RC3 3
#define RC4 4

#define OF 0

#define R_SIZE 0
#define C_SIZE 1
#define C_SIZE_A 2

#define ERROR_E +1.E-010

#define FIRST 1 
#define FILENAME 11

#ifndef PI 
#define PI 3.14159265359
#endif
/* ------------------------------ */
double **i_mR(
int r,
int c
)
{
double **A;
int ar;
int ac;
int i;

          if(r<R1||c<C1)
            {
            printf(" The size of the matrix must be positives integers.\n\n");
            printf(" double **i_mR(); \n\n");
            fflush(stdout);
            getchar();
            exit(EXIT_FAILURE);
            }

    ar = r + R1;
    ac = c + C1;

/* Dynamically allocate an array of "ar" rows
   and "ac" columns.                          */

         A = malloc(ar * sizeof(*A));
             if(!A)
            {
            printf(" I was unable to allocate the memory you requested.\n\n");
            printf(" double **i_mR(); \n\n");
            printf(" **A = malloc(ar * sizeof(*A));\n\n");
            fflush(stdout);
            getchar();
            exit(EXIT_FAILURE);
            }

      A[0] = malloc(ar * ac * sizeof(**A) );
             if(!A[0])
            {
            printf(" I was unable to allocate the memory you requested.\n\n");
            printf(" double **i_mR();\n\n");
            printf(" A[0] = malloc(ar * ac * sizeof(**A) );\n\n");
            free(A);
            fflush(stdout);
            getchar();
            exit(EXIT_FAILURE);
            }

	for(i=R1; i<ar; i++) A[i] = A[0]+i*ac;

/* Memorize the matrix size*/
    A[R_SIZE][OF] = ar;/* A[R_SIZE][OF] = A[0][0] */
    A[C_SIZE][OF] = ac;/* A[C_SIZE][OF] = A[1][0] */

/* I initialize the zero row and the zero column */
    for(r=R2; r<A[R_SIZE][OF]; r++) A[r][0] = 0.;
    for(c=C1; c<A[C_SIZE][OF]; c++) A[0][c] = 0.;

return(A);
}


/* ------------------------------ */
void f_mR(
double **A
)
{
  if(A)  free(A[0]);

  free(A);
}


/* ------------------------------ */
int main(void)
{
double **A = i_mR(3,5);

  free(A);

  printf("\n Press return to continue");

  getchar();

  return 0;
}

Étudions la fonction i_mR()

* Elle retourne un double pointeur de double (double **i_mR)
* Il entre le nombre de lignes (r) et le nombre de colonnes (c).

/* ------------------------------ */
double **i_mR(
int r,
int c
)
{
double **A;
int ar;
int ac;
int i;

          if(r<R1||c<C1)
            {
            printf(" Si le nombre de lignes ou de colonnes est inférieur à un tout s'arrête.\n\n");
            printf(" double **i_mR(); \n\n");
            fflush(stdout);   
            getchar();
            exit(EXIT_FAILURE);
            }

/* Je me réserve la colonne zéro et la ligne zéro,
   pour mémoriser la taille de la matrice,
   je rajoute donc une ligne et une colonne */

    ar = r + R1;
    ac = c + C1;


         A = malloc(ar * sizeof(*A));
             if(!A)
            {
            printf(" I was unable to allocate the memory you requested.\n\n");
            printf(" double **i_mR(); \n\n");
            printf(" **A = malloc(ar * sizeof(*A));\n\n");
            fflush(stdout);
            getchar();
            exit(EXIT_FAILURE);
            }

      A[0] = malloc(ar * ac * sizeof(**A) );
             if(!A[0])
            {
            printf(" I was unable to allocate the memory you requested.\n\n");
            printf(" double **i_mR();\n\n");
            printf(" A[0] = malloc(ar * ac * sizeof(**A) );\n\n");
            free(A);
            fflush(stdout);
            getchar();
            exit(EXIT_FAILURE);
            }

/* Ces deux commandes alloue un block mémoire de double.

   Le premier malloc offre un block de (ar) éléments.
   A pointe sur le premier de ces éléments.
   Cela correspond a un espace pour un tableau A[ar]. (ar nombres de lignes, ac nombre de colonne)

   Le deuxième malloc offre un block de (ar*ac) élément pour les éléments du tableau. 
   A[0] le premier élément du tableau pointe aussi sur A.

   A[0] pointe sur A.
   A[1] pointe sur la deuxième ligne.
   A[2] pointe sur la troisième ligne.
   ...

   C'est ce que fait la boucle for ci-dessous.
   On incrémente chaque A[i] de (i*colonnes) à partir de l'adresse de départ.
*/
	for(i=R1; i<ar; i++) A[i] = A[0]+i*ac;


/* Pour un tableau de 6 colonnes et 4 lignes. 

     A
     ******************
     A[0] 

     A
     123456 123456 123456 123456 123456
     A[0]   A[1]   A[2]   A[3]     
*/ 



/* On copie la taille de la matrice dans la matrice. */
    A[R_SIZE][OF] = ar;/* A[0][0] */
    A[C_SIZE][OF] = ac;/* A[1][0] */

/* On met zéro dans la ligne zéro et dans la colonne zéro. */
    for(r=R2; r<A[R_SIZE][OF]; r++) A[r][0] = 0.;
    for(c=C1; c<A[C_SIZE][OF]; c++) A[0][c] = 0.;

return(A);
}

Important :
.
* Vous n’est pas obliger de comprendre ce code pour utiliser les matrices.
* Dans la librairie je mets à zéro tous les éléments de la matrice avec la fonction m_0_mR(A);