probleme de pointeur ? return array

Version imprimable

03/06/2006, 17h06
Funraill.net

probleme de pointeur ? return array
Bonjour,

voila j'ai une fonction qui doit retourner un tableau de "unsigned char",

j'aimerai savoir comment declarer tt ca, parce que au moment de compiler j'ai des erreurs de pointeur et tt...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 unsigned char image; unsigned char fonction(){ unsigned char tab[r][g][b] /**/ return tab; } main(){ image = fonction(); }
quelqun pourrai m'aider ?
03/06/2006, 17h13
shadowmoon
Citation:

unsigned char image

image est donc bien de type unsigned char, par contre

Citation:

unsigned char tab[r][g][b]

tab est un tableau à trois dimensions est n'est pas de type unsigned char, mais tab[X][Y][Z] avec X,Y,Z entiers si. Tu dois donc faire par exemple :
Code:

1 2 return (tab[250][251][252])
et la ca devrait marcher

pour information, chaque combinaison de X,Y,Z définit une couleur à condition que chacun des trois soit compris entre 0 et 255.
03/06/2006, 17h25
gege2061
Citation:
Envoyé par shadowmoon

tab est un tableau à trois dimensions est n'est pas de type unsigned char, mais tab[X][Y][Z] avec X,Y,Z entiers si. Tu dois donc faire par exemple :

Code:

1 2 return (tab[250][251][252])

et la ca devrait marcher
http://yelims4.free.fr/Ordinateur/Ordinateur01.gif Perdu...

Les tableaux ne peuvent être retournés par une fonction ou passé en paramètre, il faut utiliser son adresse :

Code:

unsigned char ***foo (void);

Comme la zone mémoire contenant le tableau est utilisé hors de la fonction, il faut utiliser l'allocation dynamique.

Comment faire pour que ma fonction retourne un tableau de 2 éléments?
03/06/2006, 17h28
Funraill.net

il n'est pas possible de retourné un tableau entier ??
car j'ai une autre fonction qui prend en parametre le tableau
03/06/2006, 17h28
shadowmoon

Citation:

Les tableaux ne peuvent être retournés par une fonction ou passé en paramètre, il faut utiliser son adresse

d'ou l'erreur de pointeur.

funraill : donne l'adresse en paramètre de ta fonction, ce sera bien plus facile à gérer après.

Rque : j'ai essayé d'apporter une réponse sans avoir touché au C/C++ de puis 5 ans :lol:
03/06/2006, 17h45
Funraill.net
oki merci (:, mais petite question,

si j'ai par exemple

image1 = mafonc()
image2 = mafonc()
etc...

ca ne sera pas génant ???

edit
ahh, je crois que je vien de comprendre ce que tu m dis

edit2 ...je croi que j'ai pas compris ! lol ):
Code:

1 2 3 4 5 6 7 8 9 10 11 unsigned char image void mafonction(int *adresse){ /* generation de mon tab a trois dimension */ adresse = tab } int main(){ image = mafonc(&image) }
???
03/06/2006, 18h14
Funraill.net

tu pourrais me fair une petit exemple stp ??

Citation:

Envoyé par Funraill.net

Code:

1
2
3
4
5
6
7
8
9
10
11
 
unsigned char image
 
void mafonction(int *adresse){
    /* generation de mon tab a trois dimension */
   adresse = tab
}
 
int main(){
image = mafonc(&image)
}

à mon avis c plutot ca qu'il faut faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
unsigned char *** image
 
unsigned char *** mafonction(unsigned char **adresse){
 
    /* generation de mon tab a trois dimension */
 
   adresse = &&tab /* ou &&&tab, dsl je sais plus comment on manipule les pointeurs */
 
return (&adresse)  /* sinon pas d'affection possible */
 
}
 
int main(){
image = mafonc(&image)
}

Citation:

Envoyé par shadowmoon

à mon avis c plutot ca qu'il faut faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
unsigned char *** image
 
unsigned char *** mafonction(unsigned char **adresse){
 
    /* generation de mon tab a trois dimension */
 
   adresse = &&tab /* ou &&&tab, dsl je sais plus comment on manipule les pointeurs */
 
return (&adresse)  /* sinon pas d'affection possible */
 
}
 
int main(){
image = mafonc(&image)
}

&image => unsigned char **** adresse

03/06/2006, 19h19
crocodilex

Ca va les gars ? Vous vous amusez bien ?

En essayant toute les combinaisons possibles au hasard vous allez peut etre y arriver. Bonne chance quand même....

Ca devrait plus ressembler à:

Code:

1
2
3
4
5
6
7
8
9
10
11
char*** fonction(){
char*** tab=malloc(4*r);
unsigned int i,j;
for(i=0;i<r;i++){
                 tab[i]=malloc(4*g);
                 for(j=0;j<b;j++){
                                  tab[i][j]=malloc(b);
                                  }
                 }
return tab;
}

ARGGGG! je deviens fou lol depuis 12h30 je suis dessus ! ):

