Mettre des tableaux de caractère/mot dans un tableau

Version imprimable

Bonjour à tous,

Je souhaitais savoir comment intégrer un tableau de caractère/mot à un tableau, ça fait un moment que je suis bloqué dessus et je n'arrive pas à trouver de solution.
Ma fonction est commenté afin qu'elle puisse être le plus compréhensible possible.

Code:

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
char* chargementMotFR(){
    char tmp[35]; //Buffer afin de garder le temps nécessaire les mots sortis du fichier
    char tab[591]; //tableau final à retourner avec 591 mots/tableau de caractère
    int cpt=0; //cpt pour se situer dans le tableau
    FILE* fichier=fopen("mot.csv","r");
    if (fichier==NULL)
        printf("Erreur d'ouverture de fichier \n");
    else{
        while(fgets(tmp,35,fichier)!=NULL){
                char * pch=strtok(tmp,","); //séparateur des 2 colonnes
                char * tmpS;
                while (pch!=NULL){
                        tmpS=strtok(pch," "); //récupération du mot voulu (ici présent dans la première colonne)
                        &tab[cpt]=(char*) malloc(20*sizeof(char)); //tentative de mettre le mot dans le tableau
                        printf("%s \n",tmpS);
                        pch=strtok(NULL,",");
                        free(tab[cpt]);
                        printf("%s lll \n",tab[cpt]);
 
                }
        cpt++;
        }
    }
    fclose(fichier);
 
}

Merci à vous !

03/12/2022, 03h00
foetus

Tu n'as besoin de malloc ... pour copier ta chaîne de caractères.
Mais effectivement, tu ne peux pas retourner 1 variable locale :whistle:

Sinon utilise strcpy ou strncpy et avance ton pointeur de strlen (<- 3 liens cplusplus en anglais)
Regarde l'entête string.h
03/12/2022, 03h17
akoie

Citation:

Envoyé par foetus

Tu n'as besoin de malloc ... pour copier ta chaîne de caractères.
Mais effectivement, tu ne peux pas retourner 1 variable locale :whistle:

Sinon utilise strcpy ou strncpy et avance ton pointeur de strlen (<- 3 liens cplusplus en anglais)
Regarde l'entête string.h

J'ai sûrement mal expliquer ma problématique, ou mal compris ta réponse.

Je souhaiterai que un mot comme "ananas" soit mis par exemple en position 0. Puis le mot "carotte" en position 2 dans un tableau avec 591 mots disponibles, et chaque mots comporterait maximum 20 caractère.
De base j'avais essayé de faire un tableau du type :

Code:

char tab[591][20]

et d'intégrer le mot dans le 2e tableau de taille 20 (donc un mot de maximum taille 20), et qui irait lui même à la position 0,1,2,3,4,5,6,.... du tableau de taille 591.
Je n'arrive pas à voir comment faire.

Citation:

Envoyé par akoie

Je souhaiterai que un mot comme "ananas" soit mis par exemple en position 0. Puis le mot "carotte" en position 2 dans un tableau avec 591 mots disponibles, et chaque mots comporterait maximum 20 caractère.

Tu as 2 façons de faire (attention sûrement plantogène et fixé à 3 mots parmi 5)

Première façon, 1 tableau de chaîne de caractères:

Code:

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
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#define G_MAX_WORDS 5
 
 
char** loading_words_fr()  {
    char** tabs = malloc(G_MAX_WORDS * sizeof(char*));
 
    if (tabs != NULL) {
        memset(tabs, 0, G_MAX_WORDS * sizeof(char*));
 
//      Copy with strcpy
        tabs[0] = malloc(20 * sizeof(char));
        if (tabs[0] != NULL) { strcpy(tabs[0], "carotte"); tabs[0][7] = '\0'; }
 
//      Copy with strncpy
        tabs[2] = malloc(20 * sizeof(char));
        if (tabs[2] != NULL) { strncpy(tabs[2], "ananas", 6); tabs[2][6] = '\0'; }
 
        tabs[3] = malloc(20 * sizeof(char));
        if (tabs[3] != NULL) { tabs[3][0] = '\0'; }
    }
 
    return tabs;
}
 
 
int main()
{
    char** tabs = loading_words_fr();
 
    if (tabs != NULL) {
        size_t w;
 
        for(w=0; w < G_MAX_WORDS; ++w) { printf("%lu: %s\n", (w + 1), ((tabs[w] != NULL)? tabs[w]: "[NULL]")); }
 
        for(w=0; w < G_MAX_WORDS; ++w) { if (tabs[w] != NULL) { free(tabs[w]); } }
 
        free(tabs);
    }
 
 
    return EXIT_SUCCESS;
}

