Discussion :

[akoie]

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 :

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
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 !

[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

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

[akoie]

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

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 :

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

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.

[foetus]

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 :

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
#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 :

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
#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 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.

[akoie]

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 :

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
#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 :

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
#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.

[Sve@r]

Bonjour

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 c :

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

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'...)

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 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
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.

[foetus]

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

Il y a 1 4^ième possibilité 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)

[Sve@r]

Il y a 1 4^ième possibilité

Il y en a une 5^ième (il y en a tant...)
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 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
#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 ?) n'a pas précisé que les chaines devaient être modifiables.

[foetus]

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

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 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

[akoie]

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 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 :

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
#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;
}

[Sve@r]

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.