fonction retournant un tableau multidimensionnel: Problème!

**aero_climb** · 03/11/2006, 16h47

Bonjour à toute la communauté,

Mon souci est au niveau d'une valeur de retour d'une fonction. En effet, ma fonction est faite pour traiter n'importe quelle requête MySQL qui est supposée renvoyer quelque chose (une requête select par exemple).
J'aimerai donc que ma fonction me retourne un tableau de ce type:
xxxxxxxx| champ1 | champ2 | ............ | champ X
ligne1 | valeur | valeur |............. | valeur X
ligne 2 | valeur | valeur |............. | valeur X
ligne X | valeur | valeur |............. | valeur X

Mon problème est donc de pouvoir utiliser en dehors de la fonction le tableau que je constitue à l'intérieur de la fonction.
Voici mon code qui est totalement fonctionnel SAUF pour la valeur de retour. En gras dans le code, c'est les instructions qu'il faut sans doute modifier pour que la fonction fonctionne correctement. Mais comment les modifier...

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
char **  mysql_requete_select(MYSQL* connexion, char* requete) {
	MYSQL_RES *resultat;
	MYSQL_ROW ligne;
	my_ulonglong nb_ligne; 
	int nb_champ;
	int indice_ligne;
	int indice_champ;
	
	if(mysql_query(connexion, requete)) {
		printf(mysql_error(connexion));
	}
	resultat = mysql_store_result(connexion);
	nb_ligne = mysql_num_rows(resultat);
	nb_champ = mysql_num_fields(resultat);
	char *tab_retour[nb_ligne][nb_champ];
	
	char *pchaine;
	for(indice_ligne=0; (ligne = mysql_fetch_row(resultat)); indice_ligne++ ) {
		for(indice_champ=0; indice_champ<nb_champ; indice_champ++) {
			pchaine = malloc(strlen(ligne[indice_champ]) + 1);
			strcpy(pchaine, ligne[indice_champ]);
			tab_retour[indice_ligne][indice_champ] = pchaine;
		}
	}
	return tab_retour;

La variable tab_retour est EXACTEMENT le tableau que je veux avoir!
Mon problème est donc de savoir comme pouvoir récupérer ce tableau afin de l'utiliser en dehors de cette fonction... Le mystère est là... (enfin pour moi )

Si quelqu'un a la réponse, je serai ravi

**Médinoc** · 03/11/2006, 16h56

Ouh, tu cherches à retourner un VLA...
D'une part ce n'est pas évident que ce soit possible, d'autre part, un VLA est une variable locale, et on ne retourne jamais l'adresse d'une variable locale...

**aero_climb** · 03/11/2006, 17h06

D'accord. Mes warnings sur gcc comme quoi on ne pouvait pas retourner une variable locale étaient donc véridiques. Zut.

Il doit bien avoir une solution à mon problème, non? En passant en paramètre de la fonction un pointeur mais en faisant quoi après

Sur ce coup j'ai du mal... Un expert dans la salle? (ou quelqu'un ayant la réponse tout simplement

)

**goutbouyo** · 03/11/2006, 17h17

Tu peux initialiser ton tableau à 2 dimensions dans la fonction appellante et le passer en paramètre ta fonction :

char tab_retour[nb_ligne][nb_champ];
Le prototype de ta fonction sera :
void mysql_requete_select(MYSQL* connexion, char* requete, char **tab);

**Médinoc** · 03/11/2006, 17h25

Tu peux initialiser ton tableau à 2 dimensions dans la fonction appellante

Ben non, les dimensions sont calculées dynamiquement dans la fonction appelée...

**diogene** · 03/11/2006, 17h26

Tu peux initialiser ton tableau à 2 dimensions dans la fonction appellante et le passer en paramètre ta fonction :

Code :

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

1
2
3
char tab_retour[nb_ligne][nb_champ];
Le prototype de ta fonction sera :
void mysql_requete_select(MYSQL* connexion, char* requete, char **tab);

Ce prototype ne permet pas de passer le tableau tab_retour dont le type n'est absolument pas char**

D'accord. Mes warnings sur gcc comme quoi on ne pouvait pas retourner une variable locale étaient donc véridiques. Zut.

