Leçons de niveau 14

C pointeurs/Double pointeur de double

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Double pointeur de double
Icône de la faculté
Chapitre no 5
Leçon : C pointeurs
Chap. préc. :Tableau de pointeurs de fonctions 2
Chap. suiv. :Double pointeur de double 2
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « C pointeurs : Double pointeur de double
C pointeurs/Double pointeur de double
 », n'a pu être restituée correctement ci-dessus.


Introduction[modifier | modifier le wikicode]

Présentation[modifier | modifier le wikicode]

Double pointeur de double.

  • Pour nous ce sera un travail sur les matrices.

Ce cours en deux parties va vous présenter la création et la destruction de matrices de la librairie "Mathc".

Le but[modifier | modifier le wikicode]

Cela vous permettra :


  • Soit de construire votre propre méthode de création de matrices.
  • Soit de construire votre propre librairie à partir de ces deux méthodes.
  • Soit de commencer votre apprentissage de la méthode "mathc".


Exemple d'utilisation de la librairie[modifier | modifier le wikicode]

Copie d'un tableau dans une matrice[modifier | modifier le wikicode]

  • Pour récupérer la librairied'algèbre linéaire (n_1aa.zip).
  • Indispensable pour tester les exemples de cette page.
  • Le deuxième fichier n_1ab.zip sera pour l'étude des tableaux de matrices.
/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
int main(void)
{
double a[R2*C3]={ 1,2,3,
                  4,5,6};

double **A = i_mR(R2,C3);

  c_a_A_mR(a,A);

  printf(" a[r*c] -> A : \n\n");
  p_mR(A,0,0,C6);

  f_mR(A);
  getchar();

  return 0;
}


Présentation des fonctions :

double**A=i_mR(R2,C3); Initialiser une matrice réelle
  • Deux lignes (rows)
  • Trois colonnes (columns)
c_a_A_mR(a,A); Copier le tableau "a" dans la matrice "A"
p_mR(A,T,V,C); Imprimer la matrice "A"
  • T espaces entre les nombres
  • V chiffres après la virgule.
  • C colonnes par lignes.
f_mR(A); Libérer l'espace alloué à la matrice "A"


Additionner deux matrices[modifier | modifier le wikicode]

/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
int main(void)
{
time_t t;

  srand(time(&t));

int r = rp_I(5);
int c = rp_I(5);

double **A = r_mR(i_mR(r,c),9);
double **B = r_mR(i_mR(r,c),9);
double **AplsB = i_mR(r,c);


  printf(" A : ");
  p_mR(A,3,0,C6);

  printf(" B : ");
  p_mR(B,3,0,C6);

  printf(" AplsB : ");
  p_mR(add_mR(A,B,AplsB),3,0,C6);

  f_mR(A);
  f_mR(B);
  f_mR(AplsB);

  getchar();

  return 0;
}

Résultat :

A : 
 +8  +6  -5  +4 
 +2  +2  -5  -1 
 -9  +2  +8  -7 
 +4  +4  -7  -9 
 -7  +2  +6  +2 
.
B : 
 +4  +8  -5  +8 
 +8  -7  +2  +4 
 +4  +6  -9  -1 
 +2  +2  +4  -3 
 -3  -9  -1  -9 
.
AplsB : 
+12 +14 -10 +12 
+10  -5  -3  +3 
 -5  +8  -1  -8 
 +6  +6  -3 -12 
-10  -7  +5  -7 


Mutiplier deux matrices[modifier | modifier le wikicode]

/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
int main(void)
{
time_t t;

  srand(time(&t));

int a = rp_I(5);
int b = rp_I(5);
int c = rp_I(5);

double **A = r_mR(i_mR(a,c),9);
double **B = r_mR(i_mR(c,b),9);
double **AB = i_mR(a,b);

  printf(" A : ");
  p_mR(A,3,0,C6);

  printf(" B : ");
  p_mR(B,3,0,C6);

  printf(" AB : ");
  p_mR(mul_mR(A,B,AB),3,0,C6);

  f_mR(A);
  f_mR(B);
  f_mR(AB);

  getchar();

  return 0;
}


Résultat :


A : 
-7  -1  -1 
-3  +2  -1 
+8  -3  -5 
-9  -5  -3 
+2  +6  -3 
.
B : 
-3  +8  -5  -3 
+2  +8  +4  -9 
+6  +8  -7  +8 
.
AB : 
+13 -72 +38 +22 
 +7 -16 +30 -17 
-60  +0 -17 -37 
 -1 -136 +46 +48 
-12 +40 +35 -84 


Inverser une matrice[modifier | modifier le wikicode]

/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
int main(void)
{
time_t t;

  srand(time(&t));

int r = rp_I(5)+1;

double **A = r_mR(i_mR(r,r),9);
double **invA = r_mR(i_mR(r,r),9);
double **AinvA = i_mR(r,r);

  printf(" A : ");
  p_mR(A,3,0,C6);

  printf(" invA : ");
  p_mR(inv_mR(A,invA),6,3,C6);

  printf(" A *& invA : ");
  p_mR(mul_mR(A,invA,AinvA),6,3,C6);

  f_mR(A);
  f_mR(invA);
  f_mR(AinvA);

  getchar();

  return 0;
}


Résultat :

A
-1  +2  +2  -3  -5  +6 
-1  -5  -9  -3  +2  -3 
-5  -7  +4  -3  -3  -7 
+4  +8  +6  -3  -7  +6 
-3  +2  +6  -1  -3  +6 
-5  -1  -5  +4  -3  -7 
.
invA : 
+0.382 -0.241 +0.023 -0.125 -0.448 -0.082 
-0.598 +0.310 -0.063 +0.305 +0.470 +0.083 
-0.055 -0.057 +0.046 +0.006 +0.031 -0.037 
+0.441 -0.339 -0.029 -0.254 -0.363 +0.023 
-0.448 +0.213 -0.041 +0.117 +0.354 -0.031 
+0.296 -0.116 -0.039 -0.154 -0.129 -0.043 
.
A *& invA : 
+1.000 -0.000 +0.000 -0.000 -0.000 -0.000 
+0.000 +1.000 -0.000 +0.000 +0.000 +0.000 
-0.000 +0.000 +1.000 +0.000 +0.000 -0.000 
+0.000 -0.000 +0.000 +1.000 -0.000 -0.000 
+0.000 -0.000 +0.000 +0.000 +1.000 -0.000 
-0.000 +0.000 -0.000 +0.000 +0.000 +1.000 


Remarque :


  • r_ pour rand.
  • p_ pour print.
  • i_ pour initialize.
  • f_ pour free.
  • mR pour Real matrix


La fonction f_mR();[modifier | modifier le wikicode]

  • Nous allons commencer par cette fonction.
  • Elle libère l'espace alloué à la matrice par la fonction i_mR();


Code source[modifier | modifier le wikicode]

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

  free(A);
}


  • Nous travaillons avec des double pointeurs (**A).
  • Il y a deux pointeurs dans la fonction. (A,A[0])
  • C'est un bon début.
  • On commence par vérifier que "A" n’est pas NULL.
  • Si tout va bien on libère "A[0]" le deuxième pointeur.
  • Puis on libère A.
  • Si "A" n'existe pas, on saute "A[0]", mais on libère "A".
  • Peut-être aurait-il mieux valu écrire


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


  • Ces vidéos terminent notre premier pas sur les double pointeurs.