Discussion :

[Sve@r]

Décidément je dois rater quelque chose

Code c :

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

1
2
3
		scanf("%d", pDate[*pNbrLues][JOUR]);
		scanf("%d", pDate[*pNbrLues][MOIS]);
		scanf("%d", pDate[*pNbrLues][ANNEE]);

Oui, apprendre les pointeurs ne doit pas te faire oublier les règles de base. Je te laisse trouver tout seul...

[Invité]

Bonsoir,

Pense à élever le niveau d'avertissement de ton compilateur (ou à mieux l'écouter). Le cas échéant il peut te prévenir sur ces lignes :

Code :

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

1
2
3
scanf("%d", pDate[*pNbrLues][JOUR]);
scanf("%d", pDate[*pNbrLues][MOIS]);
scanf("%d", pDate[*pNbrLues][ANNEE]);

où tu lui donnes un int alors qu'il attend un int *.

À noter que dans le main() :

Code :

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

1
2
int **pDate = NULL;
ecLectDates(pDate, &dNbrLues);

le double pointeur pDate restera inchangé après l'appel de la fonction.
Si tu souhaites le modifier, il faudra utiliser un triple pointeur en paramètre et passer &pDate.

[Ersch]

J'ai corrigé le scampi mais il reste une erreur pendant l'exécution

Encore un problème de pointeur je suppose:

fonction

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
#include "stdafx.h"
#include "fonctions.h"
#include "string.h"
#include <stdlib.h>
 
 
#define MSG_1   11
#define MSG_2   12
#define MSG_3   13
#define MSG_4	14
#define JOUR    0
#define MOIS    1
#define ANNEE   2
#define TRUE 1
#define FALSE 0
 
void ecLectDates(int **pDate, int *pNbrLues)
{
	/* encodage du nombre de jour */
	int dNombreDate;
 
	affichageMessage(MSG_4);
	scanf("%d", &dNombreDate);
 
	/* allocation mémoire du tableau */
 
	pDate = malloc(dNombreDate * sizeof(int*));
 
	int i;
 
	for (i = 0; i < dNombreDate; i++)
	{
		pDate[i] = malloc(3 * sizeof(int));
	}
 
	/* fin allocation mémoire */
 
	do
	{
		/* encodage jour */
		affichageMessage(MSG_1);
		scanf("%d", &pDate[*pNbrLues][JOUR]);
 
		/* encodage mois */
		affichageMessage(MSG_2);
		scanf("%d", &pDate[*pNbrLues][MOIS]);
 
		/* encodage annee */
		affichageMessage(MSG_3);
		scanf("%d", &pDate[*pNbrLues][ANNEE]);
 
		(*pNbrLues)++;
	} while (*pNbrLues < dNombreDate);
}
 
//  --------------------------------------------------------------------
//  fonction conversion d'un tqbleau jour/moi/annee en Jours depuis 1900
//  --------------------------------------------------------------------
 
void convertDates(int **pDate, int *pDateConvert, int dNbrLues)
{
	/* allocation mémoire du tableau pDateConvert */
 
	pDateConvert = calloc(dNbrLues, sizeof(int));
 
	/* fin allocation */
 
	int i = 0;
 
	do
	{
		/* jours */
		pDateConvert[i] = pDate[i][JOUR];
 
		/* mois */
		if (pDate[i][JOUR] >= 2)
		{
			pDateConvert[i] += ((pDate[i][MOIS]) - 1) * 30;
		}
 
		/* année */
		if (pDate[i][ANNEE] > 1900)
		{
			pDateConvert[i] += ((pDate[i][ANNEE]) - 1900) * 365;
		}
 
		i++;
	} while (i < dNbrLues);
}
 
//	----------------------
//	Fonction tri des dates
//	----------------------
 
void triTab(int *pDateConvert, int dNbrLues)
{
	int dDesorde = TRUE;
	int i, dTemp;
	while (dDesorde)
	{
		dDesorde = FALSE;
 
		for (i = 0; i < dNbrLues - 1; i++)
		{
			if (pDateConvert[i] > pDateConvert[i + 1])
			{
				dTemp = pDateConvert[i];
				pDateConvert[i] = pDateConvert[i + 1];
				pDateConvert[i + 1] = dTemp;
				dDesorde = TRUE;
			}
		}
	}
}
 
//	---------------------------------------------
//	Conversion des valeurs en chaine de caractère
//	---------------------------------------------
 