Plus précisément, comme le dit Medinoc , ne pas retourner l'adresse d'une variable locale

**Thierry Chappuis** · 03/11/2006, 17h31

Ne peux -tu pas faire une allocation dynamique d'un tableau bidimensionnel de chaînes de caractères (avec malloc) à l'intérieur de ta fonction et retourner son adresse?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
        char ***tab_retour;
	tab_retour = malloc(nb_ligne*sizeof(*tab_retour));
	if (tab_retour == NULL){
		exit(1);
	}
	for (i=0; i<nb_ligne; i++){
		*(tab_retour+i) = malloc(nb_champs*sizeof(**tab_retour));
		if(*(tab_retour+i) == NULL){
                        exit(1);
                }
	}
        /*...*/
        return tab_retour;

**aero_climb** · 03/11/2006, 18h26

Merci à tous! J'utilise ta solution mujigka et cela fonctionne à merveille!
L'idée de faire comme ça m'a traversé l'esprit un instant mais manier des pointeurs sur 3 tableaux différents, non merci

Mais comme la solution est toute prête, je prends volontier.

Petite dernière question: Pour désallouer toute cette mémoire, je peux me contenter d'un free sur tab_retour ou je doit faire un free sur tab_retour[0][0], sur tab_retour[0] et tab_retour?

**aero_climb** · 03/11/2006, 18h35

Euh là en fait en réfléchissant, j'ai l'impression que ça va être difficile pour moi de désallouer la mémoire avec la méthode de mujigka étant donné que je n'ai pas les dimensions du tableaux en dehors de la fonction.

Je me trompe?

**Emmanuel Delahaye** · 03/11/2006, 18h37

Envoyé par goutbouyo

Tu peux initialiser ton tableau à 2 dimensions dans la fonction appellante et le passer en paramètre ta fonction :

char tab_retour[nb_ligne][nb_champ];
Le prototype de ta fonction sera :
void mysql_requete_select(MYSQL* connexion, char* requete, char **tab);

Il faut arrêter avec ça. Un char ** n'a jamais été le bon type pour un tableau lineaire à 2 dimensions. Merci de ne pas répondre n'importe quoi, c'est déjà assez compliqué de répondre ce qu'il faut...

http://emmanuel-delahaye.developpez.....htm#param_tab

**Emmanuel Delahaye** · 03/11/2006, 18h40

Envoyé par mujigka

Ne peux -tu pas faire une allocation dynamique d'un tableau bidimensionnel de chaînes de caractères (avec malloc) à l'intérieur de ta fonction et retourner son adresse?

Code :

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

1
2
 
        char ***tab_retour;

Pourquoi 3 étoiles pour un tableau de pointeur ?

Tout le monde est tombé sur la tête ce soir ou quoi ?

**Emmanuel Delahaye** · 03/11/2006, 18h55

Envoyé par aero_climb

Euh là en fait en réfléchissant, j'ai l'impression que ça va être difficile pour moi de désallouer la mémoire avec la méthode de mujigka étant donné que je n'ai pas les dimensions du tableaux en dehors de la fonction.

Je me trompe?

Créer un tableau dynamique à 2 dimensions (par exemple 3 lignes de 20 colonnes) :

Code :

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

1
2
3
4
5
 
   size_t col = 20;
   size_t lin = 3
 
   char ** pp = tab2D_create (lin, col);

le détruire :

Code :

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

   tab2D_delete (pp, lin, col);

Le prototype des fonctions est :

Code :

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

1
2
3
 
   char ** tab2D_create (size_t lin, size_t col);
   void tab2D_delete (char **pp, size_t lin, size_t col);

Si on veut pouvoir détruire le tableau sans passer les dimensions,

Code :

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

1
2
3
4
 
   TAB2D *ptab = tab2D_create (3, 20);
 
   tab2D_delete (ptab);

celle-ci doivent être enregistrées quelque part :
On utilise pour ça une structure pour regrouper les informations utiles : tailles, adresse :

Code :

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

1
2
3
4
5
6
7
8
 
typedef struct
{
   size_t col;
   size_t lin; 
   char **pp;
}
TAB2D;

avec les prototypes :

Code :

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

1
2
3
 
   TAB2D* tab2D_create (size_t lin, size_t col);
   void tab2D_delete (TAB2D *this);

