1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
| #include <stdio.h>
#include <stdlib.h>
double** dmat_alloc( size_t nrow, size_t ncol );
void dmat_free( double** mat, size_t nrow, size_t ncol);
void dmat_print(double** mat, size_t nrow, size_t ncol);
double** dmat_alloc( size_t nrow, size_t ncol )
{
/* Ici on peut vérifier que les paramètres respectent
* certaines conditions comme étant strictement
* positifs et inférieurs à une valeur maximum
* Ce serait vraiment bien mais je ne le fais pas ...
*/
double** tmp;
size_t i;
/* allocation pour un tableau de nrow pointeurs
* un pointeur pour chaque ligne c'est pour cela
* qu'il y a nrow dans le malloc ...
* Je vérifie quand même le retour du malloc
* bien qu'avec Linux et son OOM killer, enfin
* passons ....
*/
tmp = malloc( nrow * sizeof(tmp[0]) );
if (tmp==NULL) {
fprintf(stderr, "Mémoire insuffisante");
exit(EXIT_FAILURE);
}
/* une boucle pour allouer chacun des nrow pointeurs
* pour chacune des nrow lignes (ça c'est le for)
* on alloue de la place pour ncol colonnes (d'où
* le ncol dans les malloc) car chaque ligne contient
* ncol cellules, une par colonne
*/
for(i=0; i<nrow; ++i) {
tmp[i] = malloc( ncol * sizeof(tmp[0][0]) );
if (tmp==NULL) {
fprintf(stderr, "Mémoire insuffisante");
exit(EXIT_FAILURE);
}
}
return tmp;
}
void dmat_free( double** mat, size_t nrow, size_t ncol)
{
/* Id., c'est une bonne chose que de vérifier que les
* paramètres passés sont corrects ...
* Ensuite pour chaque malloc lors de l'allocation,
* il faut faire un free ici et «dans le sens inverse»
*/
size_t i;
/* En dernier on a alloué les nrow lignes, on commence
* donc par les libérer
*/
for(i=0; i<nrow; ++i) {
free(mat[i]);
}
/* On vient de libérer chaque pointeur sur les lignes
* libérons maintenant ce qui a été alloué en premier
*/
free(mat);
/* Remarque : le paramètre ncol est totalement inutile
* ici, nous pourrions nous en passer
*/
}
void dmat_print(double** mat, size_t nrow, size_t ncol)
{
/* No comment, quick and dirty ... */
size_t col,row;
for(row=0;row<nrow;++row) {
for(col=0;col<ncol;++col) {
printf("%6.3lf ", mat[row][col]);
}
printf("\n");
}
}
#define H 20
#define W 10
int main()
{
double** p;
double** d;
size_t row,col;
/* On alloue nos deux matrices */
p=dmat_alloc(H, W);
d=dmat_alloc(H, W+1);
/* On les utilise .... */
/* On les initialise
* Là aussi on peut créer des fonctions
* dédiées
*/
for(row=0;row<H;++row)
for(col=0;col<W;++col)
p[row][col]=(double)row*(double)W+(double)col;
for(row=0;row<H;++row)
for(col=0;col<W+1;++col)
d[row][col]=1.0/(1+(double)row*(double)W+(double)col);
/* On les affiche */
printf("Matrice p :\n");
dmat_print(p,H,W);
printf("\n");
printf("Matrice d :\n");
dmat_print(d,H,W+1);
printf("\n");
/* On libère la mémoire allouée */
dmat_free(p, H, W);
dmat_free(d, H, W+1);
/* Et voilà :) */
return EXIT_SUCCESS;
} |