void convertNumToChar(int *pDateConvert, char **pDateString, int dNbrLues)
{
	int i, j, k;
 
	for (i = 0; i < dNbrLues; i++)
	{
		char cTemp[15];
		int dLongChaine;
 
		_itoa(pDateConvert[i], cTemp, 10);
		dLongChaine = strlen(cTemp);
		for (j = 0; j < (15 - dLongChaine); j++)
		{
			pDateString[i][j] = '0';
		}
		for (k = 0; k < (15 - dLongChaine); k++)
		{
			pDateString[i][j] = cTemp[k];
			j++;
		}
	}
 
}
 
//  -------------------------------------------
//  fonction init avec '0' d'un tableau de char
//  -------------------------------------------
 
void iniTabChar(char **pDateString, int dNbrLues)
{
	int i, j;
 
	/* allocation mémoire du tableau */
 
	pDateString = malloc(16 * sizeof(char));
 
	for (i = 0; i < dNbrLues; i++)
	{
		pDateString[i] = malloc(dNbrLues * sizeof(char));
	}
 
	/* fin allocation mémoire */
 
	for (i = 0; i < dNbrLues; i++)
	{
		for (j = 0; j < 14; j++)
		{
			pDateString[i][j] = '0';
		}
		pDateString[i][15] = '\n';
	}
}
 
//  ---------------------------------------
//  fonction affichage d'un tableau de char
//  ---------------------------------------
 
void affichageTabChar(char **pDateString, int dNbrLues)
{
	int i, j;
 
	for (i = 0; i < dNbrLues; i++)
	{
		for (j = 0; j < 15; j++)
		{
			printf("%c", pDateString[i][j]);
		}
		printf("\n");
 
	}
}
 
//  --------------------------
//  fonction affichage message
//  --------------------------
 
void affichageMessage(int MSG_ID)
{
	switch (MSG_ID) {
	case 11:
		puts("Jour: ");
		break;
	case 12:
		puts("Mois: ");
		break;
	case 13:
		puts("Annee: ");
		break;
	case 14:
		puts("Nombre de date: ");
		break;
	default:
		break;
	}
}

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
// PRj24_visual.cpp†: dÈfinit le point d'entrÈe pour l'application console.
//
 
#include "stdafx.h"
#include "fonctions.h"
#include "stdlib.h"
 
//#define DMAXDATE 5
 
 
 
int _tmain(int argc, _TCHAR* argv[])
{
	int **pDate = NULL;
	int *pDateConvert = NULL;
	char **pDateString = NULL;
	int dNbrLues = 0;
 
	//  -------------------
	//  Encondage des dates
	//  -------------------
 
	ecLectDates(&pDate, &dNbrLues);
 
	//  --------------------------------------------------
	//  Conversion des dates en jours depuis le 01/01/1900
	//  --------------------------------------------------
 
	convertDates(&pDate, &pDateConvert, dNbrLues);
 
	//  ---------------------------
	//  Tri des dates du tableau
	//  ---------------------------
 
	triTab(pDateConvert, dNbrLues);
 
	//	---------------------------------------------
	//	Conversion des valeurs en chaine de caractère
	//	----------------------------------------------
 
	iniTabChar(pDateString, dNbrLues);
	convertNumToChar(pDateConvert, pDateString, dNbrLues);
 
	//	---------
	//	Affichage
	//	---------
 
	//affichageTabChar(tDateString, dNbrLues);
 
	_gettch();
	return 0;
}

[Invité]

J'ai bien dit

utiliser un triple pointeur

Code :

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

void ecLectDates(int ***pDate, int *pNbrLues)

J'imagine que mon premier conseil est passé à la trappe

[Ersch]

Hello Winjerome,

non désolé je t'avoue que je n'ai pas compris Est ce que c'est le cas pour les autres tableaux aussi?

[Invité]

Si tu souhaites qu'en sortant de la fonction ecLectDates(), pDates pointe vers la mémoire allouée dedans et ne reste pas à la valeur NULL affectée dans le main(), de même pDateConvert dans convertDates() et pDateString dans iniTabChar(), alors oui c'est indispensable

Pour rappel : les paramètres des fonctions sont passés par copie, et pour pouvoir les modifier, on passe alors leur adresse. Et cela vaut aussi pour les pointeurs.
Généralement on a :

Code :

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

1
2
3
4
5
6
void fonction(Type * parametre) {
    *parametre = ...
}
 
