Matrice,Tableau de chaine , fonctions

Version imprimable

20/04/2011, 21h10
tychus

Matrice,Tableau de chaine , fonctions

salut a tous
voila j'aimerais que quelqu'un me montre comment envoyerr une matrice,et un tableau de chaine a une fonction et comment les "return" ::)
20/04/2011, 22h46
Sve@r

Citation:

Envoyé par tychus

salut a tous
voila j'aimerais que quelqu'un me montre comment envoyerr une matrice,et un tableau de chaine a une fonction et comment les "return" ::)

Salut

Tu ne peux pas. Une fonction ne peut renvoyer que des types simples (char, int, short, long, float, double) ou des pointeurs (des adresses quoi).

Donc 2 solutions
1) ta fonction reçoit en paramètre l'adresse de la matrice (ou de la chaine). Ayant cette adresse elle peut aller y taper et la modifier. Quand ta fonction se termine, ta matrice (ou ta chaine) a été modifiée/remplie

2) ta fonction crée la matrice (ou la chaine) dans le tas par malloc. Et elle renvoie le pointeur alloué à la fonction appelante qui aura pour charge, une fois son travail terminé, de libérer la mémoire
21/04/2011, 16h07
diogene

Citation:

Envoyé par Sve@r

Salut

Tu ne peux pas. Une fonction ne peut renvoyer que des types simples (char, int, short, long, float, double) ou des pointeurs (des adresses quoi).
....

Pour compléter , elle peut renvoyer aussi des structures.