voila ma fonction, ne gros je voudrai quelle me renvoi le tableau texture

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
 
GLchar texturePath[128] = "images/512.jpg";
 
//unsigned char texture[512][512][3];	 
/********
 * GLint loadTexture() - Charge une Texture jpeg
 ****/
unsigned char ***loadTexture(char *fichier, int l, int h, unsigned char **adresse){
 	/**
         * Varriable Local */
 	unsigned char texture[l][h][3];	  
 	unsigned char image[l*h*3];
 	struct jpeg_decompress_struct jpegInfo;
 	struct jpeg_error_mgr jpegErreur;
 	FILE *file;
 	unsigned char *ligne;
 	int i, j;
 
 	/**
         * Debut */  	
 	jpegInfo.err = jpeg_std_error(&jpegErreur);
 	jpeg_create_decompress(&jpegInfo);
 	if((file = fopen(fichier, "rb")) == NULL){
 		printf("Erreur: impossible d'ouvrire le fichier jpeg \"%s\"\n", fichier);
 		//exit(1);
 	}
 	jpeg_stdio_src(&jpegInfo, file);
 	jpeg_read_header(&jpegInfo, TRUE);
 
 	// On verifie si l'image est bien au format RGB
 	if(jpegInfo.jpeg_color_space == JCS_GRAYSCALE){
 		printf("Erreur: l'image doit etre encoder en RGB\n");
 		//exit(1);
 	}
 
 	// On verifie si l'image est de bonne taille
 	if((jpegInfo.image_width != l) || (jpegInfo.image_height != h)){
 		printf("Erreur: l'image n'est pas a la bonne taille\nLargeur:%d\nHauteur:%d\n", l, h);
 		//exit(1);
 	}
 
 	// - Tous c bien passez
 	jpeg_start_decompress(&jpegInfo);
 	ligne = image;
 	while(jpegInfo.output_scanline < jpegInfo.output_height){
 		ligne = image +3*h*jpegInfo.output_scanline;
 		jpeg_read_scanlines(&jpegInfo, &ligne, 1);
 	}
 	jpeg_finish_decompress(&jpegInfo);
 	jpeg_destroy_decompress(&jpegInfo);
 
 	// On formate le tableau de sortie pour OpenGL
 	for(i=0; i<h; i++){
 		for(j=0;j<l;j++){
 			texture[i][j][0] = image[i*h*3+j*3];
 			texture[i][j][1] = image[i*h*3+j*3+1];
 			texture[i][j][2] = image[i*h*3+j*3+2];
 			//printf("textureR:%d\ntextureG:%d\ntextureB:%d\n",texture[i][j][0],texture[i][j][0],texture[i][j][0]);
 		}
 	}
 
 	adresse = &&texture;
 	return (adresse);
}

Code:

1
2
3
4
 
int main(){
matexture = loadTexture(playerImgPath, 512, 512, &matexture);
}

03/06/2006, 20h17
Pragmateek

Pour renvoyer l'adresse d'un tableau valide il faut le déclarer dynamiquement ou avec le mot clé "static".

Ca ne peut pas marcher, tu renvoie l'adresse d'une variable locale.

