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.