Type variable;
fonction(&variable);

Type étant dans ton cas int **

[Sve@r]

Hello Winjerome,

non désolé je t'avoue que je n'ai pas compris Est ce que c'est le cas pour les autres tableaux aussi?

Regarde cet exemple

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
int main()
{
    int var=5;
    modif(var);
    printf("var=%d\n", var);
}
 
void modif(int x)
{
    x=10;
}

Au final, ta variable reste inchangée. Pour pouvoir la faire modifier par ta fonction, il faut lui passer son adresse et la fonction la stockera dans un pointeur

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
int main()
{
    int var=5;
    modif(&var);
    printf("var=%d\n", var);
}
 
void modif(int *pt)
{
    *pt=10;
}

D'ailleurs tu le sais puisque c'est ce que tu fais avec &dNbrLues (et accessoirement aussi avec scanf())

Ben pour pDate c'est pareil. pDate étant un int **, la fonction recevant l'adresse de cette variable (parce qu'elle doit modifier ladite variable) devra la stocker dans un int ***pt et utiliser ensuite *pt pour son travail...

[Ersch]

Merci mais ça ne fonctionne tj pas il y a un problème dans la fonction quand je rentre la valeur de l'allocation, je crois que je vais dormir une nuit dessus je n'y vois plus clair la.

fonction

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
void ecLectDates(int ***pDate, int *pNbrLues)
{
	/* encodage du nombre de jour */
	int dNombreDate;
 
	affichageMessage(MSG_4);
	scanf("%d", &dNombreDate);
 
	/* allocation mémoire du tableau */
 
	*pDate = malloc(dNombreDate * sizeof(int*));
 
	int i;
 
	for (i = 0; i < dNombreDate; i++)
	{
		pDate[i] = malloc(3 * sizeof(int));
	}
 
	/* fin allocation mémoire */
 
	do
	{
		/* encodage jour */
		affichageMessage(MSG_1);
		scanf("%d", &pDate[*pNbrLues][JOUR]);
 
		/* encodage mois */
		affichageMessage(MSG_2);
		scanf("%d", &pDate[*pNbrLues][MOIS]);
 
		/* encodage annee */
		affichageMessage(MSG_3);
		scanf("%d", &pDate[*pNbrLues][ANNEE]);
 
		(*pNbrLues)++;
	} while (*pNbrLues < dNombreDate);
}

main:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int _tmain(int argc, _TCHAR* argv[])
{
	int **pDate = NULL;
	int *pDateConvert = NULL;
	char **pDateString = NULL;
	int dNbrLues = 0;
 
	//  -------------------
	//  Encondage des dates
	//  -------------------
 
	ecLectDates(&pDate, &dNbrLues);

[Invité]

Il va vraiment falloir écouter ton compilateur...
pDate est de type int *** :

• Code :

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

  *pDate = malloc(dNombreDate * sizeof(int*));

  OK

• Code :

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

  pDate[i] = malloc(3 * sizeof(int));

  Erreur : pDate[i] est de type int ** et pas int *.
  (*pDate)[i].
• Même principe dans les lignes scanf() : &pDate[*pNbrLues][JOUR] est de type int ** et non int * comme attendu.
  scanf("%d", &(*pDate)[*pNbrLues][JOUR]);

[Sve@r]

Code :

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

1
2
3
4
5
6
7
void ecLectDates(int ***pDate, int *pNbrLues)
{
	*pDate = malloc(dNombreDate * sizeof(int*));
	for (i = 0; i < dNombreDate; i++)
	{
		pDate[i] = malloc(3 * sizeof(int));
	}

J'ai dit qu'ensuite, toute la fonction devait travailler avec "*pDate". C'est "*pDate" qui représente ton tableau 2D...

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
void ecLectDates(int ***pDate, int *pNbrLues)
{
	*pDate = malloc(dNombreDate * sizeof(int*));
	for (i = 0; i < dNombreDate; i++)
	{
		(*pDate)[i] = malloc(3 * sizeof(int));
	}
	do 	{
		/* encodage jour */
		affichageMessage(MSG_1);
		scanf("%d", &(*pDate)[*pNbrLues][JOUR]);
 
		/* encodage mois  */
		affichageMessage(MSG_2);
		scanf("%d", &(*pDate)[*pNbrLues][MOIS]);
 
		/* encodage annee */
		affichageMessage(MSG_3);
		scanf("%d", &(*pDate)[*pNbrLues][ANNEE]);
 
		(*pNbrLues)++;
	} while (*pNbrLues < dNombreDate);
}

La règle de base est toujours la même. Si tu as une variable type var et que ta fonction doit la modifier, il faut lui passer &var. Et ta fonction la stockera dans un type *pt et devra ensuite bosser avec *pt. Et c'est valable même si "type" possède déjà des étoiles parce que la variable d'origine est un pointeur. T'auras le même problème avec tes fonctions convertDate() et iniTabChar qui veulent modifier un des paramètres reçu sans que celui-ci soit un pointeur. De plus, pour la fonction iniTabChar, il y a un soucis dans ta boucle. Tu alloues de 16 puis tu boucles jusqu'à dNbrLues et tu alloues à chaque pointeur "dNbrLues" caractères. A mon avis, c'est "dNbrLues" qu'il faut allouer en dimension 1 puis "16" caractères à chaque itération. Dans ce cas, si la seconde dimension est figée, tu peux simplifier (mais je te montrerai ça quand tu auras réglé tout le reste)...

[Ersch]

Voila je suis enfin arrivé à une solution qui fonctionne, il reste à voir si c'est propre comme écriture

fonction:

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
#include "stdafx.h"
#include "fonctions.h"
#include "string.h"
#include <stdlib.h>
 
#define MSG_1   11
#define MSG_2   12
#define MSG_3   13
#define MSG_4	14
#define JOUR    0
#define MOIS    1
#define ANNEE   2
#define TRUE 1
#define FALSE 0
 
void ecLectDates(int ***pDate, int *pNbrLues)
{
	/* encodage du nombre de jour */
	int dNombreDate;
 
	affichageMessage(MSG_4);
	scanf("%d", &dNombreDate);
 
	/* allocation mémoire de pDate */
 
	*pDate = malloc(dNombreDate * sizeof(int*));
 
	int i;
 
	for (i = 0; i < dNombreDate; i++)
	{
		(*pDate)[i] = malloc(3 * sizeof(int));
	}
 
	/* fin allocation mémoire */
 
	do
	{
		/* encodage jour */
		affichageMessage(MSG_1);
		scanf("%d", &(*pDate)[*pNbrLues][JOUR]);
 
		/* encodage mois */
		affichageMessage(MSG_2);
		scanf("%d", &(*pDate)[*pNbrLues][MOIS]);
 
		/* encodage annee */
		affichageMessage(MSG_3);
		scanf("%d", &(*pDate)[*pNbrLues][ANNEE]);
 
		(*pNbrLues)++;
	} while (*pNbrLues < dNombreDate);
}
 
//  --------------------------------------------------------------------
//  fonction conversion d'un tqbleau jour/moi/annee en Jours depuis 1900
//  --------------------------------------------------------------------
 
void convertDates(int **pDate, int **pDateConvert, int dNbrLues)
{
	/* allocation mémoire de pDateConvert */
 
	*pDateConvert = calloc(dNbrLues, sizeof(int));
 
	/* fin allocation */
 
	int i = 0;
 
	do
	{
		/* jours */
		(*pDateConvert)[i] = pDate[i][JOUR];
 
		/* mois */
		if (pDate[i][JOUR] >= 2)
		{
			(*pDateConvert)[i] += ((pDate[i][MOIS]) - 1) * 30;
		}
 
		/* année */
		if (pDate[i][ANNEE] > 1900)
		{
			(*pDateConvert)[i] += ((pDate[i][ANNEE]) - 1900) * 365;
		}
 
		i++;
	} while (i < dNbrLues);
}
 
//	----------------------
//	Fonction tri des dates
//	----------------------
 
void triTab(int **pDateConvert, int dNbrLues)
{
	int dDesorde = TRUE;
	int i, dTemp;
	while (dDesorde)
	{
		dDesorde = FALSE;
 
		for (i = 0; i < dNbrLues - 1; i++)
		{
			if ((*pDateConvert)[i] > (*pDateConvert)[i + 1])
			{
				dTemp = (*pDateConvert)[i];
				(*pDateConvert)[i] = (*pDateConvert)[i + 1];
				(*pDateConvert)[i + 1] = dTemp;
				dDesorde = TRUE;
			}
		}
	}
}
 
//	---------------------------------------------
//	Conversion des valeurs en chaine de caractère
//	---------------------------------------------
 
void convertNumToChar(int *pDateConvert, char ***pDateString, int dNbrLues)
{
	int i, j, k;
 
	for (i = 0; i < dNbrLues; i++)
	{
		char cTemp[15];
		int dLongChaine;
 
		_itoa(pDateConvert[i], cTemp, 10);
		dLongChaine = strlen(cTemp);
		for (j = 0; j < (15 - dLongChaine); j++)
		{
			(*pDateString)[i][j] = '0';
		}
		for (k = 0; k < (15 - dLongChaine); k++)
		{
			(*pDateString)[i][j] = cTemp[k];
			j++;
		}
	}
 
}
 
//  -------------------------------------------
//  fonction init avec '0' d'un tableau de char
//  -------------------------------------------
 
void iniTabChar(char ***pDateString, int dNbrLues)
{
	int i, j;
 
	/* allocation mémoire de pDateString */
 
	*pDateString = malloc(16 * sizeof(char));
 
	for (i = 0; i < dNbrLues; i++)
	{
		(*pDateString)[i] = malloc(dNbrLues * sizeof(char));
	}
 
	/* fin allocation mémoire */
 
	for (i = 0; i < dNbrLues; i++)
	{
		for (j = 0; j < 14; j++)
		{
			(*pDateString)[i][j] = '0';
		}
		(*pDateString)[i][15] = '\n';
	}
}
 
//  ---------------------------------------
//  fonction affichage d'un tableau de char
//  ---------------------------------------
 
void affichageTabChar(char **pDateString, int dNbrLues)
{
	int i, j;
 
	for (i = 0; i < dNbrLues; i++)
	{
		for (j = 0; j < 15; j++)
		{
			printf("%c", pDateString[i][j]);
		}
		printf("\n");
 
	}
}
 
//  --------------------------
//  fonction affichage message
//  --------------------------
 
void affichageMessage(int MSG_ID)
{
	switch (MSG_ID) {
	case 11:
		puts("Jour: ");
		break;
	case 12:
		puts("Mois: ");
		break;
	case 13:
		puts("Annee: ");
		break;
	case 14:
		puts("Nombre de date: ");
		break;
	default:
		break;
	}
}

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
// PRj24_visual.cpp†: dÈfinit le point d'entrÈe pour l'application console.
//
 
#include "stdafx.h"
#include "fonctions.h"
#include "stdlib.h"
 
int _tmain(int argc, _TCHAR* argv[])
{
	int **pDate = NULL;
	int *pDateConvert = NULL;
	char **pDateString = NULL;
	int dNbrLues = 0;
 
	//  -------------------
	//  Encondage des dates
	//  -------------------
 
	ecLectDates(&pDate, &dNbrLues);
 
	//  --------------------------------------------------
	//  Conversion des dates en jours depuis le 01/01/1900
	//  --------------------------------------------------
 
	convertDates(pDate, &pDateConvert, dNbrLues);
 
	//  ---------------------------
	//  Tri des dates du tableau
	//  ---------------------------
 
	triTab(&pDateConvert, dNbrLues);
 
	//	---------------------------------------------
	//	Conversion des valeurs en chaine de caractère
	//	----------------------------------------------
 
	iniTabChar(&pDateString, dNbrLues);
	convertNumToChar(pDateConvert, &pDateString, dNbrLues);
 
	//	---------
	//	Affichage
	//	---------
 
	affichageTabChar(pDateString, dNbrLues);
 
	_gettch();
	return 0;
}

[ternel]

Voir si c'est propre?
Qu'en penses-tu, personnellement?

[Ersch]

Voir si c'est propre?
Qu'en penses-tu, personnellement?

Je trouve l'écriture assez lourde parfois au niveau des pointeurs mais étant en phase d'apprentissage j'ai déjà rencontré des difficultés à bien comprendre l'écriture de ceux ci.

j'ai vu dans mon cours qu'on pouvait simplifier l'écriture avec notamment un "typedef int tTab[]" et déclarer "tTab * pointeur" qui serait un pointeur vers un tableau de x entier maintenant est ce la bonne façon? Je manque d'expérience

[diogene]

Pourquoi n'utilises-tu pas la valeur de retour des fonctions ?

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
int ** ecLectDates(int *pNbrLues)
{
   int **pDate;
...
   pDate = malloc(dNombreDate * sizeof(int*));
   int i;
   for (i = 0; i < dNombreDate; i++)
   {
      pDate[i] = malloc(3 * sizeof(int));
   }
...
   return pDate;
}
// idem ici:
int * convertDates(int **pDate, int dNbrLues){...}
// et ici
char **  iniTabChar(int dNbrLues){...}

Pourquoi passer l'adresse ici :

Code :

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

1
2
3
4
5
6
7
8
void triTab(int *pDateConvert, int dNbrLues)
{
...
if (pDateConvert[i] > pDateConvert[i + 1])
...
}
// idem ici
void convertNumToChar(int *pDateConvert, char **pDateString, int dNbrLues){...}

Avec comme 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
int _tmain(int argc, _TCHAR* argv[])
{
	int **pDate = NULL;
	int *pDateConvert = NULL;
	char **pDateString = NULL;
	int dNbrLues = 0;
 
	//  -------------------
	//  Encondage des dates
	//  -------------------
 
	pdate = ecLectDates(&dNbrLues);
 
	//  --------------------------------------------------
	//  Conversion des dates en jours depuis le 01/01/1900
	//  --------------------------------------------------
 
	pDateConvert = convertDates(pDate, dNbrLues);
 
	//  ---------------------------
	//  Tri des dates du tableau
	//  ---------------------------
 
	triTab(pDateConvert, dNbrLues);
 
	//	---------------------------------------------
	//	Conversion des valeurs en chaine de caractère
	//	----------------------------------------------
 
	pDateString = iniTabChar(dNbrLues);
	convertNumToChar(pDateConvert, pDateString, dNbrLues);
 
	//	---------
	//	Affichage
	//	---------
 
	affichageTabChar(pDateString, dNbrLues);
 
	_gettch();
	return 0;
}

[Sve@r]

Voila je suis enfin arrivé à une solution qui fonctionne

Gaffe à ton allocation dans ta fonction "iniTabChar()". Ce n'est pas corrigé. Mais sinon j'aime bien. J'ai testé avec 3 dates, il me les a bien mises dans l'ordre et a affiché à chaque fois un nb de jours correct (mais c'étaient toutes les 3 des dates référençant janvier 1900 donc on n'est pas certain que le calcul soit parfaitement exact dans tous les cas surtout avec 2000 qui était bissextile mais 1900 qui ne l'était pas).

j'ai vu dans mon cours qu'on pouvait simplifier l'écriture avec notamment un "typedef int tTab[]" et déclarer "tTab * pointeur" qui serait un pointeur vers un tableau de x entier maintenant est ce la bonne façon? Je manque d'expérience

Sûrement pas. Les pointeurs sont omniprésents en C. Il est capital de connaitre ce que tu manipules. Si tu caches un pointeur derrière un type tu ne simplifies rien (ça te coûte quoi de déclarer int *pointeur[] ???) et tu obscurcis le code pour tous ceux qui vont te relire (tTab *pointeur => ok, pointeur vers un tableau 1D puis plus tard pointeur[i][j]=valeur => écriture 2D !!!) y compris toi-même quand tu veux reprendre un code 6 mois plus tard...
Ceux qui écrivent ce genre de conseils sont souvent des gens qui ne savent pas eux-même ce qu'est un pointeur ou qui n'ont pas le recul suffisant pour pouvoir les expliquer.

[Ersch]

J'ai peut être mal interprété ce qu'il y a dans le cours et peut être que le but était seulement de montrer que cette solution existe, c'était en réponse au msg de Leternel ou il me demandait ce que je pensais moi même sur la clarté de mon code. J'aurais du simplement répondre que la question était pour vous

Je vais déjà digérer ça plus l'écriture que Diogene suggère

[diogene]

@sver :
Tu as lu les définitions trop rapidement et interprété à l'envers. C'est le tableau qui est "caché" par le typedef, pas le pointeur :

Code :

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

1
2
typedef int tTab[];
tTab * pointeur;

La déclaration sans typedef serait

Code :

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

int  (*pointeur )[];

[Ersch]

question écriture, c'est quoi le "mieux"?

[diogene]

Pour mon compte, si j'avais à utiliser plusieurs fois un tTab, je prendrais peut être la première formulation. Si c'est purement occasionnel, je prendrais sans doute la deuxième.

C'est selon le programme et en fonction de la clarté du code obtenu.

[Sve@r]

@sver :
Tu as lu les définitions trop rapidement et interprété à l'envers. C'est le tableau qui est "caché" par le typedef, pas le pointeur :

Oui mais bon cela ne change pas grand chose à mon point de vue. Cacher un pointeur ou un tableau derrière un type...