Discussion :

[lepetitdeveloppeur]

Bonjour à tous,
ça va faire une bonne semaine que je me casse la tête sur un projet pour l'école, je dois envoyer 3 tableaux en paramètre à une fonction et retourner un tableau mais je suis complètement bloqué... Ce code ci-dessous ne fait pas partie de mon projet mais si je sais envoyer 1 tableau et en récupérer 1, je saurai en envoyer 3. Bref ce code devrait m'afficher :
0
1
2
...
9


mais à la place j'ai ceci :
0
-858993460
-858993460
-858993460
....

voici le code :

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
#include <cv.h>
#include <highgui.h>
#include <time.h>
#include <stdio.h>
 
int initialiser_tab(int * ptr, size_t n_elements)
{
    size_t i;
 
    for(i = 0; i < n_elements; i++)
	{
        ptr[i] = (int)i;
	}
	return *ptr;
}
 
int main(void)
{
    int t[10];
	int result[10];
 
    size_t i, n_elements = sizeof(t) / sizeof(t[0]);
 
    *result = initialiser_tab(t, n_elements);
 
    for(i = 0; i < n_elements; i++)
	{
		printf("%d\n", result[i]);
	}
 
    system("PAUSE");
    return 0;
}

Je sais que d'autres méthodes existent pour en arriver à ce résultat mais j'ai absolument besoin de retourner un tableau pour la suite car ceci n'est qu'un bête bout de code je ne l'utiliserai même pas car si je peux retourner un tableau je saurai finir mon projet.

D'avance merci pour vos avis, réactions, conseils.

PS : je sais qu'il est impossible d'envoyer ou de retourner un tableau mais cela se fait par le pointeur qui pointe vers le 1er élément de ce tableau. Mais bon je suis quand même un peu perdu. Et ne faites pas attentions aux includes c'est pour mon projet.

[jeroman]

Salut

Dans ton code, tu remplis un tableau mais tu affiches le contenu du second, qui n'a pas été initialisé, donc ça affiche effectivement n'importe quoi. Seul le premier élément du second tableau a été initialisé... avec la valeur du premier élément du premier tableau. Le code n'est pas cohérent.

Par contre il faudrait expliquer plus précisément :

je dois envoyer 3 tableaux en paramètre à une fonction et retourner un tableau

car c'est pas clair du tout.
Que doivent contenir les trois tableaux et celui renvoyé ? (en C on ne peut pas renvoyer de tableau mais un pointeur)
Quel rapport entre les trois tableaux et celui renvoyé ? La fonction est censée faire quoi ?

[lepetitdeveloppeur]

Je viens de remarquer que j'ai fais une petite erreur dans mon code précédent, ce n'est pas exactement ce que je souhaite. Pour plus de précisions sur ma fonction finale, je dois faire quelque chose qui ressemble à ça :

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 traitement(int * ptr1, int * ptr2, int * ptr3, size_t nbr_elem)
{
     size_t = j;
     int resultat[nbr_elem];
 
     for(j = 0; j<nbr_elem; j++)
     {
          resultat[j] = ptr1[j] + ptr2[j] + ptr3[j];
     }
     return *resultat;
}
 
int main(void)
{
     int t1[10];
     int t2[10];   // ces tableaux seront déjà rempli
     int t3[10];
 
     int resultat_final[10];
 
    size_t i, n_elements = sizeof(t1) / sizeof(t1[0]);
 
    *resultat_final = traitement(t1,t2,t3, n_elements);
 
    for(i = 0; i < n_elements; i++)
	{
		printf("%d\n", resultat_final[i]);
	}
 
}

Je suis vraiment désolé pour le manque de précision du précédent message mais hier soir après la sale journée que je me suis tapé j'ai presque du me forcer à poster mais bon que je suis à la bourre donc l'un dans l'autre je suis dos au mur la

[diogene]

Je viens de remarquer que j'ai fais une petite erreur dans mon code précédent, ce n'est pas exactement ce que je souhaite. Pour plus de précisions sur ma fonction finale, je dois faire quelque chose qui ressemble à ça :