En fait,
- elle peut renvoyer des valeurs de tous les types, mais elle ne peux pas renvoyer des objets.
- elle ne peut donc pas renvoyer de tableaux (mais elle peut renvoyer l'adresse d'un élément d'un tableau notamment celle du premier)
- elle ne doit pas renvoyer l'adresse de variables locales à la fonction
21/04/2011, 21h38
tychus

ok merci :ccool::ccool: pour votre aide me reste juste a savoir comment utiliser un pointeur de type (**p) pour travailler sur un matrice
21/04/2011, 23h25
Sve@r

Citation:

Envoyé par tychus

ok merci :ccool::ccool: pour votre aide me reste juste a savoir comment utiliser un pointeur de type (**p) pour travailler sur un matrice

Si tu fais l'effort d'encapsuler ta matrice dans une structure, tu peux alors envoyer l'adresse de la structure à tes fonctions. Les fonctions recevant alors un simple (*p) et non un (**p)...

Il y a plusieurs implantations possibles en C pour les matrices. Une des implantations possibles est d'utiliser un tableau de tableaux de double, alloué sur le tas ou sur la pile.

Une implantation avec allocation dynamique sur le tas nous donnerais une définition de la variable que celle-là:

Code:

double **matrix = NULL;

La variable matrice n'est ici rien d'autre qu'un pointeur sur un pointeur vers double. Une autre implantation possible est d'utiliser une structure comme cette dernière (Edit: et comme proposé par Sve@r):

Code:

1
2
3
4
5
struct Matrix 
{
    double **_data;
    size_t dim[2];
};

L'utilisation d'une structure est probablement plus simple pour commencer. On va commencer par implanter pour l'exemple un fonction jouant le rôle de constructeur de la matrice et une autre jouant le rôle de destructeur. Il vient donc:

Code:

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
struct Matrix
{
    double **_data;
    size_t dim[2];
};
#define MATRIX_INIT {NULL, {0}}
 
struct Matrix *m_matrix_new(size_t nlines, size_t ncols)
{
    struct Matrix *self = NULL;
 
    if (nlines > 0 && ncols > 0)
    {
        /* Hop, on change les habitudes et on alloue tout en un bloc */
        self = malloc(sizeof *self + nlines * sizeof *self->_data +
                      nlines * ncols * sizeof **self->_data);
        if (self != NULL)
        {
            size_t i, j;
            static const struct Matrix tmp = MATRIX_INIT;
            /* Initialisation de tous les champs de la structure a une valeur
               nulle */
            *self = tmp;
 
            self->dim[0] = nlines;
            self->dim[1] = ncols;
 
            /* Mise en forme de l'objet pour que tout pointe ou il faut */
            self->_data = (double **) (self + 1);
            self->_data[0] = (double *) (self->_data + nlines);
 
 
            for (i = (size_t) 1; i < nlines; i++)
            {
                self->_data[i] = self->_data[0] + i * ncols;
 
            }
 
            /* Initialisation des elements de la matrice */
            for (i = (size_t) 0; i < nlines; i++)
            {
                for (j = (size_t) 0; j < ncols; j++)
                {
                    self->_data[i][j] = 0.0;
                }
            }
 
        }
    }
 
    return self;
}
 
void m_matrix_delete(struct Matrix *self)
{
    if (self != NULL)
    {
        free(self);
    }
}

La fonction matrix_new() est un exemple de fonction renvoyant l'adresse d'une matrice nouvellement créée. La fonction matrix_delete() est un exemple de fonction prenant l'adresse d'une matrice en paramètre.

Thierry

Salut,

Je me permets de rajouter un bout de code pour d'autres exemples si ça peut t'aider.

Code:

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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
#include<stdio.h>
#include<stdlib.h>
 
 
void   Allouer_Matrice               ( int ***Matrice, int Colonne, int Ligne                                                                  );
void   Sommer_Matrice                ( int **Matrice, int **Matrice_A, int **Matrice_B, int Ligne, int Colonne                                 );
void   Soustraire_Matrice            ( int **Matrice, int **Matrice_A, int **Matrice_B, int Ligne, int Colonne                                 );
void   Initialiser_Matrice           ( int **Matrice, int Ligne, int Colonne, int Valeur                                                       );
void   Remplir_Matrice_Aleatoirement ( int **Matrice, int Ligne, int Colonne, int OFFSET, int Valeur                                           );
void   Multiplier_Matrice            ( int **Matrice, int **Matrice_A, int **Matrice_B, int Ligne_A, int Colonne_A, int Ligne_B, int Colonne_B );
void   Multiplier_Matrice_Constante  ( int Constante, int **Matrice, int Ligne, int Colonne                                                    );
void   Afficher_Matrice              ( int **Matrice, int Ligne, int Colonne                                                                   );
void   Desallouer_Matrice            ( int **Matrice, int Colonne                                                                              );
int    Sont_Multipliables            ( int Colonne_A, int Ligne_B                                                                              );
 
int main (void)
{
    int **MatriceA=NULL;
    int **MatriceB=NULL;
    int **Matrice =NULL;
 
    Allouer_Matrice( &MatriceA, 7, 4 );
    Allouer_Matrice( &MatriceB, 4, 7 );
    Allouer_Matrice( &Matrice , 4, 4 );
 
    Remplir_Matrice_Aleatoirement( MatriceA, 7, 4, 5, 10 );
    Remplir_Matrice_Aleatoirement( MatriceB, 4, 7, 5, 10 );
 
    Initialiser_Matrice          ( Matrice , 4, 4, 0     );
 
    printf("\n\n///////////////////MATRICE A///////////////////\n");
    Afficher_Matrice( MatriceA, 4, 4 );
    printf("\n\n///////////////////MATRICE B///////////////////\n");
    Afficher_Matrice( MatriceB, 4, 4 );
 
    Sommer_Matrice( Matrice, MatriceA, MatriceB, 4, 4 );
    printf("\n\n/////////////////MATRICE SOMMEE////////////////\n");
    Afficher_Matrice( Matrice, 4, 4 );
 
    Soustraire_Matrice( Matrice, MatriceA, MatriceB, 4, 4 );
    printf("\n\n///////////////MATRICE SOUSTRAITE//////////////\n");
    Afficher_Matrice( Matrice, 4, 4 );
 
    Multiplier_Matrice( Matrice, MatriceA, MatriceB, 4, 4, 4, 4 );
    printf("\n\n///////////////MATRICE MULTIPLIEE//////////////\n");
    Afficher_Matrice( Matrice, 4, 4 );
 
    Multiplier_Matrice_Constante( 2, MatriceA, 4, 4 );
    printf("\n\n//////////MATRICE MULTIPLIEE CONSTANTE/////////\n");
    Afficher_Matrice( MatriceA, 4, 4 );
 
    Desallouer_Matrice( MatriceA, 4 );
    Desallouer_Matrice( MatriceB, 4 );
    Desallouer_Matrice( Matrice,  5 );
 
    getchar();
 
}
 
void Allouer_Matrice(int ***Matrice, int Ligne, int Colonne)
{
        if ( Matrice != NULL )
             {
                  int i=0;
 
                  // Allouer les colonnes
                  *Matrice = (int **)malloc( Ligne*sizeof(int*) );
 
                  // Allouer les lignes
                  for ( i=0 ; i<Ligne ; i++)
                      {
                         (*Matrice)[i]=(int *)malloc( Colonne*sizeof(int) );
                      }
             }
}
 
void Initialiser_Matrice(int **Matrice, int Ligne, int Colonne, int Valeur)
{
 
     if ( Matrice != NULL )
        {
             int i, j;
             for ( i=0 ; i<Ligne ; i++ )
                 {
                       for ( j=0 ; j<Colonne ; j++ )
                           {
                                Matrice[i][j]=Valeur;
                           }
                 }
        }
 
    else printf("\n\nERREUR DANS LA FONCTION Initialiser_Matrice\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEE\n\n");
}
 
void Remplir_Matrice_Aleatoirement(int **Matrice, int Ligne, int Colonne, int OFFSET, int Valeur)
{
     if ( Matrice != NULL )
        {
             int i, j;
             for ( i=0 ; i<Ligne ; i++ )
                 {
                       for ( j=0 ; j<Colonne ; j++ )
                           {
                                Matrice[i][j]=OFFSET + rand()%(Valeur+1);
                           }
                 }
        }
 
    else printf("\n\nERREUR DANS LA FONCTION Remplir_Matrice_Aleatoirement\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEE\n\n");
}
 
void Sommer_Matrice( int **Matrice, int **Matrice_A, int **Matrice_B, int Ligne, int Colonne)
{
     if ( Matrice !=NULL && Matrice_A != NULL && Matrice_B != NULL )
        {
             int i,j;
             for ( i=0 ; i<Ligne ; i++ )
                 {
                     for ( j=0 ; j<Colonne ; j++ )
                         {
                             Matrice[i][j]=Matrice_A[i][j]+Matrice_B[i][j];
                         }
                 }
        }
 
    else printf("\n\nERREUR DANS LA FONCTION Sommer_Matrice\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEE\n\n");
}
 
void Soustraire_Matrice( int **Matrice, int **Matrice_A, int **Matrice_B, int Ligne, int Colonne)
{
     if ( Matrice !=NULL && Matrice_A != NULL && Matrice_B != NULL )
        {
             int i,j;
             for ( i=0 ; i<Ligne ; i++ )
                 {
                     for ( j=0 ; j<Colonne ; j++ )
                         {
                             Matrice[i][j]=Matrice_A[i][j]-Matrice_B[i][j];
                         }
                 }
        }
 
     else printf("\n\nERREUR DANS LA FONCTION Soustraire_Matrice\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEE\n\n");
}
 
void Afficher_Matrice(int **Matrice, int Ligne, int Colonne)
{
    if ( Matrice != NULL )
       {
            int i, j;
            for ( i=0 ; i<Ligne ; i++ )
                {
                      for ( j=0 ; j<Colonne ; j++)
                          {
                                printf("\nMatrice[%d][%d]=%d", i+1, j+1, Matrice[i][j]);
                          }
                }
       }
 
    else printf("\n\nERREUR DANS LA FONCTION Afficher_Matrice\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEE\n\n");
}
 
 
void Desallouer_Matrice( int **Matrice, int Colonne )
{
    if ( Matrice != NULL )
       {
            int i;
            for ( i=1 ; i<Colonne ; i++ )
               {
                     free(Matrice[i]);
               }
 
            free(Matrice);
       }
 
    else printf("\n\nERREUR DANS LA FONCTION Desallouer_Matrice\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEEn\n");
}
 
int Sont_Multipliables( int Colonne_A, int Ligne_B )
{
    if ( Colonne_A == Ligne_B )
       {
                   return 1;
       }
 
    else return 0;
}
 
void Multiplier_Matrice( int **Matrice, int **Matrice_A, int **Matrice_B, int Ligne_A, int Colonne_A, int Ligne_B, int Colonne_B )
{
     if ( Matrice != NULL && Matrice_A != NULL && Matrice_B != NULL && Sont_Multipliables( Colonne_A, Ligne_B ) == 1 )
        {
            int i,j;
            int Repeter=0;
            for ( i=0 ; i<Ligne_A ; i++ )
             {
                 for ( j=0 ; j<Colonne_B ; j++ )
                     {
                         while ( Repeter != Colonne_A )
                               {
                                         Matrice[i][j]=Matrice[i][j]+ Matrice_A[i][Repeter]*Matrice_B[Repeter][j];
                                         Repeter++;
                               }
                         Repeter=0;
                     }
             }
         }
 
     else printf("\n\nERREUR DANS LA FONCTION Multiplier_Matrice\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEE\n   + LES DIMENSIONS DES MATRICES NE SONT PAS COMPATIBLES POUR LA MULTIPLICATION\n\n");
}
 
void Multiplier_Matrice_Constante( int Constante, int **Matrice, int Ligne, int Colonne )
{
       if ( Matrice != NULL )
          {
                    int i;
                    for ( i=0 ; i<Ligne ; i++ )
                        {
                              int j;
                              for ( j=0 ; j<Colonne ; j++ )
                                  {
                                        Matrice[i][j]=Constante*Matrice[i][j];
                                  }
                        }
          }
 
       else printf("\n\nERREUR DANS LA FONCTION Multiplier_Matrice_Constante\n   + VERIFIEZ QUE MATRICE EST CORRECTEMENT REFERENCEE\n\n");
}

Cdt.

Citation:
Envoyé par Thierry Chappuis
Code:

1 2 3 4 /* Hop, on change les habitudes et on alloue tout en un bloc */ self = malloc(sizeof *self + nlines * sizeof *self->_data + nlines * ncols * sizeof **self->_data);
Joli mais j'ai mis un peu de temps avant de piger. Et je doute que ce pauvre tychus qui (semble-t-il) débute comprenne qqchose à ça.:aie:

Accessoirement, cette allocation massive table sur le fait que
1) le membre data est collé en début de structure
2) le compilo ne rajoute pas du padding pour optimiser
Bref un peu danger danger non ????
Citation:
Envoyé par Thierry Chappuis
Code:

