Discussion :

[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

[Sve@r]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)...

[_Michel]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
}

[diogene]

Sve@r :

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[condor_01]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

matrix_display(adj_matrix,nb_nodes);

Mais ça ne marche pas !!

[condor_01]

La matrice est une matrice carré de taille

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

nb_nodes

Le problème c'est que la variable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[diogene]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

void matrix_display(int adj_matrix[][???], int 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

Comment est le code de création du tableau ?

[Thierry Chappuis]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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