.....

Je suis vraiment désolé pour le manque de précision du précédent message mais hier soir après la sale journée que je me suis tapé j'ai presque du me forcer à poster mais bon que je suis à la bourre donc l'un dans l'autre je suis dos au mur la

Tu connais ton problème, mais nous pas du tout.
Tu devrais décrire précisément ce que tu veux faire : "faire quelque chose qui ressemble à ça" n'est pas suffisant pour obtenir des réponses pertinentes.
Tu perds du temps (et apparemment tu n'en as pas de trop) et tu en fais perdre aux autres qui essayent de deviner ce que tu veux faire.

[Fabllot]

Bonjour,

D'abord la fonction :

Code :

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

1
2
 
int traitement(int * ptr1, int * ptr2, int * ptr3, size_t nbr_elem)

Plusieurs choses :
1. Quand on doit retourner un tableau, retourner un "int" est plutôt maladroit. Deux solutions plus propres sont : retourner un pointeur vers le tableau instancié dynamiquement, ou remplir un tableau résultat passé en paramètre (et initialisé correctement au prélable)
Donc voici les signatures des deux fonctions possibles:

Code :

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

1
2
3
4
5
 
// Résultat dans le retour de la fonction
int* traitement(int * ptr1, int * ptr2, int * ptr3, size_t nbr_elem);
// Résultat dans le pointeur "result" des paramètres
void traitement(int * ptr1, int * ptr2, int * ptr3, size_t nbr_elem, int* result);

2. Ce que tu retournes pose problème :

Code :

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

1
2
3
4
5
6
7
 
int traitement(int * ptr1, int * ptr2, int * ptr3, size_t nbr_elem) {
   // [...]
   int resultat[nbr_elem];
   // [...]
   return *resultat;
}

Dans ton cas tu retournes un variable locale... Donc une fois sortie de la fonction, la variable n'existe plus...

Enfin dans ton main :

Code :

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

1
2
3
int resultat_final[10];
// [...]
*resultat_final = addition(t1,t2,t3, n_elements);

La dernière ligne signifie que tu écris le retour de la fonction addition (ie. ici en entier) à l'endroit pointé par resultat_final, ou autrement dit tu ne modifies que resultat_final[0]...

[lepetitdeveloppeur]

Tu connais ton problème, mais nous pas du tout.
Tu devrais décrire précisément ce que tu veux faire : "faire quelque chose qui ressemble à ça" n'est pas suffisant pour obtenir des réponses pertinentes.
Tu perds du temps (et apparemment tu n'en as pas de trop) et tu en fais perdre aux autres qui essayent de deviner ce que tu veux faire.

En fait le problème réside dans le return du tableau, le traitement de la fonction importe peu je n'aurai aucun mal à l'adapter.

Mais si vous voulez encore plus de précisions, je récupère les valeurs (RVB en int) d'une image que je stock dans 3 tableaux à 1 dimension.
Je souhaite envoyer ces 3 tableaux à une fonction imgnvg pour les traiter et transformer l'image en niveau de gris (donc en gros gris = (rouge+vert+bleu) /3). J'ai donc besoin de renvoyer ce tableau contenant les int pour l'image en niveau de gris.

PS : j'ai absolument besoin d'utiliser cette méthode .

[jeroman]

2. Ce que tu retournes pose problème :

Code :

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

1
2
3
4
5
6
7
 
int traitement(int * ptr1, int * ptr2, int * ptr3, size_t nbr_elem) {
   // [...]
   int resultat[nbr_elem];
   // [...]
   return *resultat;
}

Dans ton cas tu retournes un variable locale... Donc une fois sortie de la fonction, la variable n'existe plus...

Non, là la fonction renvoie la valeur du premier élément du tableau (un entier). Par contre, si la fonction renvoyait l'adresse du premier élément du tableau, ça poserait effectivement un gros soucis (vu qu'il s'agit d'un tableau local non statique).

Le vrai soucis ici c'est que la fonction renvoie la valeur du premier élément, ce qui n'a pas de sens pour cette fonction-là.

[jeroman]

Mais si vous voulez encore plus de précisions, je récupère les valeurs (RVB en int) d'une image que je stock dans 3 tableaux à 1 dimension.
Je souhaite envoyer ces 3 tableaux à une fonction imgnvg pour les traiter et transformer l'image en niveau de gris (donc en gros gris = (rouge+vert+bleu) /3). J'ai donc besoin de renvoyer ce tableau contenant les int pour l'image en niveau de gris.PS : j'ai absolument besoin d'utiliser cette méthode .

Il suffit de créer, dans la fonction, un tableau dynamique, de le remplir, puis de renvoyer 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
15
16
17
18
19
20
21
22
23
24
25
26
int * cree_tableau_niveau_gris(int * tableau_composante_rouge , int * tableau_composante_verte , int * tableau_composante_bleue , size_t nombre_pixels)
{
	int * tableau_niveau_gris = malloc(nombre_pixels * sizeof *tableau_niveau_gris);
	if (tableau_niveau_gris != NULL)
	{
		/* remplissage tableau */
	}
	return tableau_niveau_gris;
}
 
... fonction_quelconque(...)
{
	int * tableau_niveau_gris;
 
	/* tableau_composante_rouge , tableau_composante_verte , tableau_composante_bleue sont des tableaux (dynamiques de préférence), chacun composés de 'nombre_pixels' éléments */
 
	...
 
	tableau_niveau_gris = cree_tableau_niveau_gris(tableau_composante_rouge , tableau_composante_verte , tableau_composante_bleue , nombre_pixels);
	if (tableau_niveau_gris != NULL )
	{
		...
	}
 
	...
}

N'oublie pas de libérer la mémoire avec free lorsque tu n'as plus besoin de ton tableau de niveau de gris, ainsi que les autres s'ils sont également dynamiques.

donc en gros gris = (rouge+vert+bleu) /3

On utilise généralement cette équation :

Y = R * 0,299 + G * 0,587 + B * 0,114

[lepetitdeveloppeur]

Je vous remercie TOUS pour vos réponses, je vais essayer ça ce soir en rentrant.

Et encore merci pour la formule j'utilise celle la dans mon programme final mais je voulais (encore) simplifier le bazar

[lepetitdeveloppeur]

Désolé pour le retard, j'ai eu quelques imprévus, voici ce que je retire des commentaires postés :

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
 
#include <stdio.h>
 
int * traitement(int * rouge, int * vert, int * bleu, size_t nbr)
{
 
   int * gris = malloc(nbr * sizeof * gris);
 
	if(gris != NULL)
	{
		int j =0;
		for(j; j < nbr ; j++)
                {
			gris[j] = rouge[j] + bleu[j] + vert[j];
                }
	}
 
	return gris;
}
 
int main(void)
{
	int pixel_rouge[10] = {0};
	int pixel_vert[10] = {0};
	int pixel_bleu[10] = {0};
 
	size_t nbr_pixel = 10 * sizeof(int) ;
 
	int * pixel_gris = malloc(nbr_pixel);
 
        int i = 0;
	for( i; i < 10 ; i++)
	{
		pixel_rouge[i] = i;
		pixel_vert[i] = i;
		pixel_bleu[i] = i;
	}
 
        pixel_gris = traitement(pixel_rouge,pixel_vert,pixel_bleu,10);
 
	if(pixel_gris != NULL)
	{
		int ii = 0;
		for(ii; ii < 10; ii++)
		{
			printf("%d\n",pixel_gris[ii]);
		}
    }
 
    free(pixel_gris);
    system("PAUSE");
    return 0;
}

Voici ce qu'il me ressort :
0
3
6
9
12
15
18
21
24
27

Merci à tous ce code fonctionne parfaitement

Est-ce vous pouvez quand même y jeter un œil histoire de voir si je ne vais pas surcharger la mémoire (l'allocation du tableau dans la fonction me fait un peu peur en fait parce que je ne vois pas comment la désallouer car je dois absolument créer le tableau dans la fonction)

[diogene]

A part

Code :

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

size_t nbr_pixel = 10 * sizeof(int) ;

Pourquoi multiplier par sizeof(int) ?

l'allocation du tableau dans la fonction me fait un peu peur en fait parce que je ne vois pas comment la désallouer car je dois absolument créer le tableau dans la fonction

Comme tu as fait. C'est une contrainte de cette fonction : le programme appelant la fonction est en charge de faire la désallocation.

[jeroman]

Salut

Pour rester cohérent, je te propose de créer les 3 premiers tableaux de manière dynamique également. Car tu as 3 tableaux sur la pile, et un créé sur le tas, tous les 4 ayant la même taille. Ce serait plus cohérent d'en créer 4 dynamiquement. D'autant que -je suppose- ton programme final devra calculer bien plus que 10 pixels ; cela évitera donc le plantage assuré en cas de débordement de la pile.

Mais cela dépend de ce que l'énoncé de l'exo te permet ou non de faire. Je ne sais pas s'il y a des contraintes particulières.

Les codes tels que

Code :

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

1
2
int j =0;
for(j; j < nbr ; j++)

peuvent être remplacés par :

Code :

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

1
2
int j;
for(j = 0 ; j < nbr ; j++)

ou

Code :

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

1
2
int j =0;
for( ; j < nbr ; j++)

car l'expression en rouge n'a aucun effet ; le compilateur risque de mettre un avertissement, même si ici il n'y a rien de grave.

La partie

Code :

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

1
2
size_t nbr_pixel = 10 * sizeof(int) ;
 int * pixel_gris = malloc(nbr_pixel);

a deux problèmes :
1) elle risque d'entrainer une confusion : ici "nbr_pixel" ne correspond pas au nombre de pixels mais à la taille de la mémoire à allouer.
2) elle provoque une fuite de mémoire. En effet, le 4ème tableau est alloué par la fonction "traitement" :

