Bonsoir !

je suis en train d'implementer des prototypes de fonctions deja donnés, j'ai plus ou moins du mal avec les pointeurs de tableaux et de fonctions.
J'aurai besoin que vous verifiez, si possible, mon code, en particulier avec les *
A vrai dire, je ne sais pas comment les tester avec un main etant donné que c'est une suite de fichiers (un projet en realisation), et que j'en suis qu'au debut.

Voici le fichier file.h donné, je dois rajouter des prototypes de fonctions mais pas modifier ceux deja presents
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
// mettre des choses avant
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))
 
/// \struct pour encapsuler des tableaux dynamiques d'entiers avec la dimension.
typedef struct s_tab_dyn{
  int * tab;
  int dim;
} t_tab_int_dyn;
 
typedef struct s_mat_dyn{
  int ** tab;
  int nbRows;
  int nbCol;
} t_mat_int_dyn;
 
/// \struct idem avec des chaînes de cractères
typedef struct s_mat_char_dyn{
  char *** tab;
  int nbRows;
  int nbCol;
  int offset; // donne le nombre de colonnes avant celles des candidats
} t_mat_char_star_dyn;
 
/// \struct arc pour les graphes
typedef struct s_arc_p{ /// arc pondéré
  int orig;
  int dest;
  int poids;
} t_arc_p;
 
int * creer_tab_int(int dim); // juste un malloc de dim cases
int ** creer_mat_int(int nbRows,int nbCol); // malob 2D
int ** creer_mat_char(int nbRows, int nbCol);
void affiche_tab_int(int *tab,int dim, FILE *logfp);
 
void creer_t_mat_int_dyn(t_mat_int_dyn *stTab,int nbRows,int nbCol); // utilise la struct
void creer_t_tab_int_dyn(t_tab_int_dyn *stTab,int dim); // idem
void creer_t_mat_char_dyn(t_mat_char_star_dyn * s_tabmots);
void affiche_t_tab_int_dyn(t_tab_int_dyn t_tab, FILE *logfp);
void affiche_t_mat_char_star_dyn(t_mat_char_star_dyn t_tabmots, FILE *logfp);
void affiche_t_mat_int_dyn(t_mat_int_dyn t_tab, FILE *logfp);
void affiche_mat_int(int **duels_mat,int nbRows,int nbCol,FILE *logfp);
 
void init_tab_int(int *tab,int dim,int valeur);// initialise avec une valeur
void init_mat_int(int **mat,int nbRows,int nbCol,int valeur); // idem
 
//----------------------------------
// Prototypes rajoutées par moi meme
char lecture(char f, char delimiteur);
void affiche_mat_char(char **duels_mat,int nbRows,int nbCol,FILE *logfp);
et voici ce que j'ai fait, le fichier file.c
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
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include "file.h"
#define TAILLE_MAX 1000
 
 
int * creer_tab_int(int dim)
{
	int *tab = NULL;
	tab = malloc(dim*sizeof(int));
	if (tab == NULL){
		printf("Probleme d'allocation.\n");
		exit(1);
	}
	return tab;
}
 
//----------------------------------------------------------------------------
 
int ** creer_mat_int(int nbRows, int nbCol)
{
	int *tab = NULL;
	tab = malloc(nbRows*sizeof(int));
	if (tab == NULL){
		printf("Probleme d'allocation.\n");
		exit(1);
	}
 
	for (int i=0; i<nbRows; i++)
	{
		tab[i] = malloc(nbCol*sizeof(int));
		if (tab[i] == NULL)
		{
			printf("Probleme d'allocation.\n");
			exit(1);
		}
	}
	return tab;
}
 
//----------------------------------------------------------------------------
 
int ** creer_mat_char(int nbRows, int nbCol)
{
	char *tab = NULL;
	tab = malloc(nbRows*sizeof(char*));
	if (tab == NULL){
		printf("Probleme d'allocation.\n");
		exit(1);
	}
 
	for (int i=0; i<nbRows; i++)
	{
		tab[i] = malloc(nbCol*sizeof(char*));
		if (tab[i] == NULL)
		{
			printf("Probleme d'allocation.\n");
			exit(1);
		}
	}
	return tab;
}
 
//----------------------------------------------------------------------------
 
void creer_t_tab_int_dyn(t_tab_int_dyn *stTab, int dim)
{
	*stTab->tab = creer_tab_int(dim);
}
 
//----------------------------------------------------------------------------
 
void creer_t_mat_int_dyn(t_mat_int_dyn *stTab, int nbRows, int nbCol)
{
	**stTab->tab = creer_mat_int(nbRows,nbCol);
}
 
