Pointeurs de matrices ??

Bonjour à tous,

J'ai vu qu'en C il était possible d'écrire

Code:

---

long matrice[9][9]

---

pour créer une matrice 9*9. Si l'on veut écrire ça "sous forme de pointeurs", doit-on faire

Code:

---

long **matrice

---

?

Je suis dans le cas d'une fonction qui doit renvoyer cette matrice : doit-elle être de type long** ? Et quand je renvoie cette matrice,

Code:

---

return matrice;

---

suffit ou je dois mettre autre chose ? Et enfin : quand j'envoie cette matrice à une fonction, que dois-je écrire ???


Merci :P


EDIT : j'ai aussi fait un test, pour passer une matrice [9][9] en argument, et bizarrement, long maFonction(long matrice[][]) ne fonctionne pas, mais long maFonction(long matrice[][9]) fonctionne !!! Comment ça se fait ???

Citation:

---

EDIT : j'ai aussi fait un test, pour passer une matrice [9][9] en argument, et bizarrement, long maFonction(long matrice[][]) ne fonctionne pas, mais long maFonction(long matrice[][9]) fonctionne !!! Comment ça se fait ???

---

Rien de tel qu'une petite explication :

http://www.ldsol.com/doc/ansi-c/node62.htm#SECTION00693000000000000000

Sinon, pour en revenir à ton problème :

Citation:

---

J'ai vu qu'en C il était possible d'écrire

Code:

---

1 2	long matrice[9][9]

---

pour créer une matrice 9*9

---

Oui là tu crée un tableau bi-dimensionnel.

Citation:

---

Si l'on veut écrire ça "sous forme de pointeurs", doit-on faire

Code:

---

1 2	long **matrice

---

?

---

Oui, là tu as crée un pointeur sur un pointeur de long. Ca peut te permettre de créer un objet qui pourra faire office d'une matrice. Il ne faudra pas cependant oublier d'effectuer une allocation mémoire pour ta matrice.

Citation:

---

Je suis dans le cas d'une fonction qui doit renvoyer cette matrice : doit-elle être de type long** ?

---

Si tu le fais comme précédement, oui.

Citation:

---

Et enfin : quand j'envoie cette matrice à une fonction, que dois-je écrire ???

---

un truc du genre :

Code:

---

1 2 3

void maFct( long ** matrice ) ...

---

long maFonction(long matrice[][9]) : Le compilateur a besoin de connaitre la taille du type d'argument que tu lui passes : ici un pointeur vers des tableaux de 9 longs, donc si tu incrémentes le pointeur dans la fonction il se calera automatiquement en début de tableau de 9 (ligne 0, ligne 1 ...).
Si tu déclares une matrice sous la forme long tab[X][Y], tu ne peux pas la passer sous la forme **tab, le compilo refusera, tu peux faire long maFonction(long matrice[][9]) ou long maFonction(long (*matrice)[9]) .

Voilà un exemple de code pour illustrer :

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

#include <stdio.h>   void affi(int (*tab)[3]) { int i , j;   for(i = 0; i < 3; i++, tab++) { for(j = 0; j < 3; j++) printf("%3d", (*tab)[j]);   puts(""); } }   int main(void) { int tab[3][3]; int i, j;   for(i = 0; i < 3; i++) { for(j = 0; j < 3; j++) tab[i][j] = i*3 + j;   } affi(tab); return 0; }

---

En fait ça dépends si tu souhaites faire une allocation statique ou dynamique.

Une allocation statique reserve l'espace en mémoire dés que tu a écris :

Code:

---

1 2	long matrice[9][9]

---

ce qui te coute en mémoire (en octet) :
un long vaut 4 octets soit 32 bits

tu as 9 cases en largeur et 9 cases en hauteur => 81 cases

