Discussion :

[Invité]

Bonjour à tous,

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

Code :

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

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 :

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

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 :

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

return matrice;

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


Merci


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 ???

[PRomu@ld]

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

[PRomu@ld]

Sinon, pour en revenir à ton problème :

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

Code :

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

1
2
 
long matrice[9][9]

pour créer une matrice 9*9

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

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

Code :

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

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.

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.

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

un truc du genre :

Code :

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

1
2
3
 
void maFct( long ** matrice )
...

[Trap D]

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 :

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

[websurfeur]

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 :

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

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 :

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

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 :

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

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 :

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

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 :

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

#include <stdlib.h>

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

[Invité]

Merci à vous, c'est beaucoup plus clair maintenant

[Emmanuel Delahaye]

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

Code :

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

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 :

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

long **matrice

?

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

Methode générale :

Il faut créer un tableau de Y pointeurs

Code :

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

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 :

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

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

[Emmanuel Delahaye]

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

Code :

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

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 :

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

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 :

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

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

[Invité]

Ca reste quand même très complexe

Code :

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

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 :

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

[Emmanuel Delahaye]

Je ne comprends pas vraiment ce code :

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

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

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

[PRomu@ld]

Je ne comprends pas vraiment ce code

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

[Invité]

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

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 :

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

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

peut être remplacé par

Code :

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

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 :

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

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

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

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

Code :

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

long matrice[9][9];

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

[PRomu@ld]

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 :

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

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.

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.

[PRomu@ld]

Pourquoi ne pas faire simplement ...

C'est toi qui veux utiliser les pointeurs :

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

[Emmanuel Delahaye]

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

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

Code :

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

long ** matrice;

non ?

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 :

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

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

peut être remplacé par

Code :

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

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.

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

Code :

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

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

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

Heink ? Et ça,

Code :

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

long **matrice = ...;

c'est pas une défintion ?

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

Code :

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

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

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

[Emmanuel Delahaye]

Code :

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

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

[Invité]

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

[PRomu@ld]

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

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

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