1 2 3 4 static const struct Matrix tmp = MATRIX_INIT; /* Initialisation de tous les champs de la structure a une valeur nulle */ *self = tmp;
Ouais, free style. Mais bon, le memset ne serait-il pas plus approprié ?

30/04/2011, 08h30
Thierry Chappuis

Citation:

Envoyé par Sve@r

Ouais, free style. Mais bon, le memset ne serait-il pas plus approprié ?

memset() initialise all-bytes-to-zero, ce qui est généralement moins portable que d'initialiser la structure comme je le fais ici. Dans la norme, rien n'oblige la valeur NULL ou un flottant comme 0.0 a être représenté avec tous les bytes à 0.

En ce concerne l'allocation de la mémoire pour la matrice en une fois, pour les matrices, je n'ai pas de bench pour savoir si une allocation ligne par ligne plus efficace. On retrouve tellement d'exemple de création de matrice sur ce forum et d'autre que je me suis permis une petit variation. C'est une variation qu'on retrouve dans certaines bibliothèques scientifiques.

Avec meilleures salutations

Thierry
30/04/2011, 10h56
diogene
N'y a t-il pas un risque à réaliser une allocation dynamique unique pour stocker des objets de types différents à cause des problèmes d'alignements ?
On voit la difficulté par la nécessité de cast sauvages.

