Discussion :

[Dunkhan]

Bonjour,


Je reviens vers vous avec une question sur les paramètres à envoyé a une fonction pour la création dynamique d'un tableau a 2 dimensions.

Je comprend lorsque je veux passer le paramètre d'un tableau a une dimension..
Pour un tableau a une dimension

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
 
int main(int argc, char *argv[])
{
 
	int *ptTab = NULL;
	size_t dTailleTab = 10;
 
	Fct_creationTab(&ptTab, dTailleTab);
 
 
}
 
 
void Fct_creationTab(int **pptTab, size_t dTailleTab)
{
 
	*pptTab = malloc(dTailleTab * sizeof(int));
 
	for (i = 0; i < dTailleTab; i++)
	{
		(*pptTab)[i] = 1 + i;
	}
 
}

Je comprend aussi le code pour faire un tableau à 2 dimensions directement dans le main

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
54
55
56
57
58
59
60
61
62
 
int main(int argc, char *argv[])
{
 
	// =======================================================================================================
	// VARIABLE(S) LOCALE
	// =======================================================================================================
	int **tDamier = NULL;
	size_t size_Damier = 10;
	int i, j;
 
 
	// =======================================================================================================
	// CODE MAIN
	// =======================================================================================================
 
	printf("Entrer la taille du damier de jeux : ");
	scanf("%d", &size_Damier);
 
 
 
	tDamier = malloc(size_Damier * sizeof(int));
	if (tDamier == NULL)
	{
		printf("Echec de l'allocation\n");
		return EXIT_FAILURE;
	}
 
	for (i = 0; i < size_Damier; i++)
	{
		tDamier[i] = malloc(size_Damier * sizeof(int));
		if (tDamier[i] == NULL)
		{
			printf("Echec de l'allocation\n");
 
			for (i = 0; i >= 0; i--)
			{
				free(tDamier[i]);
			}
			free(tDamier);
 
			return EXIT_FAILURE;
		}
	}
 
	for (i = 0; i < size_Damier; i++)
	{
		for (j = 0; j < size_Damier; j++)
		{
			tDamier[i][j] = j + 1;
			printf("tDamier[%d][%d] = %d\n",i, j, tDamier[i][j]);
		}
	}
 
 
	for (i = 0; i >= 0; i--)
	{
		free(tDamier[i]);
	}
	free(tDamier);
	return 0;
}

mais je bloque complètement sur le comment faire pour un tableau a 2 dimensions..
Je m'y perd dans mes pointeurs, le nombre d’étoiles que je dois utiliser.. brefs..
J'ai beau lire les pdf du cours, ou les tutos que je trouve ici ou ailleurs.. je ne trouve pas vraiment de réponses a mes questions..



Edit:

Un ami vient de me passer comment faire un return de l'adresse du tableau une fois crée dans la fonction dans une fonction int **

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
int ** creerTableau (int *pLongueurDamier, int *pLargeurDamier)
{
    int i, j;
    int **pDamier = NULL;
 
    printf("Longueur (max 26) et largeur de la carte (ex : 15 10) : ");
    scanf("%d %d", pLongueurDamier, pLargeurDamier);
 
    pDamier = malloc(*pLongueurDamier * sizeof(int *));
 
    for(i = 0 ; i < *pLongueurDamier ; i++)
    {
        pDamier[i] = malloc(*pLargeurDamier * sizeof(int));
    }
 
    for(i = 0 ; i < *pLongueurDamier ; i++)
    {
        for(j = 0 ; j < *pLargeurDamier ; j++)
        {
            pDamier[i][j] = 0;
        }
    }
 
    return pDamier;
}

Mais je me pose quand même la question de savoir comment faire pour le faire directement avec des pointeurs et si c'est possible, voir même conseillé??



Merci d'avance

[Matt_Houston]

Le passage de paramètres aux fonctions se faisant par valeur (ou « copie »), il te faut toujours une indirection supplémentaire pour modifier la valeur du paramètre.

Pour modifier un int, tu dois passer un int *.
Pour modifier un int *, tu dois passer un int **.
Pour modifier un int **, tu dois passer un int ***.

Alternativement tu peux aussi affecter à ta variable la valeur de retour de ta fonction comme tu l'as proposé avec creerTableau.

Une remarque sur la conception de cette dernière : ne lui impose pas tant de responsabilités, à savoir récupérer le résultat de la saisie des dimensions du tableau et l'initialiser. La récupération et la validation de données sont des opérations délicates : isole-les des traitements internes.

[Sve@r]

Je m'y perd dans mes pointeurs, le nombre d’étoiles que je dois utiliser.. brefs..

