Fonction qui retourne une matrice

Version imprimable

20/10/2007, 19h37
condor_01

Fonction qui retourne une matrice

Salut à tous,
Je veux écrire une fonction qui retourne une matrice (tableau à deux dimensions)
D'après ce que j'ai lu, une fonction ne peut pas retourner un tableau. Il faut utiliser les pointeurs.
Mais les pointeurs me paraissent difficiles à manipuler.
Comment pourrais je écrire cette fonction et l'utiliser par la suite.

Et si je veux écrire une fonction qui prend comme paramètre une matrice qu'est ce que je dois faire?

Mercii

Citation:

Envoyé par condor_01

Salut à tous,
Je veux écrire une fonction qui retourne une matrice (tableau à deux dimensions)
D'après ce que j'ai lu, une fonction ne peut pas retourner un tableau. Il faut utiliser les pointeurs.
Mais les pointeurs me paraissent difficiles à manipuler.
Comment pourrais je écrire cette fonction et l'utiliser par la suite.

Et si je veux écrire une fonction qui prend comme paramètre une matrice qu'est ce que je dois faire?

Mercii

Un pointeur n'est absolument pas difficile à manipuler. Ce n'est que l'adresse d'une variable => Cours de programmation C.
2 solutions
Dans l'appelant tu définis ta matrice puis tu passes l'adresse de celle-ci à la fonction
exemple
Code:

1 2 3 4 5 6 7 8 9 10 int main() { int matrice[100][100]; fct(matrice); } void fct(int m[100][100]) { m[x][y]=...; }
dans ce cas rien à renvoyer