Le malloc() renvoie une adresse assurant un alignement compatible avec tout type d'objet.
Mais que dire de

Code:

self->_data = (double **) (self + 1);

self+1 est un (struct Matrix *) et son cast en (double**) est-il possible ? Est-ce qu'il est garanti que l'alignement d'un (double*) est compatible avec celui d'une structure ?

Même chose ici entre un (double**) et un (double *) :

Code:

self->_data[0] = (double *) (self->_data + nlines);

Un (double) a t-il un alignement compatible avec celui d'un (double *) ?

Imaginons dans le même style d'allouer N char suivis de M double
Code:

1 2 3 4 5 struct t { char * car; double * db; };
on aurait
Code:

1 2 3 4 5 6 struct t *p = malloc(sizeof *p + N*sizeof *p->car +M*sizeof *p->db); if(p != NULL) { p->car = (char*)(p+1); p->db = (double*)(p->car + N); }
p->car, (struct t*) -> (char*), ne devrait pas poser de problème, par contre p->db avec le transtypage (char*) ->(double*) si. Selon la valeur de N, l'alignement des doubles peut être incorrect.
30/04/2011, 11h37
Thierry Chappuis

Non, le respect des contraintes d'alignement n'est pas garanti dans le code proposé. Pour une telle garantie, il faut des allocations séparées pour la strcture, le tableau de (double *) et le tableau de double. En pratique, le premier champ de la structure étant un pointeur, il est très probable que les contraintes d'alignement soient respectées pour le tableau de pointeurs sur double. Ceci ne vaut toutefois pas pour le tableau de double qui doit être alloué séparemment.