Code :

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

1
2
3
int * pixel_gris = malloc(nbr_pixel);
...
pixel_gris = traitement(pixel_rouge,pixel_vert,pixel_bleu,10);

Au niveau structure du programme, je te conseillerais de bien découper chaque tâche en une fonction spécifique. Exemple (à modifier si besoin) :

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
/* La fonction créé un tableau dynamique niveau de gris, et le remplit */
/* La fonction renvoie l'adresse du tableau dynamique */
int * traitement(int * rouge, int * vert, int * bleu, size_t nbr)
{
...
}
 
/* La fonction lit le fichier, créé 3 tableaux dynamiques (un par canal : RGB) et les remplit */
/* La fonction renvoie 1 en cas de réussite, 0 sinon */
/* Si la fonction echoue alors qu'elle a alloué quelque chose, elle doit "free" elle-même, et les pointeurs pointés par les 3 premiers pointeurs (dans les arguments) doivent être mis (ou rester) à NULL */
int lecture_fichier_remplissage_RGB( char const * const nom_fichier , int ** pixel_rouge , int ** pixel_vert , int ** pixel_bleu , size_t * nbr_pixels)
{
...
}
 
int main(void)
{
	int * pixel_rouge = NULL;
	int * pixel_vert = NULL;
	int * pixel_bleu = NULL;
	int * pixel_gris = NULL;
	size_t nbr_pixels = 0;
 
	char nom_fichier[]=".............";
 
	if (lecture_fichier_remplissage_RGB(nom_fichier , &pixel_rouge , &pixel_vert , &pixel_bleu , &nbr_pixels))
	{
		pixel_gris = traitement(pixel_rouge , pixel_vert , pixel_bleu , nbr_pixels);
		if ( pixel_gris != NULL )
		{
			... en cas d' autres traitement à faire / affichage ...
			free(pixel_gris);
			pixel_gris = NULL;
		}
		free(pixel_rouge);
		free(pixel_vert);
		free(pixel_bleu);
 
		pixel_rouge = pixel_vert = pixel_bleu = NULL;
	}
 
	/* ici, tous les tableaux ont été desalloués... */
 
	...
 
	return .... ;
}