Discussion :

[.....1.....]

Salut,

Voilà plusieurs heures que je m'arrache les cheveux sur le problème suivant : impossible de passer un tableau de int en paramètre à une fonction. En fait, c'est très simple : je déclare un tableau dans main(), et je souhaite l'initialiser (taille et contenu) à partir d'une fonction saisieTableau(), mais rien à faire : que des erreurs à la compilation.

Malheureusement malgré mes recherches et mes lectures, je ne m'en sors pas...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
34
35
36
37
38
39
40
41
42
43
 
#include <stdio.h>
#include <stdlib.h>
 
void saisieTab(int tab[], int n)
{
	tab = malloc(8 * sizeof(int));
	int i = 0;
	int a = 5;
 
	for (n = 0; n != 3; n++)
	{
		tab[n] = a;
		a = a * 10;
	}
 
	for (i = 0; i != 3; i++)
	{
		printf("\nAff 1.5 : %d\n", tab[i]);
	}
}
 
 
int main()
{
	int n = 3;
	int *tab = malloc(1 * sizeof(int));
	int i = 0;
 
	for (i = 0; i != n; i++)
	{
		printf("\nAff 1 : %d\n", tab[i]);
	}
 
	saisieTab(tab, n);
 
	for (i = 0; i != n; i++)
	{
		printf("\nAff 2 : %d\n", tab[i]);
	}
 
	return 0;
}

Ce code va paraître absurde, car je le modifie depuis des heures pour essayer de comprendre le problème, à tel point que ça finit par ne ressembler à rien. Mais ma dernière idée était de pouvoir allouer dynamiquement la mémoire au tableau dans saisieTab(), puis de le remplir...mais une fois revenu dans le main(), il ne se passe rien.

Avec cette version, j'obtenais presque ce que je voulais (le contenu du tableau initial, tab, était bien modifié par saisieTab()) :

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
 
#include <stdio.h>
#include <stdlib.h>
 
void saisiTab(int tabss[3], int n)
{
	tabss[0] = 55;
	int i = 0;
	int a = 5;
 
	for (n = 0; n != 3; n++)
	{
		tabss[n] = a;
		a = a * 10;
	}
 
	for (i = 0; i != 2; i++)
	{
		printf("\nAff 1.5 : %d\n", tabss[i]);
	}
}
 
 
int main()
{
	int tab[] = {1,2,3};
	int i = 0;
	int n = 3;
 
	for (i = 0; i != 3; i++)
	{
		printf("\nAff 1 : %d\n", tab[i]);
	}
 
	saisiTab(tab, n);
 
	for (i = 0; i != 3; i++)
	{
		printf("\nAff 2 : %d\n", tab[i]);
	}
 
	return 0;
}

Malheureusement, le n - censé représenter la dimension du tableau - ne sert à rien, de plus la taille du tableau est fixe et déterminée par int tab[] = {1,2,3}; : or, ce n'est pas le but que je recherche...moi je veux demander à l'utilisateur de saisir un n et retrouver ensuite l'usage de ce n dans saisieTab() ==> j'ai donc pensé à demander la saisie de n directement dans la fonction, mais comme je l'explique pour mon premier code, le tab déclaré dans main() reste le même...

Merci d'avance pour votre aide'

[Médinoc]

Pourquoi ne pas faire simplement int* saisieTab(int n) ?

[abdennour bouaicha]

la taille du tableau doit etre fixe dans l'initialisation sinon on doit la changer par la fonction realloc,
voici un exemple de realloc

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
 
#include<stdio.h> 
main()
{
int i,p=1;
double*t=NULL;
//t=(double*)malloc(sizeof(double));
for(i=0;i<8;i++){
  t=realloc(t,p*sizeof(double));              
t[i]=i;
p++;
//printf("%lf\n",t[i]);
 
 
}
 
for(i=0;i<8;i++){
 
printf("%lf\n",t[i]);
 
 
}
 
getch();
}

[.....1.....]

Salut,

Merci pour vos réponses, mais elles ne m'ont pas aidé.

Médinoc : je pige pas...pourquoi je ferai ça ? Tu ne m'expliques rien...

abdennour bouaicha : idem, je viens d'essayer d'utiliser realloc() mais je pige mal le lien entre ton exemple et ce que je cherche à faire.