//----------------------------------------------------------------------------
 
void creer_t_mat_char_dyn(t_mat_char_star_dyn *s_tabmots)
{
	***s_tabmots->tab = creer_mat_char(s_tabmots->nbRows, s_tabmots->nbCol);
}
 
//----------------------------------------------------------------------------
 
void affiche_tab_int(int *tab, int dim, FILE *logfp)
{
	for (int i=0; i<dim; i++)
	{
		fputs(tab[i],logfp);
	}
}
 
//----------------------------------------------------------------------------
 
void affiche_mat_int(int **duels_mat,int nbRows,int nbCol,FILE *logfp)
{
	for (int i=0; i<nbRows; i++)
	{
		for (int j=0; j<nbCol; j++)
		{
			fputs(duels_mat[i][j],logfp);
		}
	}
}
 
//----------------------------------------------------------------------------
 
void affiche_mat_char(char **duels_mat,int nbRows,int nbCol,FILE *logfp)
{
	for (int i=0; i<nbRows; i++)
	{
		for (int j=0; j<nbCol; j++)
		{
			fputs(duels_mat[i][j],logfp);
		}
	}
}
 
//----------------------------------------------------------------------------
 
void affiche_t_tab_int_dyn(t_tab_int_dyn t_tab, FILE *logfp)
{
	affiche_tab_int(*t_tab.tab,t_tab.dim,logfp);
}
 
//----------------------------------------------------------------------------
 
void affiche_t_mat_int_dyn(t_mat_int_dyn t_tab, FILE *logfp)
{
	affiche_mat_int(**t_tab.tab,t_tab.nbRows,t_tab.nbCol,logfp);
}
 
//----------------------------------------------------------------------------
 
void affiche_t_mat_char_star_dyn(t_mat_char_star_dyn t_tabmots, FILE *logfp)
{
	affiche_mat_char(***t_tabmots.tab,t_tabmots.nbRows,t_tabmots.nbCol,logfp);
}
 
//----------------------------------------------------------------------------
 
void init_tab_int(int *tab,int dim,int valeur)
{
	for (int i=0; i<dim; i++)
	{
		tab[i] = valeur;
	}
}
 
//----------------------------------------------------------------------------
 
void init_mat_int(int **mat,int nbRows,int nbCol,int valeur)
{
	for (int i=0; i<nbRows; i++)
	{
		for (int j=0; j<nbCol; j++)
		{
			mat[i][j] = valeur;
		}
	}
}
 
//----------------------------------------------------------------------------
 
char lecture(char f, char delimiteur)
{
	int i = 0;
	int j;
	int nbRows = 1;
	int nbCol = 1;
	char p;
	char chaine [TAILLE_MAX] = "";
 
	char **tab = NULL;
	tab = malloc(nbRows*sizeof(char*));
	if (tab == NULL){
		printf("Probleme d'allocation.\n");
		exit(1);
	}
 
	for (int i=0; i<nbRows; i++)
	{
		tab[i] = malloc(nbCol*sizeof(char));
		if (tab[i] == NULL)
		{
			printf("Probleme d'allocation.\n");
			exit(1);
		}
	}
 
	FILE* fichier = NULL;
	fichier = fopen(f,"r");
 
	if (fichier == NULL)
	{
		printf("impossible d'ouvrir le fichier %c.",f);
	}
	else
	{
		while (fgets(chaine,TAILLE_MAX,fichier) != NULL)
		{
			j = 0;
			p = strtok(chaine,delimiteur);
			while (p != NULL)
			{
				tab[i][j] = p;
				nbCol++;
				tab[i] = realloc(tab[i],nbCol*sizeof(char));
				if (tab[i] == NULL){
					printf("Probleme d'allocation.\n");
					exit(1);
				}
				p = strtok(NULL,delimiteur);
				j++;
			}
			nbRows++;
			tab = realloc(tab,nbRows*sizeof(char));
			if (tab == NULL){
				printf("Probleme d'allocation.\n");
				exit(1);
			}
			i++;
		}
	}
	fclose(f);
	return tab;	
}
Les procedures utilisant les struct doivent utiliser les fonctions deja implementé

Concernant la derniere fonction (char lecture) :
elle doit lire un fichier txt, détecter le nombre de lignes (nbRows) et de colonnes (nbCol) en utilisant un caractère délimiteur passé en paramètre et doit renvoyer l’adresse d’un tableau de chaînes de caractères de nbrows × nbCol cases contenant chacun des éléments du fichier txt

Je pense m’être tromper au niveau des parametres de la fonction, je ne sais pas trop

Merci en tout cas et bon reveillon !