Ou bien ta fonction crée la matrice (réservation de mémoire) puis renvoie le pointeur récupéré à la réservation => nécessité ensuite que tu gères toi-même la libération. C'est plus compliqué et plus dangereux (imagine que la fonction soit intégrée dans une boucle...)
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 int **fct() { int i; int **matrice; // Allocation de l'espace pour stocker 100 pointeurs matrice=malloc(100 * sizeof(int*)); // Allocation de chaque pointeur pour stocker 100 int for (i=0; i < 100; i++) matrice[i]=malloc(100 * sizeof(int)); return matrice; } int main() { int **matrice; int i; matrice=fct(); <... travail sur la matrice ...> // Libération de chaque pointeur for (i=0; i < 100; i++) free(matrice[i]); // Libération du pointeur global free(matrice); }
En plus faut inclure des tests si une des allocations se passe mal et y associer une action de libération des allocations précédentes. Bref plus compliqué...

En revanche, surtout ne tente pas un truc de ce style
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int **fct() { int matrice[100][100]; return matrice; } int main() { int **matrice; matrice=fct(); }
Tu ne ferais que récupérer l'adresse d'une variable volatile (une fois que tu quittes "fct()", toutes les variables locales sont libérées et la mémoire associée affectée à autre chose) => tu récupères une adresse inutilisable. Il faut impérativement que dans "fct" la matrice soit allouée dans ce qui se nomme "le tas" via du malloc (mémory allocate)...

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
 
// Multiplie une matrice 1*4 par une matrice 4*4.
void MatriceMultiplication_14_44 (double matrice_1 [4], double matrice_2 [16], double matrice_s [4])
{
	matrice_s [0] =
		(matrice_1 [0] * matrice_2 [0]) +
		(matrice_1 [1] * matrice_2 [1]) +
		(matrice_1 [2] * matrice_2 [2]) +
		(matrice_1 [3] * matrice_2 [3]);
	matrice_s [1] =
		(matrice_1 [0] * matrice_2 [4]) +
		(matrice_1 [1] * matrice_2 [5]) +
		(matrice_1 [2] * matrice_2 [6]) +
		(matrice_1 [3] * matrice_2 [7]);
	matrice_s [2] =
		(matrice_1 [0] * matrice_2 [8]) +
		(matrice_1 [1] * matrice_2 [9]) +
		(matrice_1 [2] * matrice_2 [10]) +
		(matrice_1 [3] * matrice_2 [11]);
	matrice_s [3] =
		(matrice_1 [0] * matrice_2 [12]) +
		(matrice_1 [1] * matrice_2 [13]) +
		(matrice_1 [2] * matrice_2 [14]) +
		(matrice_1 [3] * matrice_2 [15]);
}

Voilà un exemple basique. Comme tu voit, les matrices que je manipule ont une structure en une dimention au niveau du codage (pas de doubles pointeurs ni de structures qui ralentissent les calculs) et ma fonction produit une matrice dont la mémoire à déjà été allouée (comme ça quand ma fonction appelante fait le calcul pour 1000 points à la suite elle n'a qu'à allouer une seule fois la mémoire) :

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
 
void ImageTraitement (HWND hwnd)
{
	HDC hdc;
	PAINTSTRUCT ps;
	RECT ClientRect;
	long i;
	double coord_3d [4];
	double coord_2d [2];
 
	GetClientRect (hwnd, &ClientRect);
 
	hdc = BeginPaint (hwnd, &ps);
	// Traitement des points un par un.
	for (i=0; i<5*5*5; i++){
		// Calcule les coordonnées du point dans la base caméra.
		MatriceMultiplication_14_44 (grille + (i*4), matrice_globale_camera, coord_3d);
 
		if (coord_3d [2] != 0){
			// Calcule les coordonnées dans le plan vituel (en mm).
			coord_2d [0] = distance_ecran * (coord_3d [0] / coord_3d [2]);
			coord_2d [1] = distance_ecran * (coord_3d [1] / coord_3d [2]);
 
			// Calcule les coordonnées dans le plan réel (en pixel)
			coord_2d [0] *= largeur_ecran_pixel / largeur_ecran_metrique;
			coord_2d [1] *= hauteur_ecran_pixel / hauteur_ecran_metrique;
 
			// Centre les cordonnées
			coord_2d [0] += ClientRect.right / 2;
			coord_2d [1] = (ClientRect.bottom / 2) - coord_2d [1];
 
			// Affiche le point
			SetPixel (hdc, (long)(coord_2d [0]), (long)(coord_2d [1]), 0x00FFFFFF);
		}
	}
	EndPaint (hwnd, &ps);
}

22/10/2007, 11h37
diogene
Sve@r :
Citation:
En revanche, surtout ne tente pas un truc de ce style

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int **fct() { int matrice[100][100]; return matrice; } int main() { int **matrice; matrice=fct(); }

Tu ne ferais que récupérer l'adresse d'une variable volatile...
L'exemple n'est pas correct et le compilateur ne sera pas d'accord: matrice dans la fonction fct n'est pas du type int** mais int (*)[100], mais la conclusion l'est (retourner l'adresse d'une variable locale est à ne pas faire effectivement)

Merci pour vos réponses.
Je suis en train de travailler sur une fonction qui doit afficher une matrice
Voila ce que j'ai fait:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 matrix_display(int adj_matrix[][], int nb_nodes) { int i=0; int j=0; for(i=0;i<nb_nodes;i++) { for(j=0;j<nb_nodes;j++) { printf("matrix[%d][%d]=%d ",i,j,adj_matrix[i][j]) ; } printf ("\n"); } }
et puis je l'appelle

Code:

matrix_display(adj_matrix,nb_nodes);

Mais ça ne marche pas !!

22/10/2007, 12h27
condor_01

La matrice est une matrice carré de taille

Code:

nb_nodes

Le problème c'est que la variable

Code:

nb_nodes

je ne la connais pas au début
c'est au cours de l'exécution qu'elle est récupérée
22/10/2007, 13h01
diogene
Code:

1 2 3 4 5 6 matrix_display(int adj_matrix[][], int nb_nodes) { ... printf("matrix[%d][%d]=%d ",i,j,adj_matrix[i][j]) ; ... }
Pour pouvoir utiliser la notation [][] pour accéder aux éléments de la matrice, le compilateur doit connaître la seconde dimension du tableau. Indépendamment, la fonction doit avoir void pour type de retour.

Code:

void matrix_display(int adj_matrix[][???], int nb_nodes)

Citation:

...je ne la connais pas au début
c'est au cours de l'exécution qu'elle est récupérée

Comment est le code de création du tableau ?

Citation:

Envoyé par Sve@r

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
int **fct()
{
    int i;
    int **matrice;
 
    // Allocation de l'espace pour stocker 100 pointeurs
    matrice=malloc(100 * sizeof(int*));
 
    // Allocation de chaque pointeur pour stocker 100 int
    for (i=0; i < 100; i++)
        matrice[i]=malloc(100 * sizeof(int));
 
    return matrice;
}
 
int main()
{
    int **matrice;
    int i;
 
    matrice=fct();
 
    /* travail sur la matrice */
 
    /* Libération de chaque pointeur */
    matrice_detruire(
 
   // Libération du pointeur global
   free(matrice);
}

On peut faire plus propre. Je propose:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int **creer_matrice(size_t xsize, size_t ysize)
{
    int **matrice = NULL;
 
    if (xsize > 0 && ysize > 0)
    {
        matrice = malloc(xsize * sizeof *matrice);
        if (matrice != NULL)
        {
            matrice[0] = malloc(xsize * ysize * sizeof *matrice[0]);
            /* Verifier que l'allocation a reussi et faire le menage si 
               necessaire */
            if (matrice[0] != NULL)
            {
                size_t i;
 
                for (i = 1; i < xsize; i++)
                {
                    matrice[i] = &matrice[0][i*ysize];
                }
                memset(matrice[0], 0, xsize * ysize * sizeof matrice[0]);
            }
            else
            {
                /* Erreur d'allocation: on fait le menage */
                free(matrice), matrice = NULL;
            }
        }
        else
        {
            /* Erreur d'allocation: rien a faire ici, matrice vaut NULL */
        }
    }
 
    return matrice;
}
 
void matrice_detruire(int ***matrice)
{
    if (matrice != NULL && *matrice != NULL)
    {
        int **this = *matrice;
 
        free(this[0]);
        free(this);
        *matrice = NULL;
    }
}
 
int main(void)
{
    int **matrice = NULL;
 
    matrice = creer_matrice(3, 4);
 
    /* travail sur la matrice */
 
    /* Liberation de chaque pointeur */
    matrice_detruire(&matrice);
 
    return 0;
}

Thierry