Il faut que tu alloue ton tableau texture avec malloc, et qu'ensuite tu retourne le pointeur renvoye par malloc(3).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdlib.h> unsigned char ***func() { unsigned char ***tab; tab = malloc(taille * sizeof(*tab)); if (tab == NULL) { /* ** Traitement de l'erreur */ } /* ** Initialisation du tableau. */ return (tab); }
Les variables locales non statiques sont detruites a la sortie de la fonction.
Donc il faut allouer pour les conserver.

Et surtout ne pas oublier
Code:

1 2 free(tab);
Des que tu n'as plus besoin de ton tableau.

Bonsoir, et merci

jsuis encore debutant en c... et les allocation avec malloc me sont plutot abstrait... :D

j'ai fais quelque chose comme ca

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
 
unsigned char ***loadTexture(char *fichier, int l, int h){
 
	/**
         * Varriable Local */
 	unsigned char ***texture[l][h][3];	  
 	unsigned char image[l*h*3];
 	struct jpeg_decompress_struct jpegInfo;
 	struct jpeg_error_mgr jpegErreur;
 	FILE *file;
 	unsigned char *ligne;
 	int i, j;
 
	/**
         * Allocation dinamique du tableau */
	texture = malloc(400 * sizeof(*texture));
	if(texture == NULL){
      printf("Erreur: Memoire insufisante !");
      //exit(1);
	}
 
	/**
         * Debut */  	
 	jpegInfo.err = jpeg_std_error(&jpegErreur);
 	jpeg_create_decompress(&jpegInfo);
 	if((file = fopen(fichier, "rb")) == NULL){
 		printf("Erreur: impossible d'ouvrire le fichier jpeg \"%s\"\n", fichier);
 		//exit(1);
 	}
 	jpeg_stdio_src(&jpegInfo, file);
 	jpeg_read_header(&jpegInfo, TRUE);
 
 	// On verifie si l'image est bien au format RGB
 	if(jpegInfo.jpeg_color_space == JCS_GRAYSCALE){
 		printf("Erreur: l'image doit etre encoder en RGB\n");
 		//exit(1);
 	}
 
 	// On verifie si l'image est de bonne taille
 	if((jpegInfo.image_width != l) || (jpegInfo.image_height != h)){
 		printf("Erreur: l'image n'est pas a la bonne taille\nLargeur:%d\nHauteur:%d\n", l, h);
 		//exit(1);
 	}
 
 	// - Tous c bien passez
 	jpeg_start_decompress(&jpegInfo);
 	ligne = image;
 	while(jpegInfo.output_scanline < jpegInfo.output_height){
 		ligne = image +3*h*jpegInfo.output_scanline;
 		jpeg_read_scanlines(&jpegInfo, &ligne, 1);
 	}
 	jpeg_finish_decompress(&jpegInfo);
 	jpeg_destroy_decompress(&jpegInfo);
 
 	// On formate le tableau de sortie pour OpenGL
 	for(i=0; i<h; i++){
 		for(j=0;j<l;j++){
 			texture[i][j][0] = image[i*h*3+j*3];
 			texture[i][j][1] = image[i*h*3+j*3+1];
 			texture[i][j][2] = image[i*h*3+j*3+2];
 			//printf("textureR:%d\ntextureG:%d\ntextureB:%d\n",texture[i][j][0],texture[i][j][0],texture[i][j][0]);
 		}
 	}
	return(texture);
}