Après peut-être que c'est moi qui ne vois pas la subtilité dont vous essayez de me parler, mais quoiqu'il en soit sans plus d'explications vos réponses ne m'aident pas vraiment.

[foetus]

Merci pour vos réponses, mais elles ne m'ont pas aidé.

Médinoc : je pige pas...pourquoi je ferai ça ? Tu ne m'expliques rien...

Il faut relire les cours alors

Ce que te dis Médinoc c'est que c'est soit tu passes un double pointeur (int**, soit l'adresse d'un tableau) soit tu retournes un pointeur (int*)
Le truc, c'est que le passage de paramètres en C est par valeur (c'est le 2ième ou 3ième cours ) et si tu passes un pointeur simple, tu vas allouer une zone mémoire et stocker son adresse dans le paramètre local à la fonction.

Et approfondi tes cours aussi , parce que le type tableau pour 1 paramètre d'une fonction sous forme crochet n'existe pas : il est dégradé en pointeur, et donc tu perds la taille.

[Médinoc]

Médinoc : je pige pas...pourquoi je ferai ça ? Tu ne m'expliques rien...

Ben si ta fonction est censée créer le tableau, alors le plus simple est qu'elle le retourne:

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 * saisieTab(int n)
{
	int* tab = malloc(n * sizeof(int));
	int i = 0;
	int a = 5;
 
	for (i = 0; i < n; i++)
	{
		tab[i] = a;
		a = a * 10;
	}
 
	for (i = 0; i < n; i++)
	{
		printf("\nAff 1.5 : %d\n", tab[i]);
	}
	return tab;
}
 
int main()
{
	int n = 3;
	int *tab = saisieTab(n);
	int i = 0;
 
	for (i = 0; i < n; i++)
	{
		printf("\nAff 2 : %d\n", tab[i]);
	}
	return 0;
}

Après, si tu veux un tableau mais que la fonction le remplisse simplement, c'est aussi simple:

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
void saisieTab(int[] tab, int n)
{
	int i = 0;
	int a = 5;
 
	for (i = 0; i < n; i++)
	{
		tab[i] = a;
		a = a * 10;
	}
 
	for (i = 0; i < n; i++)
	{
		printf("\nAff 1.5 : %d\n", tab[i]);
	}
	return tab;
}
 
 
int main()
{
	int n = 3;
	int *tab = calloc(n, sizeof(int));
	int i = 0;
 
	for (i = 0; i < n; i++)
	{
		printf("\nAff 1 : %d\n", tab[i]);
	}
 
	saisieTab(tab, n);
 
	for (i = 0; i < n; i++)
	{
		printf("\nAff 2 : %d\n", tab[i]);
	}
 
	return 0;
}

L'important est de ne pas confondre n et i: n est le nombre d'éléments, i est l'index de l'élément courant.

[.....1.....]

foetus : c'est ce que j'ai fini par me dire après coup Mais je suis en pleine compréhension au niveau des pointeurs et des passages de paramètres, alors j'ai tendance à mélanger même si ça commence à rentrer.

Médinoc : merci, c'est bien plus clair comme ça Mais en fait j'avais déjà essayé de retourner le tableau...je n'ai pas obtenu le résultat escompté. Après comparaison avec ce que j'avais fait encore avant, j'ai effectivement mélangé mes paramètres, mes déclarations...tout quoi.

Bref, je vais bien finir par assimiler correctement toutes ces notions ^^

Merci beaucoup pour votre aide'

[Bktero]

Avant de s'attaquer à des tableaux à modifier dans une fonction, as-tu déjà bien compris comment modifier une variable à l'intérieur d'une fonction ?

Par exemple, tu peux faire ça :

Code :

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

1
2
3
4
5
6
7
int doubler(int value) {
	return value * 2;
}
 
int a = 2;
a = doubler(a);
assert(a == 4);

Si maintenant, tu ne veux pas passer par la valeur de retour mais bien modifier directement la variable passée en paramètre, comment ferais-tu ? Comment complèterais-tu le code suivant ?

Code :

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

1
2
3
4
5
6
7
void doubler(?type? value) {
	// ???
}
 
int a = 2;
doubler(?? a);
assert(a == 4);

[Sve@r]

Bonjour