Bonjour
La première chose qu'il te faut comprendre, c'est que créer un tableau 2D en allocations dynamiques ne te donne pas un carré mais plutôt un tableau de tableaux. Si par exemple tu génères un tableau de 2 lignes et 3 cases par lignes ben peut-être que les 3 premières cases seront aux adresses 100, 101 et 102 mais peut-être que les 3 suivantes seront aux adresses 8700, 8701 et 8702.
Toutefois le mécanismes d'adressage avec les crochets te donne l'illusion que c'est un carré.

Sinon pour le reste, il te faut procéder étape par étape.
Prenons exemple d'un tableau à 3 dimensions de "ints" sous la forme 3x4x5. Tout d'abord, tu définis la base du tableau. Et 3D te donneront 3 étoiles. Donc int ***tab. Idem 4D te donneront 4 étoiles et etc. Toutefois généralement au-delà de 3D on a du mal à se représenter le résultat.

Ensuite, la première dimension t'indique que tu as 3 éléments. Mais 3 éléments de quoi ? Ben de tableaux 2D puisque chaque dimension gère "n" dimensions précédentes.
Donc tu alloues ainsi: tab=malloc(3 * sizeof (int **)). Ainsi, à la case "tab" (par exemple à l'adresse 100) tu as maintenant la place pour y ranger 3 pointeurs 2D.

Ensuite, chaque pointeur 2D va devoir stocker 4 tableaux 1D. Donc tu initie une boucle de 0 à 3 et pour chaque tab[i] tu alloues l'espace pour tes 4 pointeurs 1D

Code c :

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

1
2
for (i=0; i < 3; i++)
	tab[i]=malloc(4 * sizeof(int*))

Et maintenant, chaque pointeur 1D va devoir stocker 5 ints. Donc tu rajoutes une seconde boucle

Code c :

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

1
2
3
4
5
for (i=0; i < 3; i++) {
	tab[i]=malloc(4 * sizeof(int*))
	for (j=0; j < 4; j++)
		tab[i][j]=malloc(5 * sizeof(int))
}

A partir de là, tu peux taper dans tab[i][j][k] sans souci. Et quel que soit l'agencement interne de ta mémoire, chaque index [] te placera sur le bon pointeur puis le bon suivant et etc jusqu'à la case finale.

Sinon il y a une autre possibilité: partir dans tous les cas sur un tableau 1D puisque de toute façon, que ce soit 60 ints épars ou 60 ints en lignes, ça reste 60 ints que tu peux manipuler. Exemple int *tab=malloc(3*4*5*sizeof(int)).
Ensuite te suffit de convertir le tab[i][j][k] de ton algo en tab[x] de ta zone via la formule x=i*4*5+j*5+k (tu remarqueras que la première dimension "3" n'est pas utilisée)

Un ami vient de me passer comment faire un return de l'adresse du tableau une fois crée dans la fonction dans une fonction int **

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
int ** creerTableau (int *pLongueurDamier, int *pLargeurDamier)
{
    int i, j;
    int **pDamier = NULL;
 
    printf("Longueur (max 26) et largeur de la carte (ex : 15 10) : ");
    scanf("%d %d", pLongueurDamier, pLargeurDamier);
 
    pDamier = malloc(*pLongueurDamier * sizeof(int *));
 
    for(i = 0 ; i < *pLongueurDamier ; i++)
    {
        pDamier[i] = malloc(*pLargeurDamier * sizeof(int));
    }
 
    for(i = 0 ; i < *pLongueurDamier ; i++)
    {
        for(j = 0 ; j < *pLargeurDamier ; j++)
        {
            pDamier[i][j] = 0;
        }
    }
 
    return pDamier;
}

Mais je me pose quand même la question de savoir comment faire pour le faire directement avec des pointeurs et si c'est possible, voir même conseillé??

Je ne comprends pas trop "directement avec les pointeurs". Que ce soit dans le main() ou dans une fonction qui renvoie le tableau, ça reste des pointeurs. Quant au "conseillé" ben ça ne dépend que de toi. Toutefois il te faut quand-même prendre l'habitude de toujours vérifier tes malloc et prévoir un traitement de nettoyage si un malloc échoue. Parce que dans ce cas, il te faut libérer tout ce qui a été alloué. Et donc si tu délègues la génération à une fonction tu seras plus à l'aise pour gérer les erreurs d'allocation. Personnellement pour ça je préconise le très décrié "goto" (il n'y a pas de mauvais outils, seulement de mauvaises façon de s'en servir).

Exemple d'allocation 3D avec nettoyage

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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
int ***tab;
int i,j;
 
tab=malloc(3 * sizeof(int **));
if (tab == NULL)
	goto nettoyage;
 
for (i=0; i < 3; i++)
	tab[i]=NULL;
 
for (i=0; i < 3; i++) {
	tab[i]=malloc(4 * sizeof(int *));
	if (tab[i] == NULL)
		goto nettoyage;
	for (j=0; j < 4; j++)
		tab[i][j]=NULL;
 
	for (j=0; j < 4; j++) {
		tab[i][j]=malloc(5 * sizeof(int));
		if (tab[i][j] == NULL)
			goto nettoyage;
	}
}
 
... (utilisation du tableau alloué)...
 
nettoyage:
if (tab != NULL) {
	for (i=0; i < 3; i++) {
		if (tab[i] != NULL) {
			for (j=0; j < 4; j++)
				if (tab[i][j] != NULL)
					free(tab[i][j]);
		}
		free(tab[i]);
	}
	free(tab);
}

Toute l'astuce de ce code est de commencer par initialiser chaque pointeur du tableau qui le contient à NULL. Ainsi, si une allocation échoue, je pars directement au code de nettoyage qui passera tout le tableau mais ne traitera que les pointeurs réellement allouées.
Et si tout se passe bien, ben une fois le tableau exploité le code passe quand-même en final par la même phase de nettoyage qui libère tout le tableau dans l'ordre inverse de ses dimensions.

PS: alter-ego possible (pour ceux qui n'aiment pas les décalages de blocs lors de ces tests en cascade)

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
nettoyage:
if (tab != NULL) {
	for (i=0; i < 3; i++) {
		if (tab[i] == NULL) continue;
		for (j=0; j < 4; j++)
			if (tab[i][j] == NULL) continue;
			free(tab[i][j]);
		}
		free(tab[i]);
	}
	free(tab);
}

[Dunkhan]

Merci à vous deux pour les éclaircissement

Je comprend un peu mieux comment m'y retrouver.


Ce que je voulais dire par "directement avec des pointeurs", c'est lors du passage des paramètres à l'appel de la fonction dans laquelle je vais créer les tableaux.

Pour reprendre le premier exemple que je cite, je sais comment faire pour passer directement l'adresse du tableau a une dimension que j'ai déclaré dans le main()

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
 
int main(int argc, char *argv[])
{
 
	int *ptTab = NULL;
	size_t dTailleTab = 10;
 
	fct_CreationTab(&ptTab, dTailleTab);
 
 
}
 
 
void fct_CreationTab(int **pptTab, size_t dTailleTab)
{
 
	*pptTab = malloc(dTailleTab * sizeof(int));
 
	for (i = 0; i < dTailleTab; i++)
	{
		(*pptTab)[i] = 1 + i;
	}
 
}

Ici je passe l'adresse d'un pointeur grâce au symbole &, et dans le prototype de ma fonction je colle deux ** a pptTab.. puisque j'ai du coup l'adresse d'un pointeur qui contient lui même l'adresse du premier élément de mon tableau et dont le type pointer est de type int (j'ai bon jusque la non??)

Dans la fonction de type void(), je manipule "directement" la variable ptTab que j'ai déclaré dans mon main. -> "directement avec des pointeurs"

Ma confusion vient du fait que je ne savais pas, je ne sais pas, comment faire la même chose avec un tableau a 2 dimensions.. quels sont les paramètres a indiquer dans le prototype de ma fonction, et comment les manipuler dans la fonction.

Dans le code que mon ami m'a envoyé, il déclare un tableau dans le main(), mais il ne le passe pas en paramètre dans le prototype de la fonction (int), il recrée un tableau dans la fonction (même si les variables portent le même nom), et il renvoie l'adresse de ce tableau ainsi crée via un return dans la variable déclarée dans le main() (est ce que je suis clair??)..

Mais je commence a comprendre en relisant vos explications et les exemples de code..
Je vais essayé de pondre un code d'apres ce que j'ai compris, et je reviendrais le poster ici


Encore merci de prendre le temps.. les pointeurs sont une notion importante et je veux vraiment être sur que j'ai bien assimilé la matière!
Surtout que j'ai examen dans 10 jours et qu'il est sur et certain que le prof va essayé de nous piéger avec des bouts de code "tout con", mais qui demanderons d'avoir bien compris tout ça..

[Sve@r]

Ma confusion vient du fait que je ne savais pas, je ne sais pas, comment faire la même chose avec un tableau a 2 dimensions.. quels sont les paramètres a indiquer dans le prototype de ma fonction, et comment les manipuler dans la fonction.

Tu repars du principe de base (nD=n étoiles) mais tu rajoutes une étoile en plus parce que tu ne travailles pas directement sur ta variable (ton tableau) mais sur une indirection de ton tableau (son adresse).
C'est dû au fait que tout paramètre passé à une fonction n'est transmis que par copie mais aussi dû au fait que la mémoire de ton programme est globale. Et donc si une fonction doit modifier une variable située dans une autre fonction, elle ne peut le faire que si elle reçoit l'adresse de cette variable (cf post de Matt_Houston) parce que chaque adresse ne référence, dans tout ton programme, qu'une seule et unique variable.
Et dans ta fonction, tu remplaces tous les tab de ton algo par (*pt) du pointeur reçu (avec les parenthèses dues à la gestion des priorités de l'étoile sur les crochets)

Exemple du départ avec allocation dans le main

Code c :

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

1
2
3
4
5
6
7
8
9
int main() {
	int ***tab;
	tab=malloc(3 * sizeof(int **);
	for (i=0; i < 3; i++) {
		tab[i]=malloc(4 * sizeof(int*))
		for (j=0; j < 4; j++)
			tab[i][j]=malloc(5 * sizeof(int))
	}
}

Même exemple depuis une fonction

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void genere3D(int ****pt) {
	(*pt)=malloc(3 * sizeof(int **);
	for (i=0; i < 3; i++) {
		(*pt)[i]=malloc(4 * sizeof(int*))
		for (j=0; j < 4; j++)
			(*pt)[i][j]=malloc(5 * sizeof(int))
	}
}
 
int main() {
	int ***tab;
	genere3D(&tab);
}

Dans le code que mon ami m'a envoyé, il déclare un tableau dans le main(), mais il ne le passe pas en paramètre dans le prototype de la fonction (int), il recrée un tableau dans la fonction, et il renvoie l'adresse de ce tableau ainsi crée via un return dans la variable déclarée dans le main()

C'est quand-même en effet un peu plus pratique d'utiliser la possibilité de retourner une valeur pour la récupérer dans une variable plutôt que de vouloir modifier ladite variable directement.
Surtout que faire modifier une variable par une fonction oblige à avoir une variable justement, ce qui peut-être contraignant.

Exemple: fonction qui renvoie le carré d'un nombre

Code c :

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

1
2
3
int carre(int n) {
	return n*n;
}

Tu peux l'utiliser bien évidemment pour affecter une variable...

Code c :

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

1
2
3
int main() {
	int x=carre(5);
}

Mais tu peux l'utiliser aussi de façon directe

Code c :

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

1
2
3
int main() {
	printf("Le double du carré de 5 est %d\n", 2*carre(5));
}

Maintenant une fonction qui modifie la variable reçue par son carre

Code c :

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

1
2
3
void carre(int *pt) {
	(*pt)=(*pt)*(*pt);
}

Tu peux encore l'utiliser pour modifier une variable

Code c :

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

1
2
3
4
int main() {
	int x=5;
	carre(&x);
}

Mais tu ne peux plus l'utiliser de façon directe...

(même si les variables portent le même nom)

Visibilité d'une variable. Deux variables automatiques situés dans deux blocs distincts peuvent porter le même nom sans entrer en conflit l'une avec l'autre car elles ne sont visibles que dans le bloc où elles ont été déclarées...

[Dunkhan]

Merci pour les explications

J'ai bien compris maintenant comment faire pour utiliser les pointeurs (et les pointeurs de pointeurs... pointeurs^^).

J'ai choisis la forme ou je retourne une adresse plutôt que de manipuler directement les pointeurs. C'est quand même beaucoup moins contraignant a écrire.
Et puis, dans ce cas précis, je pense aussi que c'est plus "safe" que de manipuler des valeurs qui se trouvent dans une autre fonction (ici le main()). En cas d'erreurs, la fonction retourne juste ça, une erreur.

Du coup, j'ai même pu aller plus loin dans la conception de mon algo et utiliser des structures dans ma deuxième dimension, ce qui va grandement me faciliter la tache pour manipuler mes données


Encore merci a vous deux et particulièrement à Sve@r (qui prend chaque fois bien le temps de me fournir des explications détaillées)

[Sve@r]

et utiliser des structures dans ma deuxième dimension, ce qui va grandement me faciliter la tache pour manipuler mes données

Bien vu Plus tu réfléchis en amont à la façon de t'organiser, plus tu te facilites ensuite le développement.

Encore merci a vous deux et particulièrement à Sve@r (qui prend chaque fois bien le temps de me fournir des explications détaillées)

Ta réussite nous fais tous progresser