Deuxième façon, 1 gros tableau de caractères:

Code:

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
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#define G_MAX_LEN_WORDS 20
#define G_MAX_WORDS      5
 
 
char* loading_words_fr()  {
    char* tabs = malloc(G_MAX_WORDS * G_MAX_LEN_WORDS /* * sizeof(char) */);
 
    if (tabs != NULL) {
        memset(tabs, '\0', (G_MAX_WORDS * G_MAX_LEN_WORDS /* * sizeof(char) */));
 
//      Copy with strcpy
        strcpy(tabs, "carotte"); /* *(tabs + 7) = '\0'; */
 
//      Copy with strncpy
        strncpy((tabs + 2*G_MAX_LEN_WORDS), "ananas", 6); /* *(tabs + 2*G_MAX_LEN_WORDS + 6) = '\0'; */
 
        *(tabs + 4*G_MAX_LEN_WORDS) = '9'; /* *(tabs + 4*G_MAX_LEN_WORDS + 1) = '\0'; */
    }
 
    return tabs;
}
 
 
int main()
{
    char* tabs = loading_words_fr();
 
    if (tabs != NULL) {
        size_t w; char* tmp;
 
        for(w=0, tmp=tabs; w < G_MAX_WORDS; ++w, tmp+=G_MAX_LEN_WORDS) { printf("%lu: %s\n", (w + 1), tmp); }
 
        free(tabs);
    }
 
 
    return EXIT_SUCCESS;
}

Édit 1: il faut les sizeof pour initialiser avec memset ... je ne le sais jamais :oops: mais au debugger on le voit.
Édit 2: @Sve@r, le VDD (Voisin Du Dessous) me signale que je prends en compte 19 caractères et non 20 (à cause de la sentinelle '\0') Effectivement, mais mon code illustre juste 2 idées et il n'est pas à prendre tel quel.

Citation:

Envoyé par foetus

Tu as 2 façons de faire (attention sûrement plantogène et fixé à 3 mots parmi 5)

Première façon, 1 tableau de chaîne de caractères:

Code:

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
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#define G_MAX_WORDS 5
 
 
char** loading_words_fr()  {
    char** tabs = malloc(G_MAX_WORDS * sizeof(char*));
 
    if (tabs != NULL) {
        memset(tabs, 0, G_MAX_WORDS);
 
//      Copy with strcpy
        tabs[0] = malloc(20 * sizeof(char));
        if (tabs[0] != NULL) { strcpy(tabs[0], "carotte"); tabs[0][7] = '\0'; }
 
//      Copy with strncpy
        tabs[2] = malloc(20 * sizeof(char));
        if (tabs[2] != NULL) { strncpy(tabs[2], "ananas", 6); tabs[2][6] = '\0'; }
 
        tabs[3] = malloc(20 * sizeof(char));
        if (tabs[3] != NULL) { tabs[3][0] = '\0'; }
    }
 
    return tabs;
}
 
 
int main()
{
    char** tabs = loading_words_fr();
 
    if (tabs != NULL) {
        size_t w;
 
        for(w=0; w < G_MAX_WORDS; ++w) { printf("%lu: %s\n", (w + 1), ((tabs[w] != NULL)? tabs[w]: "[NULL]")); }
 
        for(w=0; w < G_MAX_WORDS; ++w) { if (tabs[w] != NULL) { free(tabs[w]); } }
 
        free(tabs);
    }
 
 
    return EXIT_SUCCESS;
}

Deuxième façon, 1 gros tableau de caractères:

Code:

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
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#define G_MAX_LEN_WORDS 20
#define G_MAX_WORDS      5
 
 
char* loading_words_fr()  {
    char* tabs = malloc(G_MAX_WORDS * G_MAX_LEN_WORDS * sizeof(char));
 
    if (tabs != NULL) {
        memset(tabs, '\0', (G_MAX_WORDS * G_MAX_LEN_WORDS));
 
//      Copy with strcpy
        strcpy(tabs, "carotte"); /* *(tabs + 7) = '\0'; */
 
//      Copy with strncpy
        strncpy((tabs + 2*G_MAX_LEN_WORDS), "ananas", 6); /* *(tabs + 2*G_MAX_LEN_WORDS + 6) = '\0'; */
 
        *(tabs + 4*G_MAX_LEN_WORDS) = '9'; /* *(tabs + 4*G_MAX_LEN_WORDS + 1) = '\0'; */
    }
 
    return tabs;
}
 
 
int main()
{
    char* tabs = loading_words_fr();
 
    if (tabs != NULL) {
        size_t w; char* tmp;
 
        for(w=0, tmp=tabs; w < G_MAX_WORDS; ++w, tmp+=G_MAX_LEN_WORDS) { printf("%lu: %s\n", (w + 1), tmp); }
 
        free(tabs);
    }
 
 
    return EXIT_SUCCESS;
}

Merci ! Je finirai d'arranger ça avec ce que j'ai besoin demain et je reviendrai vers vous.
Mais de ce que j'ai vu ça à l'air de correspondre à mon problème.

Bonjour

Citation:

Envoyé par akoie

Je souhaiterai que un mot comme "ananas" soit mis par exemple en position 0. Puis le mot "carotte" en position 2 dans un tableau avec 591 mots disponibles, et chaque mots comporterait maximum 20 caractère.
De base j'avais essayé de faire un tableau du type char tab[591][20]

Attention, en C il est d'usage de ne parler que des caractères "utiles". Un mot comme "ananas" fait donc 6 caractères. Mais il ne faut pas oublier que la chaine a besoin d'un espace particulier pour stocker le '\0'. Le mot "ananas" a donc besoin de 7 caractères pour qu'il soit stocké sans erreur.
Cet espace venant "en plus" des caractères dont tu as besoin, on écrit généralement char tab[591][20+1].
Et pour le code de foetus, on remplacera tabs[0] = malloc(20 * sizeof(char)) par tabs[0] = malloc((20 + 1) * sizeof(char)).
Ce "20+1" au lieu de "21" permet aux autres lecteurs de comprendre que tu n'as pas oublié l'espace pour le '\0'. Il permet aussi une plus grande souplesse en mettant la taille "utile" sous forme de macro
Code:

1 2 3 #define SZ_WORD (20) ... tabs[0] = malloc((SZ_WORD + 1) * sizeof(char))
Le code de foetus (allocation de N chaines) souffre d'un défaut: il demande N allocations (ici 591). Ok il a traité le cas des allocations échouées en ne remplissant que si l'allocation réussit mais il reste quand-même ce souci de devoir faire 591 allocations avec 591 échecs possibles donc 591 chaines non remplies
Il t'offre aussi une autre solution en te donnant une "super grosse zone 1D" avec un seul malloc (comme un gros damier) mais tu devras ensuite "calculer" toi-même les indices en 1D d'une chaine [x][y] pour trouver ladite chaine dans le gros damier (i=x * G_MAX_LEN_WORDS + y) et inversement (x=i/G_MAX_LEN_WORDS et y=i%G_MAX_LEN_WORDS). Faisable mais quand je vois son combat avec les maths pour se positionner dans le damier avec ses *(tabs + 4*G_MAX_LEN_WORDS + 1) = '\0' (surtout que si on rajoute la convention dont j'ai parlé, il faut alors remplacer "G_MAX_LEN_WORDS" par "G_MAX_LEN_WORDS+1" => *(tabs + 4*(G_MAX_LEN_WORDS+1) + 1) = '\0'...) :weird:

C'est pour cela qu'il y a une 3° possibilité qui offre l'avantage du gros damier tout en gardant l'avantage des adressages en [x][y] au prix de seulement 2 malloc: le premier malloc pour créer le damier, et le second pour créer un tableau (de pointeurs) qui référencera chaque mot du damier.
Ce qui donnerait
Code:

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 <stdlib.h> #include <stdio.h> #include <string.h> #define G_MAX_LEN_WORDS 20 #define G_MAX_WORDS 5 char** loading_words_fr() { // La zone de travail (le damier) char* work = malloc(G_MAX_WORDS * (G_MAX_LEN_WORDS + 1) * sizeof(*work)); if (work == NULL) return NULL; // Les pointeurs pointant vers chaque "mot" de la zone de travail char** tabs=malloc(G_MAX_WORDS * sizeof(*tabs)); if (tabs == NULL) { free(work); return NULL; } // Nécessité de faire pointer chaque "pointeur" vers la bonne position dans le damier // Ce sera là le seul moment de calcul difficile dans toute l'opération... for (size_t i=0; i < G_MAX_WORDS; i++) tabs[i]=work + i * (G_MAX_LEN_WORDS + 1); // Ouais bon, était-il réellement difficile ce calcul??? // Remplissage strcpy(tabs[0], "carotte"); strcpy(tabs[2], "ananas"); return tabs; } int main() { char **mots=loading_words_fr(); if (mots == NULL) return EXIT_FAILURE; printf("Mot 0: %s\n", mots[0]); printf("Mot 2: %s\n", mots[2]); printf("4° caractère du mot 2: %c\n", mots[2][3]); free(mots[0]); free(mots); return EXIT_SUCCESS; }
Pour le nettoyage, le premier free(mots[0]) permet de libérer le damier (car la toute première adresse du tableau de pointeurs est aussi l'adresse du damier) puis free(mots) pour libérer enfin le tableau des pointeurs.

03/12/2022, 09h50
foetus

Citation:

Envoyé par Sve@r

Faisable mais quand je vois son combat avec les maths pour se positionner dans le damier

Il y a 1 4^ième possibilité :mrgreen: faire 1 structure dictionnaire (ou nom le plus approprié)
Tu encapsules tout le code "technique" mais l'utilisateur a 1 interface propre : dictionary_load(), dictionary_get(8), dictionary_replace(15, "yalla"), ...

Mais cela n'est pas dit par @akoie

Tu as aussi 1 approche entre 2 : la macro. Par exemple, #define G_GET_WORD(DICT, N) ( *(DICT + N*(G_MAX_LEN_WORDS + 1)) ).
Mais appelant des globales ou ayant trop de paramètres, pas idéal à "ranger" dans son code ... la structure sera toujours mieux (et tu peux toujours remplacer certaines fonctions par des macros)

Citation:

Envoyé par foetus

Il y a 1 4^ième possibilité :mrgreen:

Il y en a une 5^ième (il y en a tant...:D)
On est tous deux partis du principe de "recopier" les chaines. Et pourquoi faire? Ces chaines existent dans le code, pourquoi s'embêter à les recopier alors qu'on les a déjà...???
Suffit simplement de récupérer leurs adresses...
Code:

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 #include <stdlib.h> #include <stdio.h> #include <string.h> #define G_MAX_WORDS 5 char** loading_words_fr() { // Le simple tableau de pointeurs char** tabs=malloc(G_MAX_WORDS * sizeof(*tabs)); if (tabs == NULL) return NULL; // Remplissage tabs[0]="carotte"; tabs[2]="ananas"; return tabs; } int main() { char **mots=loading_words_fr(); if (mots == NULL) return EXIT_FAILURE; printf("Mot 0: %s\n", mots[0]); printf("Mot 2: %s\n", mots[2]); printf("3° caractère du mot 2: %c\n", mots[2][3]); free(mots); return EXIT_SUCCESS; }
Valà. Plus besoin de se dire "ouh là là aurai-je assez avec 20" et autres mélodrames du même genre.
Juste qu'on ne peut pas les modifier, on est d'accord. Mais pareil, akoie (ça sert, Axelle Red :mouarf:?) n'a pas précisé que les chaines devaient être modifiables.

03/12/2022, 11h20
foetus
Citation:

Envoyé par Sve@r

On est tous deux partis du principe de "recopier" les chaines. Et pourquoi faire?

:whistle: Dans le code de son premier message
- il charge 1 fichier.
- sa fonction contient "fr". Donc on peut penser plusieurs langues, avec 1 traduction à taille fixe. Avec 1 structure qui puisse passer de l'1 à l'autre.
Édit 1: la table d'index 1 classique :mrgreen: Mais je n'y avais pas pensé ... parce que la structure dictionnaire (ou nom le + approprié) est la réponse.
Édit 2: effectivement, prendre l'addresse des chaînes de caractères "lecture seule" (.rodata) peut être pratique dans certains cas ... mais pas ici je pense

Citation:

Envoyé par foetus

:whistle: Dans le code de son premier message

il charge 1 fichier.
sa fonction contient "fr". Donc on peut penser plusieurs langues, avec 1 traduction à taille fixe. Avec 1 structure qui puisse passer de l'1 à l'autre.

Édit 1: la table d'index 1 classique :mrgreen: Mais je n'y avais pas pensé ... parce que la structure dictionnaire (ou nom le + approprié) est la réponse.
Édit 2: effectivement, prendre l'addresse des chaînes de caractères "lecture seule" (.rodata) peut être pratique dans certains cas ... mais pas ici je pense

En effet, je dois d'abord insérer les mots français dans un tableau, et les traductions dans correspondante à ce mot dans un AVL.
Je vais essayer de coller tout ça et reviendrait vers vous dès que j'aurai des nouvelles, merci beaucoup à vous !

MAJ : J'ai réussi à obtenir ce que je voulais grâce à vous. Voici le code final de ma fonction :
Code:

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 #include <stdlib.h> #include <stdio.h> #include <string.h> #define G_MAX_LEN_WORDS 20 #define G_MAX_WORDS 587 char** loading_words_fr() { char tmp[35]; FILE * fichier=fopen("mot.csv","r"); // La zone de travail (le damier) char* work = malloc(G_MAX_WORDS * (G_MAX_LEN_WORDS + 1) * sizeof(*work)); if (work == NULL) return NULL; // Les pointeurs pointant vers chaque "mot" de la zone de travail char** tabs=malloc(G_MAX_WORDS * sizeof(*tabs)); if (tabs == NULL) { free(work); return NULL; } // Nécessité de faire pointer chaque "pointeur" vers la bonne position dans le damier for (size_t i=0; i < G_MAX_WORDS; i++) tabs[i]=work + i * (G_MAX_LEN_WORDS + 1); // Remplissage int cpt=0; if (fichier==NULL) printf("Erreur d'ouverture de fichier"); else{ while (fgets(tmp,35,fichier)!=NULL){ char * pch=strtok(tmp,","); char * tmpS; while (pch!=NULL){ tmpS=strtok(pch," "); strcpy(tabs[cpt],tmpS); pch=strtok(NULL,","); } cpt++; } } return tabs; }

04/12/2022, 08h03
Sve@r

Citation:

Envoyé par akoie

Voici le code final de ma fonction

Final, final c'est vite dit. Déjà, si le fichier n'est pas ouvert tu renvoies quand-même un tableau vide (plus exactement contenant des valeurs aléatoires). De son côté, l'appelant n'ayant aucun moyen de détecter ce souci, traitera allègrement le tableau reçu et ses valeurs débiles.

Ensuite strtok() est maintenant dépréciée. Le souci inhérent à cette fonction est qu'elle utilise une variable statique pour mémoriser le travail en cours entre chaque appel. Or une variable statique étant unique pour un programme, cela interdit la réentrance. Impossible par exemple d'utiliser cette fonction dans une boucle imbriquée pour traiter des imbrications de chaines style "a/b/c:z/y/x:/titi/tata/tutu" comme les PATH en disant "je boucle pour séparer sur le deux-points puis je boucle en interne pour séparer sur le slash" car la boucle interne se mélangera avec la boucle externe.
Ok tu ne le fais pas ici donc ça fonctionne mais si tu en prends l'habitude tu arriveras tôt ou tard sur un cas où ça ne fonctionne pas. Il te faut la remplacer par strtok_r() dans laquelle tu lui passes toi-même le pointeur permettant de mémoriser son travail.
Ce qui n'est pas vraiment plus compliqué. Suffit de rajouter dans ton code un pointeur style char* work puis de remplacer strtok(tmp,",") par strtok_r(tmp, ",", &work).
Accessoirement moi je séparerais les choses. Une fonction pour créer le tableau, et une autre pour le remplir. Plus les fonctions sont "atomiques" mieux on peut les utiliser dans différentes configurations.

Et c'est quoi cette indentation ignoble? Ca ne te saute pas aux yeux tellement c'est immonde et illisible? foetus et moi on te montre divers exemples avec à chaque fois un code élégant, aéré, propre et surtout bien aligné et ben non, tu y rajoutes tes lignes avec leurs indentations anarchiques. T'en as rien à cirer de ton code et de ceux qui vont le relire? Là ça va qu'il n'y a que 10 lignes mais quand tu en auras 50 avec des boucles et alternatives et re-boucles??? Un programme ça ne se jette pas en vrac avec mollesse, un programme ça s'écrit.