Voilà plusieurs heures que je m'arrache les cheveux sur le problème suivant : impossible de passer un tableau de int en paramètre à une fonction. En fait, c'est très simple : je déclare un tableau dans main(), et je souhaite l'initialiser (taille et contenu) à partir d'une fonction saisieTableau(), mais rien à faire : que des erreurs à la compilation.
Malheureusement malgré mes recherches et mes lectures, je ne m'en sors pas...voici le code :

Le souci principal est que tu ne souhaites non pas simplement passer le tableau à une fonction pour qu'elle l'utilise (ou qu'elle modifie juste son contenu) mais tu veux lui passer le tableau pour qu'elle modifie aussi sa nature (tableau de par exemple 10 int devenant un tableau de 15 int). Et ça c'est assez drastique

Déjà comme l'explique Bktero, une fonction ne peut absolument pas modifier une variable reçue car elle n'en reçoit qu'une copie. En revanche ce qu'on peut faire (et d'ailleurs ce qu'on fait) c'est lui passer l'adresse de la variable à modifier. Là c'est comme le reste la fonction reçoit une copie de cette adresse mais comme la mémoire d'un programme est "unique" (ou "globale"), en ayant l'adresse (même une copie) la fonction peut aller taper dedans ce qui modifie alors la variable associée à cette adresse par ricochet. C'est le principe de scanf().

Le second souci c'est qu'un tableau c'est un truc déjà formaté. Un tableau de 10 int restera définitivement un tableau de 10 int. Quoi que tu fasses, tu ne pourras jamais le transformer en un tableau de 15 int. La seule façon d'avoir quelque chose se comportant comme un tableau de taille variable est d'utiliser l'allocation dynamique malloc() et realloc().

Donc partant de là, il n'y a que très peu de possibilités et toutes se baseront sur l'allocation dynamique. La seule différence que tu pourras avoir sera

• une fonction qui alloue ce qu'il faut (malloc) et qui retourne le pointeur alloué => dans ce cas elle n'a pas besoin de recevoir quoi que ce soit (hormis peut-être le nombre d'éléments) puisqu'elle travaille en indépendant et retourne le résultat de ce travail. C'est l'exemple de Médinoc
• une fonction qui reçoit un pointeur à allouer (ou à réallouer) et qu'elle va alors modifier. Mais là on retombe sur le premier souci à savoir qu'une fonction ne peut modifier une variable qui lui est extérieure que si elle reçoit l'adresse de cette variable. Si elle doit modifier un int elle reçoit l'adresse de cet int qu'elle stocke dans un "int étoile". Si elle doit modifier un double elle reçoit l'adresse de ce double qu'elle stocke dans un "double étoile". Et si elle doit modifier un truc qui est déjà un pointeur sur un tableau d'int (donc un truc déjà int étoile) ben la règle reste la même: elle doit recevoir l'adresse de cet int étoile qu'elle stockera dans un "int étoile étoile"

Ou alors tu abandonnes l'idée de modifier la nature du tableau. Tu pars du principe que tu as un tableau connu dès le départ (donc par exemple 10 int) et ta fonction se contente juste d'initialiser son contenu. Là on retombe dans le classique. D'autant plus qu'avec les macrodéfinitions tu peux très bien centraliser la taille (tu ne l'écris qu'une fois dans la macro puis ensuite tu utilises la macro dans tout le reste du code => si demain tu veux changer et la passer de 10 à 20 tu ne la changes qu'une fois et tu recompiles).

[.....1.....]

Salut !

Encore une fois, merci pour toutes ces informations. Et désolé pour mon délai de réponse mais je ne m'attendais pas à avoir d'autres réponses

J'ai bien compris la majorité de ce que vous dites, mais mon problème venait je pense d'une subtilité que je n'avais manifestement pas saisie, et elle doit l'être maintenant. D'ailleurs @Bktero voici ton code complété. On verra ainsi si j'ai vraiment compris :

Code :

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

1
2
3
4
5
6
7
void doubler(int * value) {
	*value = 4;
}
 
int a = 2;
doubler(&a);
assert(a == 4);

[Sve@r]

D'ailleurs @Bktero voici ton code complété. On verra ainsi si j'ai vraiment compris :

Bien compris le principe du pointeur mais pas le sens du verbe "doubler"

Code :

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

1
2
3
4
5
6
7
void doubler(int * value) {
	*value = (*value) * 2;
}
 
int a = 8;
doubler(&a);
assert(a == 16);

Heureusement c'est le pointeur le plus important

Et si maintenant on applique ça à une fonction qui alloue par exemple 10 caractères à un pointeur reçu

Code :

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

1
2
3
4
5
6
void alloc(char **pt) {
	*pt=malloc(10);
}
 
char *tab;
alloc(&tab);

Par opposition au premier exemple de Médinoc (sans porter de jugement de valeur, chaque solution aura ses avantages et ses inconvénients)

Code :

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

1
2
3
4
5
6
7
8
char *alloc() {
	char *pt
	pt=malloc(10);
	return pt;			// Ou return malloc(10) pour faire plus simple
}
 
char *tab;
tab=alloc();

[.....1.....]

Ah mince en effet j'ai pas fait attention au sens de "doubler" ^^ J'ai juste vu que a = 4 et je l'ai donc modifié en conséquence.

Ça marche, c'est bien noté.

Alors là j'utilise en effet malloc() pour mes tableaux. Sauf qu'en terme de sécurité, il est recommandé d'utiliser free() puis de réinitialiser le pointeur concerné à NULL. Mais si on prend le cas suivant :

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
int * saisieTab(int n)
{
	int* tab = malloc(n * sizeof(int));
 
	//On modifie le tableau...
 
	return tab;
}
 
int main()
{
	int *tableau = malloc(1 * sizeof(int));
	int n = 5;
 
	saisieTab(tableau, n);
 
	//tableau est maintenant modifié...
}

Je ne vois pas où placer free(tab) et tab = NULL...dans le main() ? Donc en faisant free(tableau) et tableau = NULL ? Car si je le fais dans saisieTab(), il est clair que le return ne servira pas à grand-chose... Ou dois-je implémenter différemment la modification du tableau ?

[Bktero]

Bon, on va dire que "doubler", c'était difficile et le pointeur, c'était facile

Tu as là un principe super un important, tu veux modifier un TRUC, tu passes un pointeur sur ce TRUC. Pour un int, tu passes un int*. Pour un int* (presque un tableau, mais on ne peut pas passer un vrai tableau à une fonction (1)), on passe un int**. Dans le premier cas, TRUC est int et dans le deuxième TRUC est int*.

L'autre possibilité, c'était ma première version de doubler() et c'est ce que tu as fait : ta fonction crée le TRUC et le renvoie. Si TRUC est un int, tu n'as rien de spécial à faire quand tu n'en as plus besoin. Si TRUC est un int* obtenu par le résultat de malloc() (ça marche aussi avec calloc() bien sûr), alors tu as quelque chose à faire : appeler FREE. Quand faire ça ? Quand tu n'as plus besoin de ton int*. Dans ton cas, ça semble être la fin du main(), après ce qui va à la place du commentaire. Mettre le pointeur à NULL n'est pas obligatoire. C'est juste une bonne pratique qu'un pointeur pointe toujours sur quelque chose de valide (et une zone libérée avec free() n'est plus valide) ou NULL. Ca evite justement d'accéder à une zone invalide : il suffit de tester le pointeur contre NULL pour savoir si on peut accéder à ce qui est pointé ou pas.

[Sve@r]

Je ne vois pas où placer free(tab) et tab = NULL...dans le main() ?

Quand tu n'en as plus besoin (donc ici dans le main()). En revanche, le main ne doit pas faire de malloc puisque c'est saisieTab qui s'en charge !!!

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main()
{
	int *tableau;
	int n = 5;
 
	tableau=saisieTab(n);
 
	//tableau est maintenant modifié...
	...
 
	//je n'en ai maintenant plus besoin
	free(tableau);
	tableau=NULL;		// si tu veux (perso je ne remplis jamais une variable si je ne compte pas la lire plus tard mais certains arguments de Bktero sont intéressants)
}

Ce qu'il faut bien comprendre, c'est que tu as beau avoir tout ton code découpé en plusieurs fonctions, tu n'as quand-même qu'une seule grosse zone mémoire unique. Donc t'as parfaitement le droit de l'ouvrir d'un côté et la refermer de l'autre...

[.....1.....]

Ah ah, oui, enfin le truc c'est que je me suis surtout focalisé le pointeur et non sur "doubler"

Merci beaucoup, maintenant j'ai de quoi faire et j'ai pas mal éclairci ma lanterne grâce à vous

PS : pour le double malloc() c'est une bête erreur de recopie de ma part ^^