Thierry
30/04/2011, 11h47
diogene

@Sve@r

Citation:

Accessoirement, cette allocation massive table sur le fait que
1) le membre data est collé en début de structure

Ce qui est garanti par la norme

Citation:

2) le compilo ne rajoute pas du padding pour optimiser

Le padding dans la structure n'a pas d'importance dans le code de Thierry

Je reviens à quelque chose de plus traditionnel avec trois allocation qui garantit le respect des contraintes d'alignement.

Code:

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
struct Matrix
{
    double **_data;
    size_t dim[2];
};
#define MATRIX_INIT {NULL, {0}}
 
struct Matrix *m_matrix_new(size_t nlines, size_t ncols)
{
    struct Matrix *self = NULL;
 
    if (nlines > 0 && ncols > 0)
    {
        /* Hop, on change les habitudes et on alloue tout en un bloc */
        self = malloc(sizeof *self);
        if (self != NULL)
        {
            static const struct Matrix tmp = MATRIX_INIT;
            /* Initialisation de tous les champs de la structure a une valeur
               nulle */
            *self = tmp;
 
            self->dim[0] = nlines;
            self->dim[1] = ncols;
 
            self->_data = malloc(nlines * sizeof *self->_data);
            if (self->_data != NULL)
            {
                self->_data[0] = malloc(nlines * ncols * sizeof *self->_data[0]);
                if (self->_data[0] != NULL)
                {
                    int i;
 
                    for (i = 1; i < nlines; i++)
                    {
                        self->_data[i] = self->_data[0] + i * ncols;
                    }
 
                    /* Initialization */
                    for (i = 0; i < nlines * ncols; i++)
                    {
                        self->_data[0][i] = 0.0;
                    }
                }
                else
                {
                    /* Echec de l'allocation de memoire: on fait le menage et on
                       renvoit la valeur NULL */
                    free(self->_data);
                    free(self), self = NULL;
                }
            }
            else
            {
                /* Echec de l'allocation: on fait le menage et on renvoit la
                   valeur NULL */
                free(self), self = NULL;
            }
        }
        else
        {
            /* Echec de l'allocation de memoire pour self: rien a faire, on
               renvoit la valeur NULL. */
        }
    }
 
    return self;
}
 
struct Matrix * m_matrix_delete(struct Matrix *self)
{
    if (self != NULL)
    {
        free(self->_data[0]);
        free(self->_data);
        free(self), self = NULL;
    }
 
    return self;
}

Thierry