On peut pousser l'abstraction encore plus loin :

http://emmanuel-delahaye.developpez.com/tad.htm

**benhoeil** · 03/11/2006, 19h01

Pourquoi 3 étoiles pour un tableau de pointeur ?

d'ailleurs je crois avoir déjà fait la gaffe, et je me demande si le compilateur accepte ?

je voudrais bien une solution à ce problème aussi. Elle est bien non la méthode de goutbouyo (à part l'erreur de type pour le tableau à 2 dimension) ?

**benhoeil** · 03/11/2006, 21h00

Envoyé par Emmanuel Delahaye

Il faut arrêter avec ça. Un char ** n'a jamais été le bon type pour un tableau lineaire à 2 dimensions. Merci de ne pas répondre n'importe quoi, c'est déjà assez compliqué de répondre ce qu'il faut...

http://emmanuel-delahaye.developpez.....htm#param_tab

En fait, après lecture d'un paragraphe sur le sujet, est-ce mauvais que le type du paramètre de la fonction soit char** ?

pour la déclaration, OK, ça change. mais moi je ne vois pas le problème pour le type du paramètre d'une fonction.

**diogene** · 03/11/2006, 21h12

Elle est bien non la méthode de goutbouyo (à part l'erreur de type pour le tableau à 2 dimension) ?

Elle n'est pas possible compte tenu de ce qu'on sait : voir la réponse de Médinoc

est-ce mauvais que le type du paramètre de la fonction soit char** ?

Bien sur que non si l'argument est du type char **, ce qui n'est pas le cas ici : Ce que veut souligner Emmanuel , c'est que le nombre d'* n'a rien à voir avec le nombre de dimensions.

**Emmanuel Delahaye** · 03/11/2006, 21h24

Envoyé par benhoeil

En fait, après lecture d'un paragraphe sur le sujet, est-ce mauvais que le type du paramètre de la fonction soit char** ?

C'est mauvais si c'est hors-sujet. Or pour un tableau à deux dimensions, c'est hors sujet. Par contre pour un tableau de pointeurs, c'est OK.

pour la déclaration, OK, ça change. mais moi je ne vois pas le problème pour le type du paramètre d'une fonction.

Le problème, c'est que le type n'est pas bon. Ton compilateur doit d'ailleurs le dire.

**benhoeil** · 03/11/2006, 22h14

Le problème, c'est que le type n'est pas bon. Ton compilateur doit d'ailleurs le dire.

Oui, je viens de vérifier, le compilateur génère un warning. Je pensais que le tableau à 2 dim était un cas particulier du tableau de pointeurs.

Hors sujet : il y avait un post sur un bonhomme qui n'arrivait pas à appeler correctement system() sous cygwin. où est-il passé ??? j'aurais bien aimé avoir la solution.

gl · 03/11/2006, 22h46

Envoyé par benhoeil

Hors sujet : il y avait un post sur un bonhomme qui n'arrivait pas à appeler correctement system() sous cygwin. où est-il passé ??? j'aurais bien aimé avoir la solution.

ici : http://www.developpez.net/forums/sho...d.php?t=232026

**aero_climb** · 04/11/2006, 00h32

Wah! Et bien je vois que le sujet passionne

Je dois avouer que je suis un peu perdu... Un pointeur je comprends bien mais quand il s'agit de pointeur de pointeur de pointeur, là je suis complètement paumé...
La solution avec char ***tab_retour fonctionne... c'est qu'elle doit être correct. Par contre je ne sais pas pourquoi elle fonctionne et je n'arrive vraiment pas à me représenter ce char ***tab_retour.
Si quelqu'un a un peu de temps pour expliquer clairement ce que veut dire un char ***tab_retour, je suis preneur! (Et sûrement d'autres personnes)

Je crois aussi que si on arrive à un tel niveau de complexité (enfin pour moi) c'est que peut être il y a un problème en amont. Je devrais peut être tenter de créer plusieurs fonctions afin de connaitre les dimensions du tableau que je veux créer au lieu de créer un tableau dynamiquement.
La simplicité est clairement ce qui est le mieux.
Mais je suis tout de même d'accord si quelqu'un possède une explication didactique sur le char *** tab_retour.

PS: ce forum est vraiment d'une qualité exeptionnelle, j'adore les compétences des intervenants!

**Emmanuel Delahaye** · 04/11/2006, 09h16

Envoyé par aero_climb

La simplicité est clairement ce qui est le mieux.
Mais je suis tout de même d'accord si quelqu'un possède une explication didactique sur le char *** tab_retour.

Comme je l'ai déjà dit char*** n'est pas le bon type pour l'adresse d'un tableau de pointeurs sur char. C'est char **.

Si tu veux créer dynamiquement un tableau à 2 dimensions, par exemple nb_lin x nb_col, il y a une solution qui consiste à créer nb_lin tableau de nb_col char, et de stocker leurs adresses dans un tableau de nb_lin pointeurs sur char.

On commence par créer le tableau de nb_lin pointeurs sur char.

Rappel, pour créer dynamiquement un tableau de type T et de taille N, on fait :

Code :

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

T *p = malloc (sizeof *p * N);

Donc, pour créer un tableau de nb_lin pointeurs sur char, on applique la formule directement et on fait donc:

Code :

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

char * *pp =  malloc (sizeof *pp * nb_lin);

NOTA :

Code :

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

char * *

peut s'écrire

Code :

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

char**

ou

Code :

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

char        *                 *

, c'est pareil...

Le choix de l'identificateur 'pp' est fait pour qu'on se rappelle qu'il s'agit d'un pointeur de pointeur (char **)

Ensuite, et pour chaque ligne, on crée un tableau de nb_col char, soit :

Code :

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

1
2
3
4
5
6
7
 
size_t i;
 
for (i = 0; i < nb_lin; i++)
{
   pp[i] = malloc (sizeof *pp[i] * nb_col);
}

Ensuite, la fonction peut retourner la valeur de pp. Ce qui donne :

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
 
#include <stdlib.h>
 
char **tab2_create (size_t nb_lin, size_t nb_col)
{
   char **pp = malloc (sizeof *pp * nb_lin);
   if (pp != NULL)
   {
      size_t i;
 
      for (i = 0; i < nb_lin; i++)
      {
         pp[i] = malloc (sizeof *pp[i] * nb_col);
      }
   }
   return pp;
}

Il n'est absolument pas question de char ***. Attention, ce code est un peu simpliste et ne traite pas tous les cas d'erreurs d'allocation. Par ailleurs,les données (lignes) ne sont pas initialisées.

Dans la fonction appelante, on peut ensuite utiliser le tableau comme un tableau à 2 dimensions statique, c'est à dire avec les [lin][col]. Par exemple :

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
 
#include <stdio.h>
 
int main (void)
{
   /* creation d'un tableau de 10 ligne de 80 caracteres utiles */
 
   size_t nb_lin = 10;
   size_t nb_col = 80 + 1;
   char **tab = tab2_create (nb_lin, nb_col);
 
   if (tab != NULL)
   {
      /* Initialisation des lignes */
      size_t i;
      for (i = 0; i < nb_lin; i++)
      {
         strcpy (tab[i], "");
      }
 
      /* remplissage de 2 lignes,  puis affichage */
      strcpy (tab[3], "Hello");
      strcpy (tab[9], "morld");
 
      printf ("%s %s\n", tab[3], tab[9]);
 
      /* correction d'un caractere, puis affichage */
      tab[9][0] = 'w';
 
      printf ("%s %s\n", tab[3], tab[9]);
 
   }
 
   return 0;
}

Ce code fonctionne,

Hello morld
Hello world

Press ENTER to continue.

mais mon traceur d'allocations m'indique que de la mémoire n'est pas libérée :

SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D24E8 (40 bytes) malloc'ed at line 9 of 'main.c' not freed
SYSALLOC Bloc 003D2518 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D2578 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D25D8 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D2638 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D2698 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D26F8 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D2758 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D27B8 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D2818 (81 bytes) malloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D4A10 (81 bytes) malloc'ed at line 16 of 'main.c' not freed

ce qui parait assez logique...

Je te laisse écrire la fonction qui libère la mémoire. Rappel : tout ce qui a été alloué doit être libéré.

fonction retournant un tableau multidimensionnel: Problème!

C

Discussions similaires

Partager

Partager