donc un total de 4*9*9 = 324 octets mémoires (pour rien car il n'y a pas encore de donnée dans ton tableau).

avec une allocation dynamique en utilisant

Code:

---

1 2	long ** matrice;

---

tu as un pointeur de pointeur sur une zone mémoire (qui n'est pas encore définie)!

tu alloues la zone mémoire dés que tu souhaites l'utiliser comme ci-dessous :

Code:

---

1 2 3 4

matrice = (long **) malloc(9 *sizeof(long)); for (i = 0 ; i < 9 ; i++) matrice[i] = (long *)malloc(9*sizeof(long));

---

et ensuite dés que tu n'en a plus besoin tu la libère :

Code:

---

1 2 3 4

for (i = 0 ; i < 9 ; i++) free(matrice[i]); free(matrice);

---

Pour avoir les deux fonction malloc et free il faut faire

Code:

---

#include <stdlib.h>

---

Voilà j'espère avoir put t'aider.

Merci à vous, c'est beaucoup plus clair maintenant :P

Citation:

---

Envoyé par jo_le_coco

J'ai vu qu'en C il était possible d'écrire

Code:

---

long matrice[9][9]

---

pour créer une matrice 9*9. Si l'on veut écrire ça "sous forme de pointeurs", doit-on faire

Code:

---

long **matrice

---

?

---

On peut (c'est pas une FAQ ?).

Methode générale :

Il faut créer un tableau de Y pointeurs

Code:

---

long **matrice = malloc(Y * sizeof *matrice);

---

puis, après les vérifications d'usage, créer Y tableaux de X long dont on range les adresses dans le tableau de pointeurs :

Code:

---

1 2 3 4 5 6 7

int i;   for (i = 0; i < Y; i++) { matrice[i] = malloc (X * sizeof *matrice[i]); }

---

ensuite, on peut accéder aux données en faisant matrice[i][j]

Quand on a plus besoin de la matrice, penser à libérer les blocs dans le bon ordre...

Citation:

---

Envoyé par websurfeur

tu alloues la zone mémoire dés que tu souhaites l'utiliser comme ci-dessous :

Code:

---

1 2 3 4

matrice = (long **) malloc(9 *sizeof(long)); for (i = 0 ; i < 9 ; i++) matrice[i] = (long *)malloc(9*sizeof(long));

---

---

Ecriture inutilement complexe et difficile à maintenir...

http://emmanuel-delahaye.developpez....tes.htm#malloc

Code:

---

1 2 3 4 5 6

long **matrice = malloc (9 *sizeof *matrice); for (i = 0 ; i < 9 ; i++) { matrice[i] = malloc (9 * sizeof *matrice[i]); }

---

Le même en double

Code:

---

1 2 3 4 5 6

double **matrice = malloc (9 *sizeof *matrice); for (i = 0 ; i < 9 ; i++) { matrice[i] = malloc (9 * sizeof *matrice[i]); }

---

et hop, un changement.

Et je ne parle pas des constantes magiques (9) pour définir la taille...

Ca reste quand même très complexe :?

Citation:

---

Envoyé par Emmanuel Delahaye

Code:

---

1 2 3 4 5

long **matrice = malloc (9 *sizeof *matrice); for (i = 0 ; i < 9 ; i++) { matrice[i] = malloc (9 * sizeof *matrice[i]); }

---

---

Je ne comprends pas vraiment ce code :oops: :roll: :

Je connais les allocations dynamiques, mais là je suis un peu dérouté :(

Citation:

---

Envoyé par jo_le_coco

Je ne comprends pas vraiment ce code :oops: :roll: :

---

J'ai pourtant tout expliqué avant. Je t'engage à relire mes messages.

Citation:

---

Je connais les allocations dynamiques, mais là je suis un peu dérouté :(

---

Tu as lu l'article dont j'ai mis le lien ?

Citation:

---

Je ne comprends pas vraiment ce code

---

http://rperrot.developpez.com/articl...ocationC/#L1.2

J'ai bien tout lu, mais je débute, et quand je me trouve devant une pléthore de pointeurs, d'allocations, de tableaux, de tableaux à plusieurs dimensions... je succombe :cry:

Bon mais grosso modo, je comprends. Par contre, il reste UN truc que je ne saisis vraiment pas : dans ton lien, tu dis que

Code:

---

long *p = malloc (sizeof (long));

---

peut être remplacé par

Code:

---

long *p = malloc(sizeof *p)

---

Mais comment est-ce que l'ordinateur peut deviner quelle est la taille de *p ??? Et, du même genre, comment, dans ce code :

Code:

---

long **matrice = malloc (9 *sizeof *matrice);

---

l'odinateur sait-il la taille de *matrice, qui n'a même pas été déclaré 8O ??

Et, dernière petite question (après j'arrête, promis :lol: ) : pourquoi ne pas faire simplement

Code:

---

long matrice[9][9];

---

au besoin avec des constantes #define au lieu des 9 ?

sizeof a deux formes, une avec parenthèse et une sans.

Celle avec parenthèse attend un type et celle sans attend une expression.

Ici, c'est une expression qu'on attend.

L'expression en question est celle ci :

Code:

---

1 2

*p

---

Or ceci est le type du pointeur, c'est à dire long, du coup, ça revient strictement au même que sizeof(long). C'est un raccourci pour faciliter les choses.

Citation:

---

L'odinateur sait-il la taille de *matrice, qui n'a même pas été déclaré ??

---

Pour lui, *matrice est un pointeur d'entier long, ça fonctionne comme avant.

Citation:

---

Pourquoi ne pas faire simplement ...

---

C'est toi qui veux utiliser les pointeurs :

Citation:

---

Si l'on veut écrire ça "sous forme de pointeurs", doit-on faire

---

Citation:

---

Envoyé par jo_le_coco

J'ai bien tout lu, mais je débute, et quand je me trouve devant une pléthore de pointeurs, d'allocations, de tableaux, de tableaux à plusieurs dimensions... je succombe :cry:

---

Euh, c'est bien toi qui a parlé de

Code:

---

long ** matrice;

---

non ?

Citation:

---

Bon mais grosso modo, je comprends. Par contre, il reste UN truc que je ne saisis vraiment pas : dans ton lien, tu dis que

Code:

---

long *p = malloc (sizeof (long));

---

peut être remplacé par

Code:

---

long *p = malloc(sizeof *p)

---

Mais comment est-ce que l'ordinateur peut deviner quelle est la taille de *p ???

---

Il ne devine pas, il sait et il calcule. *p est une forme simplifiée de p[0], c'est à dire un élément (ici, le premier) du tableau pointé par p.

sizeof p[0] retourne donc la taille de p[0]. Pour calculer la taille, le compilateur n'a besoin que du type. Comme p a été défini avec un type, il peut en déduire la taille de l'objet.

Citation:

---

Et, du même genre, comment, dans ce code :

Code:

---

long **matrice = malloc (9 *sizeof *matrice);

---

l'odinateur sait-il la taille de *matrice, qui n'a même pas été déclaré 8O ??

---

Heink ? Et ça,

Code:

---

long **matrice = ...;

---

c'est pas une défintion ?

Citation:

---

Et, dernière petite question (après j'arrête, promis :lol: ) : pourquoi ne pas faire simplement

Code:

---

long matrice[9][9];

---

au besoin avec des constantes #define au lieu des 9 ?

---

Oui, bien sûr, mais encore une fois, ce n'est pas moi qui ai abordé le long ** matrice...

Citation:

---

Envoyé par jo le croco

pour créer une matrice 9*9. Si l'on veut écrire ça "sous forme de pointeurs", doit-on faire

---

Citation:

---

Envoyé par PRomu@ld

Code:

---

*p

---

Or ceci est le type du pointeur, c'est à dire long,

---

Ce n'est pas un type c'est un objet (c'est pour ça qu'il n'y a pas de parenthèses)

Je pensais que c'était indispensable dans mon cas d'utiliser les pointeurs... mais ça m'aura appris bien des choses sur les allocations :P Merci à vous :roll: :D

Oups, je me suis planté, je voulais dire :

Citation:

---

Or ceci est du type du pointeur, c'est à dire long

---

Encore une fois de plus je ne me relis pas ...
:sm: