J'ai à manipuler des fichiers contenant des données.
Ces données sont stockées dans des sections : 1 section avec son nom de
section et la donnée qui correspond à cette section.
Je ne connais pas à priori le nombre de fichiers ni le nombre de sections.
Je compte faire un tableau de sections avec pour indice le numero de section
et comme donnée le nom de la section.
Egalement un tableau de données à deux dimensions (section x numéro de
fichier).
Mon algorithme consisterait à parcourir mes fichiers,
pour chaque fichier
pour chaque section
je regarde si elle est connue (tableau de sections)
si oui, je lis son numéro
si non je la crée.
je lis la donnée de la section du fichier
j'inscris ma donnéee lue tans mon tableau de données à l'emplacement
(numero de fichier, numero de section).
Je suis ainsi amené à manipuler des tableaux à deux dimensions et surtout à
redimensionner dynamiquement les deux dimensions.
Est-ce possible ?
Comment procéder ?
Sinon j'avais pensé à un tableau de pointeurs vers des tableaux mais je ne
sais pas comment manipuler cela.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Marc Lasson
Scud a écrit:
Bonjour, Salut :)
J'ai à manipuler des fichiers contenant des données. Ces données sont stockées dans des sections : 1 section avec son nom de section et la donnée qui correspond à cette section. Ok.
Je ne connais pas à priori le nombre de fichiers ni le nombre de sections.
Ok.
Je compte faire un tableau de sections avec pour indice le numero de section
et comme donnée le nom de la section. Ok.
Egalement un tableau de données à deux dimensions (section x numéro de fichier). Ok.
Bon, personnelement, je trouve qu'en C les tableaux ne sont pas les objets dynamiques les plus simples à manier. J'aurai plutôt choisit de faire une liste de section et une liste de fichier:
Mon algorithme consisterait à parcourir mes fichiers, pour chaque fichier pour chaque section je regarde si elle est connue (tableau de sections) si oui, je lis son numéro si non je la crée. je lis la donnée de la section du fichier j'inscris ma donnéee lue tans mon tableau de données à l'emplacement (numero de fichier, numero de section).
L'algorithme est le meme.
Je suis ainsi amené à manipuler des tableaux à deux dimensions et surtout à
redimensionner dynamiquement les deux dimensions.
Rappel : -------- Un tableau unidimensionel dynamique d'objet de type 't' se programme en (ré)allouant une zone mémoire (contigüe) dont la taille est un multiple de la taille de l'objet 't'. (1)
Exemple d'un tableau de 5 'int': int *p = malloc (5 * sizeof (int));
En C, on aime bien implémenter les tableaux dynamiques à deux dimensions d'objet de type 't' à l'aide d'un tableau unidimensionnel dynamique de tableau unidimensionnel dynamique de 't'.
Ce qui nous donne pour un tableau de 5x5: /* on alloue un tableau de 5 pointeur d'int : */ int **p = malloc (5 * sizoef (int *)); /* puis POUR chaque element de ce tableau * on alloue un tableau de 5 int : * */ for (x = 0;x < 5;x ++){ p[x] = malloc (5 * sizeof (int)); }
Admettons que je veuille ajouter une dimension a mon tableau de 5x5, on deux solutions: une kivabien et une kivamoinsbien.
la dimension kivabien: ---------------------- on realloue le tableau de pointeur: p = realloc (p, 6 * sizeof (int *)); et on alloue un tableau de 5 nouvelles cases: p[5] = malloc (5 * sizeof (int);
Sur le schema ca revient a rajouter une case au tableau d'où partent les fléches.
la dimension kivamoinsbien: -------------------------- On réajuste chaque element du tableau de pointeur pour rajouter une case : for (x = 0;x < 5;x ++){ p[x] = realloc (p[x], 6 * sizeof (int)); }
Sur le schema, ca revient à rajouter une case à chaque tableau d'où arrivent les flèches.
Sinon j'avais pensé à un tableau de pointeurs vers des tableaux mais je ne
sais pas comment manipuler cela. C'est ca.
Merci pour vos eclaircissements. J'ai tendance à rendre les choses simples compliquées :'(. J'aimerai
être plus pédagogique.
-- Marc.
PS: j'ai volontairement ignoré les echecs des fonctions *alloc().
http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc0012.html#q_10 est ton ami.
Scud a écrit:
Bonjour,
Salut :)
J'ai à manipuler des fichiers contenant des données.
Ces données sont stockées dans des sections : 1 section avec son nom de
section et la donnée qui correspond à cette section.
Ok.
Je ne connais pas à priori le nombre de fichiers ni le nombre de
sections.
Ok.
Je compte faire un tableau de sections avec pour indice le numero de
section
et comme donnée le nom de la section.
Ok.
Egalement un tableau de données à deux dimensions (section x numéro de
fichier).
Ok.
Bon, personnelement, je trouve qu'en C les tableaux ne sont pas les
objets dynamiques les plus simples à manier. J'aurai plutôt choisit de
faire une liste de section et une liste de fichier:
Mon algorithme consisterait à parcourir mes fichiers,
pour chaque fichier
pour chaque section
je regarde si elle est connue (tableau de sections)
si oui, je lis son numéro
si non je la crée.
je lis la donnée de la section du fichier
j'inscris ma donnéee lue tans mon tableau de données à l'emplacement
(numero de fichier, numero de section).
L'algorithme est le meme.
Je suis ainsi amené à manipuler des tableaux à deux dimensions et
surtout à
redimensionner dynamiquement les deux dimensions.
Rappel :
--------
Un tableau unidimensionel dynamique d'objet de type 't' se programme en
(ré)allouant une zone mémoire (contigüe) dont la taille est un multiple
de la taille de l'objet 't'. (1)
Exemple d'un tableau de 5 'int':
int *p = malloc (5 * sizeof (int));
En C, on aime bien implémenter les tableaux dynamiques à deux dimensions
d'objet de type 't' à l'aide d'un tableau unidimensionnel dynamique de
tableau unidimensionnel dynamique de 't'.
Ce qui nous donne pour un tableau de 5x5:
/* on alloue un tableau de 5 pointeur d'int : */
int **p = malloc (5 * sizoef (int *));
/* puis POUR chaque element de ce tableau
* on alloue un tableau de 5 int :
* */
for (x = 0;x < 5;x ++){
p[x] = malloc (5 * sizeof (int));
}
Admettons que je veuille ajouter une dimension a mon tableau de 5x5, on
deux solutions: une kivabien et une kivamoinsbien.
la dimension kivabien:
----------------------
on realloue le tableau de pointeur:
p = realloc (p, 6 * sizeof (int *));
et on alloue un tableau de 5 nouvelles cases:
p[5] = malloc (5 * sizeof (int);
Sur le schema ca revient a rajouter une case au tableau d'où partent
les fléches.
la dimension kivamoinsbien:
--------------------------
On réajuste chaque element du tableau de pointeur pour rajouter une
case :
for (x = 0;x < 5;x ++){
p[x] = realloc (p[x], 6 * sizeof (int));
}
Sur le schema, ca revient à rajouter une case à chaque tableau d'où
arrivent les flèches.
Sinon j'avais pensé à un tableau de pointeurs vers des tableaux mais
je ne
sais pas comment manipuler cela.
C'est ca.
Merci pour vos eclaircissements.
J'ai tendance à rendre les choses simples compliquées :'(. J'aimerai
être plus pédagogique.
--
Marc.
PS: j'ai volontairement ignoré les echecs des fonctions *alloc().
http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc0012.html#q_10 est ton ami.
J'ai à manipuler des fichiers contenant des données. Ces données sont stockées dans des sections : 1 section avec son nom de section et la donnée qui correspond à cette section. Ok.
Je ne connais pas à priori le nombre de fichiers ni le nombre de sections.
Ok.
Je compte faire un tableau de sections avec pour indice le numero de section
et comme donnée le nom de la section. Ok.
Egalement un tableau de données à deux dimensions (section x numéro de fichier). Ok.
Bon, personnelement, je trouve qu'en C les tableaux ne sont pas les objets dynamiques les plus simples à manier. J'aurai plutôt choisit de faire une liste de section et une liste de fichier:
Mon algorithme consisterait à parcourir mes fichiers, pour chaque fichier pour chaque section je regarde si elle est connue (tableau de sections) si oui, je lis son numéro si non je la crée. je lis la donnée de la section du fichier j'inscris ma donnéee lue tans mon tableau de données à l'emplacement (numero de fichier, numero de section).
L'algorithme est le meme.
Je suis ainsi amené à manipuler des tableaux à deux dimensions et surtout à
redimensionner dynamiquement les deux dimensions.
Rappel : -------- Un tableau unidimensionel dynamique d'objet de type 't' se programme en (ré)allouant une zone mémoire (contigüe) dont la taille est un multiple de la taille de l'objet 't'. (1)
Exemple d'un tableau de 5 'int': int *p = malloc (5 * sizeof (int));
En C, on aime bien implémenter les tableaux dynamiques à deux dimensions d'objet de type 't' à l'aide d'un tableau unidimensionnel dynamique de tableau unidimensionnel dynamique de 't'.
Ce qui nous donne pour un tableau de 5x5: /* on alloue un tableau de 5 pointeur d'int : */ int **p = malloc (5 * sizoef (int *)); /* puis POUR chaque element de ce tableau * on alloue un tableau de 5 int : * */ for (x = 0;x < 5;x ++){ p[x] = malloc (5 * sizeof (int)); }
Admettons que je veuille ajouter une dimension a mon tableau de 5x5, on deux solutions: une kivabien et une kivamoinsbien.
la dimension kivabien: ---------------------- on realloue le tableau de pointeur: p = realloc (p, 6 * sizeof (int *)); et on alloue un tableau de 5 nouvelles cases: p[5] = malloc (5 * sizeof (int);
Sur le schema ca revient a rajouter une case au tableau d'où partent les fléches.
la dimension kivamoinsbien: -------------------------- On réajuste chaque element du tableau de pointeur pour rajouter une case : for (x = 0;x < 5;x ++){ p[x] = realloc (p[x], 6 * sizeof (int)); }
Sur le schema, ca revient à rajouter une case à chaque tableau d'où arrivent les flèches.
Sinon j'avais pensé à un tableau de pointeurs vers des tableaux mais je ne
sais pas comment manipuler cela. C'est ca.
Merci pour vos eclaircissements. J'ai tendance à rendre les choses simples compliquées :'(. J'aimerai
être plus pédagogique.
-- Marc.
PS: j'ai volontairement ignoré les echecs des fonctions *alloc().
http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc0012.html#q_10 est ton ami.
Scud
Merci beaucoup pour votre aide.
J'y vois plus clair maintenant !
-Scud
"Marc Lasson" a écrit dans le message de news:3f3dfa2f$0$16150$
Scud a écrit:
Bonjour, Salut :)
J'ai à manipuler des fichiers contenant des données. Ces données sont stockées dans des sections : 1 section avec son nom de section et la donnée qui correspond à cette section. Ok.
Je ne connais pas à priori le nombre de fichiers ni le nombre de sections.
Ok.
Je compte faire un tableau de sections avec pour indice le numero de section
et comme donnée le nom de la section. Ok.
Egalement un tableau de données à deux dimensions (section x numéro de fichier). Ok.
Bon, personnelement, je trouve qu'en C les tableaux ne sont pas les objets dynamiques les plus simples à manier. J'aurai plutôt choisit de faire une liste de section et une liste de fichier:
Mon algorithme consisterait à parcourir mes fichiers, pour chaque fichier pour chaque section je regarde si elle est connue (tableau de sections) si oui, je lis son numéro si non je la crée. je lis la donnée de la section du fichier j'inscris ma donnéee lue tans mon tableau de données à l'emplacement
(numero de fichier, numero de section).
L'algorithme est le meme.
Je suis ainsi amené à manipuler des tableaux à deux dimensions et surtout à
redimensionner dynamiquement les deux dimensions.
Rappel : -------- Un tableau unidimensionel dynamique d'objet de type 't' se programme en (ré)allouant une zone mémoire (contigüe) dont la taille est un multiple de la taille de l'objet 't'. (1)
Exemple d'un tableau de 5 'int': int *p = malloc (5 * sizeof (int));
En C, on aime bien implémenter les tableaux dynamiques à deux dimensions d'objet de type 't' à l'aide d'un tableau unidimensionnel dynamique de tableau unidimensionnel dynamique de 't'.
Ce qui nous donne pour un tableau de 5x5: /* on alloue un tableau de 5 pointeur d'int : */ int **p = malloc (5 * sizoef (int *)); /* puis POUR chaque element de ce tableau * on alloue un tableau de 5 int : * */ for (x = 0;x < 5;x ++){ p[x] = malloc (5 * sizeof (int)); }
Admettons que je veuille ajouter une dimension a mon tableau de 5x5, on deux solutions: une kivabien et une kivamoinsbien.
la dimension kivabien: ---------------------- on realloue le tableau de pointeur: p = realloc (p, 6 * sizeof (int *)); et on alloue un tableau de 5 nouvelles cases: p[5] = malloc (5 * sizeof (int);
Sur le schema ca revient a rajouter une case au tableau d'où partent les fléches.
la dimension kivamoinsbien: -------------------------- On réajuste chaque element du tableau de pointeur pour rajouter une case : for (x = 0;x < 5;x ++){ p[x] = realloc (p[x], 6 * sizeof (int)); }
Sur le schema, ca revient à rajouter une case à chaque tableau d'où arrivent les flèches.
Sinon j'avais pensé à un tableau de pointeurs vers des tableaux mais je ne
sais pas comment manipuler cela. C'est ca.
Merci pour vos eclaircissements. J'ai tendance à rendre les choses simples compliquées :'(. J'aimerai
être plus pédagogique.
-- Marc.
PS: j'ai volontairement ignoré les echecs des fonctions *alloc().
http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc0012.html#q_10 est ton ami.
Merci beaucoup pour votre aide.
J'y vois plus clair maintenant !
-Scud
"Marc Lasson" <marc.lasson@laposte.net> a écrit dans le message de
news:3f3dfa2f$0$16150$626a54ce@news.free.fr...
Scud a écrit:
Bonjour,
Salut :)
J'ai à manipuler des fichiers contenant des données.
Ces données sont stockées dans des sections : 1 section avec son nom de
section et la donnée qui correspond à cette section.
Ok.
Je ne connais pas à priori le nombre de fichiers ni le nombre de
sections.
Ok.
Je compte faire un tableau de sections avec pour indice le numero de
section
et comme donnée le nom de la section.
Ok.
Egalement un tableau de données à deux dimensions (section x numéro de
fichier).
Ok.
Bon, personnelement, je trouve qu'en C les tableaux ne sont pas les
objets dynamiques les plus simples à manier. J'aurai plutôt choisit de
faire une liste de section et une liste de fichier:
Mon algorithme consisterait à parcourir mes fichiers,
pour chaque fichier
pour chaque section
je regarde si elle est connue (tableau de sections)
si oui, je lis son numéro
si non je la crée.
je lis la donnée de la section du fichier
j'inscris ma donnéee lue tans mon tableau de données à
l'emplacement
(numero de fichier, numero de section).
L'algorithme est le meme.
Je suis ainsi amené à manipuler des tableaux à deux dimensions et
surtout à
redimensionner dynamiquement les deux dimensions.
Rappel :
--------
Un tableau unidimensionel dynamique d'objet de type 't' se programme en
(ré)allouant une zone mémoire (contigüe) dont la taille est un multiple
de la taille de l'objet 't'. (1)
Exemple d'un tableau de 5 'int':
int *p = malloc (5 * sizeof (int));
En C, on aime bien implémenter les tableaux dynamiques à deux dimensions
d'objet de type 't' à l'aide d'un tableau unidimensionnel dynamique de
tableau unidimensionnel dynamique de 't'.
Ce qui nous donne pour un tableau de 5x5:
/* on alloue un tableau de 5 pointeur d'int : */
int **p = malloc (5 * sizoef (int *));
/* puis POUR chaque element de ce tableau
* on alloue un tableau de 5 int :
* */
for (x = 0;x < 5;x ++){
p[x] = malloc (5 * sizeof (int));
}
Admettons que je veuille ajouter une dimension a mon tableau de 5x5, on
deux solutions: une kivabien et une kivamoinsbien.
la dimension kivabien:
----------------------
on realloue le tableau de pointeur:
p = realloc (p, 6 * sizeof (int *));
et on alloue un tableau de 5 nouvelles cases:
p[5] = malloc (5 * sizeof (int);
Sur le schema ca revient a rajouter une case au tableau d'où partent
les fléches.
la dimension kivamoinsbien:
--------------------------
On réajuste chaque element du tableau de pointeur pour rajouter une
case :
for (x = 0;x < 5;x ++){
p[x] = realloc (p[x], 6 * sizeof (int));
}
Sur le schema, ca revient à rajouter une case à chaque tableau d'où
arrivent les flèches.
Sinon j'avais pensé à un tableau de pointeurs vers des tableaux mais
je ne
sais pas comment manipuler cela.
C'est ca.
Merci pour vos eclaircissements.
J'ai tendance à rendre les choses simples compliquées :'(. J'aimerai
être plus pédagogique.
--
Marc.
PS: j'ai volontairement ignoré les echecs des fonctions *alloc().
http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc0012.html#q_10 est ton ami.
"Marc Lasson" a écrit dans le message de news:3f3dfa2f$0$16150$
Scud a écrit:
Bonjour, Salut :)
J'ai à manipuler des fichiers contenant des données. Ces données sont stockées dans des sections : 1 section avec son nom de section et la donnée qui correspond à cette section. Ok.
Je ne connais pas à priori le nombre de fichiers ni le nombre de sections.
Ok.
Je compte faire un tableau de sections avec pour indice le numero de section
et comme donnée le nom de la section. Ok.
Egalement un tableau de données à deux dimensions (section x numéro de fichier). Ok.
Bon, personnelement, je trouve qu'en C les tableaux ne sont pas les objets dynamiques les plus simples à manier. J'aurai plutôt choisit de faire une liste de section et une liste de fichier:
Mon algorithme consisterait à parcourir mes fichiers, pour chaque fichier pour chaque section je regarde si elle est connue (tableau de sections) si oui, je lis son numéro si non je la crée. je lis la donnée de la section du fichier j'inscris ma donnéee lue tans mon tableau de données à l'emplacement
(numero de fichier, numero de section).
L'algorithme est le meme.
Je suis ainsi amené à manipuler des tableaux à deux dimensions et surtout à
redimensionner dynamiquement les deux dimensions.
Rappel : -------- Un tableau unidimensionel dynamique d'objet de type 't' se programme en (ré)allouant une zone mémoire (contigüe) dont la taille est un multiple de la taille de l'objet 't'. (1)
Exemple d'un tableau de 5 'int': int *p = malloc (5 * sizeof (int));
En C, on aime bien implémenter les tableaux dynamiques à deux dimensions d'objet de type 't' à l'aide d'un tableau unidimensionnel dynamique de tableau unidimensionnel dynamique de 't'.
Ce qui nous donne pour un tableau de 5x5: /* on alloue un tableau de 5 pointeur d'int : */ int **p = malloc (5 * sizoef (int *)); /* puis POUR chaque element de ce tableau * on alloue un tableau de 5 int : * */ for (x = 0;x < 5;x ++){ p[x] = malloc (5 * sizeof (int)); }
Admettons que je veuille ajouter une dimension a mon tableau de 5x5, on deux solutions: une kivabien et une kivamoinsbien.
la dimension kivabien: ---------------------- on realloue le tableau de pointeur: p = realloc (p, 6 * sizeof (int *)); et on alloue un tableau de 5 nouvelles cases: p[5] = malloc (5 * sizeof (int);
Sur le schema ca revient a rajouter une case au tableau d'où partent les fléches.
la dimension kivamoinsbien: -------------------------- On réajuste chaque element du tableau de pointeur pour rajouter une case : for (x = 0;x < 5;x ++){ p[x] = realloc (p[x], 6 * sizeof (int)); }
Sur le schema, ca revient à rajouter une case à chaque tableau d'où arrivent les flèches.
Sinon j'avais pensé à un tableau de pointeurs vers des tableaux mais je ne
sais pas comment manipuler cela. C'est ca.
Merci pour vos eclaircissements. J'ai tendance à rendre les choses simples compliquées :'(. J'aimerai
être plus pédagogique.
-- Marc.
PS: j'ai volontairement ignoré les echecs des fonctions *alloc().
http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc0012.html#q_10 est ton ami.