bon, jpense que c pas ca ...ouisque ca marche pas, mais si tu pourrais me corriger ca serai simpa (:

03/06/2006, 20h58
Pragmateek

Code:

unsigned char ***texture[l][h][3]

Cela déclare un tableau tridimensionnel contenant des pointeur de pointeur de pointeur sur "char".

Code:

unsigned char ***texture

suffit et après avec "malloc" la taille est déterminée.
03/06/2006, 21h23
Emmanuel Delahaye

Citation:

Envoyé par Funraill.net

voila j'ai une fonction qui doit retourner un tableau

C'est pas possible.
03/06/2006, 21h24
Emmanuel Delahaye

Citation:

Envoyé par Funraill.net

il n'est pas possible de retourné un tableau entier ??
car j'ai une autre fonction qui prend en parametre le tableau

Pas possible.
03/06/2006, 21h26
Emmanuel Delahaye

Citation:

Envoyé par seriousme

Pour renvoyer l'adresse d'un tableau valide il faut le déclarer dynamiquement ou avec le mot clé "static".

static ? :vomi:
03/06/2006, 21h27
Médinoc

Un truc qui déjà simplifierai, c'est un

Code:

typedef unsigned char PIXELRVB[3];

ça éliminerait avantageusement une dimension lors de certaines déclarations...
03/06/2006, 21h29
Emmanuel Delahaye

Citation:

Envoyé par Funraill.net

jsuis encore debutant en c...

Et tu veux déjà manipuler des tableaux dynamiques à 3 dimensions ? T'es pas un peu tombé sur la tête, là ?

Reprenons.

Le tableau dont tu as besoin as-t-il une taille connue à la compilation ou à l'exécution ?

Citation:

Envoyé par Funraill.net

Code:

1
2
3
4
5
6
 
unsigned char ***loadTexture(char *fichier, int l, int h){
 
	/**
         * Varriable Local */
 	unsigned char ***texture[l][h][3];

Il y a confusion ici.
De une, tu ne peux pas declarer un tableau de taille variable.
D'ailleurs ton compilateur a du te le signaler dans sa grande gentillesse.
Soit la taille est connue par avance, auquel cas tu le declares avec un taille constante, soit la taille est variable, auquel cas il faut allouer.

Et de toute facon, vu que ce tableau doit encore exister a la sortie de la fonction, tu es oblige de l'allouer.

Ensuite, tu as simplement besoin d'un tableau a 3 dimensions. Ici tu en a declare un a six dimensions. Ca fait un peu trop.

Code:

1
2
3
4
5
6
 
	texture = malloc(400 * sizeof(*texture));
	if(texture == NULL){
      printf("Erreur: Memoire insufisante !");
      //exit(1);
	}

Pourquoi 400 ? Ne serait-ce pas plutot h ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 	// On formate le tableau de sortie pour OpenGL
 	for(i=0; i<h; i++)
         {
 	    for(j=0;j<l;j++)
             {
 		texture[i][j][0] = image[i*h*3+j*3];
 		texture[i][j][1] = image[i*h*3+j*3+1];
 		texture[i][j][2] = image[i*h*3+j*3+2]; 		/*printf("textureR:%d\ntextureG:%d\ntextureB:%d\n",texture[i][j][0],texture[i][j][0],texture[i][j][0]);*/
 	     }
 	 } 
	return(texture);
}

La, non.

Tu n'as alloue que la premiere dimension du tableau.
Il faut allouer le reste.

Ca devrait ressembler a ca :

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
 
for(i=0; i<h; i++)
    {
      texture[i] = malloc(l * sizeof(*(texture[i])));
      if (texture[i] == NULL)
        {
          /*
          ** Traitement de l'erreur
          */
        }
      for(j=0;j<l;j++)
        {
          texture[i][j] = malloc(3 * sizeof(*(texture[i][j])));
          if (texture[i][j] == NULL)
            {
              /*
              ** Traitement de l'erreur
              */
            }
          texture[i][j][0] = image[i*h*3+j*3];
          texture[i][j][1] = image[i*h*3+j*3+1];
          texture[i][j][2] = image[i*h*3+j*3+2];
          /*       printf("textureR:%d\ntextureG:%d\ntextureB:%d\n",texture[i][j][0],texture[i][j][0],texture[i][j][0]); */
        }
    }

Et surtout on n'oublie pas de tout liberer apres.

03/06/2006, 22h09
Médinoc

Citation:

Envoyé par Emmanuel Delahaye

Et tu veux déjà manipuler des tableaux dynamiques à 3 dimensions ? T'es pas un peu tombé sur la tête, là ?

Euh, accuse-moi de dipterophilie si tu veux, mais je crois bien que seules deux des trois dimensions sont dynamiques...
Ce qui est déjà beaucoup pour un débutant, je te l'accorde.
05/06/2006, 16h52
shadowmoon

alors funraill.net pb résolu ou non ?