Sujet Précédent Sujet Suivant

Création d'une Structure (débutant)

Résolu/Fermé
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017 - Modifié par pijaku le 3/01/2014 à 13:20
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017 - 23 janv. 2014 à 22:33
Bonjour,

Voici la structure suivante : 

struct Mot {
    int nbLettres;
    char lettres[Mot.nbLettres];
};


La console m'indique que "Mot" à la troisième ligne n'est pas déclaré. Or "Mot" est la structure que je veux créer.
S'il n'est pas possible de faire ainsi, comment puis-je contourner le problème ?

Merci d'avance

A voir également:

4 réponses

Réponse 1 / 4
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
Modifié par [Dal] le 3/01/2014 à 12:53
Bonjour Xifly,

Ta struct ne peut utiliser la valeur de l'entier qu'elle contient qu'une fois que tu as déclaré une variable ayant pour type cette struct.

Alors, une façon de faire est de définir lettres comme étant un pointeur sur char et d'allouer dynamiquement l'espace nécessaire à la chaîne C, une fois que la struct existe.

Par exemple, comme cela : 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Mot
{
    int nbLettres;
    char * lettres;
};

int main(void)
{
    struct Mot un_mot;

    un_mot.nbLettres = 3;
    un_mot.lettres = malloc(un_mot.nbLettres + 1);
    strcpy(un_mot.lettres, "abc");
    printf("un_mot.nbLettres = %d - un_mot.lettres = %s\n",
            un_mot.nbLettres, un_mot.lettres);
    free(un_mot.lettres);

    return 0;
}



Dal
1
Réponse 2 / 4
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
Modifié par [Dal] le 3/01/2014 à 13:20
Le code ci-dessus est compatible C89.

Si tu veux utiliser une structure telle que tu l'avais envisagée au départ, et que tu peux utiliser du C99, tu peux définir un tableau de longueur variable et te passer d'utiliser malloc / free. Ta struct contenant ton tableau de longueur variable devra alors être définie dans une fonction (main, ou une autre), et utiliser une autre variable (non contenue dans la struct elle-même) pour définir la longueur variable souhaitée à la déclaration.

Voilà un exemple en C99 illustrant cet usage : 

#include <stdio.h>
#include <string.h>

int main(void)
{
    int n = 0;
    struct Mot
    {
        int nbLettres;
        char lettres[n];
    };

    n = 4;
    struct Mot un_mot;

    strcpy(un_mot.lettres, "abc");
    un_mot.nbLettres = n - 1;
    printf("un_mot.nbLettres = %d - un_mot.lettres = %s\n",
                un_mot.nbLettres, un_mot.lettres);
    printf("strlen un_mot.lettres = %d\n", strlen(un_mot.lettres));

    return 0;
}


C'est plus "opaque" pour la compréhension du code, mais c'est toi qui vois ce que tu veux (peux) faire.


Dal
0
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
Modifié par Xifly le 3/01/2014 à 17:05
J'ai réussi a comprendre le deuxième programme;
Le problème est qu'il ne marche que pour un seul mot puisque n=4 ne convient que pour "abc"
J'ai donc fait ainsi : 

#include <stdio.h>
#include <string.h>

int main(void)
{
    int n = 0;
    struct Mot
    {
        int nbLettres;
        char lettres[n];
    };


    struct Mot MARRON;
    strcpy(MARRON.lettres, "MARRON");
    n = strlen(MARRON.lettres);
    MARRON.nbLettres = n;
    printf("MARRON.nbLettres = %d - MARRON.lettres = %s\n", MARRON.nbLettres, MARRON.lettres);
    printf("strlen MARRON.lettres = %d\n", strlen(MARRON.lettres));

    return 0;
}

ça a l'air de convenir.

Merci
0
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
3 janv. 2014 à 17:00
Le problème est qu'ici je dois changer le n pour chaque structure mot ... or j'aimerais que cela se fasse automatiquement ...
Ici je voudrais que ce soit le uniquement le n du mot marron qui soit égale à strlen(MARRON.lettres
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
Modifié par [Dal] le 3/01/2014 à 17:08
Les prototypes de strcpy() et strlen() sont définis dans string.h. Dans ce code c'est juste utilisé pour mettre quelque chose dans la chaîne C et illustrer ce qui se passe.

Si tu ne veux pas utiliser les pointeurs mais que tu peux faire du C99 (avec gcc ajoute -std=c99 à tes options de compilation), alors utilise un code selon les indications ci-dessus https://forums.commentcamarche.net/forum/affich-29423778-creation-d-une-structure-debutant#2 et documentes que tu fais du C99.

Je ne peux pas te dire si cela répond à ce que demande ton prof car je ne connais pas l'énoncé de la question et je me suis contenté de répondre à ta question.

Cela dit, je ne vois pas l'intérêt, dans la vie réelle, de créer une structure contenant la longueur d'un mot pour faire un jeu de pendu, alors qu'il est si simple de déterminer la longueur avec strlen(). Le seul intérêt de ce genre de choses serait pour des applications ayant intensivement et répétitivement besoin de tester la taille de chaînes, et pour lesquelles précalculer et stocker la taille en mémoire permettrait d'améliorer les performances en temps d'exécution.

Pour un dictionnaire de mots à utiliser pour un "pendu", si tu as plusieurs mots à gérer, le plus simple est de faire un tableau de chaînes C et de calculer leur taille avec strlen lorsque tu en as besoin, et de laisser tomber ta struct.


Dal
0
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
Modifié par Xifly le 3/01/2014 à 17:05
Finalement ça a l'air de convenir : 

#include <stdio.h>
#include <string.h>

int main()
{
    int n = 0;
    struct Mot
    {
        int nbLettres;
        char lettres[n];
    };


    struct Mot MARRON;
    strcpy(MARRON.lettres, "MARRON");
    n = strlen(MARRON.lettres);
    MARRON.nbLettres = n;
    printf("MARRON.nbLettres = %d - MARRON.lettres = %s\n", MARRON.nbLettres, MARRON.lettres);
    printf("strlen MARRON.lettres = %d\n", strlen(MARRON.lettres));

    struct Mot CACAHUETE;
    strcpy(CACAHUETE.lettres, "CACAHUETE");
    n = strlen(CACAHUETE.lettres);
    CACAHUETE.nbLettres = n;
    printf("CACAHUETE.nbLettres = %d - CACAHUETE.lettres = %s\n", CACAHUETE.nbLettres, CACAHUETE.lettres);
    printf("strlen CACAHUETE.lettres = %d\n", strlen(CACAHUETE.lettres));

    return 0;
}
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
3 janv. 2014 à 17:10
as-tu lu ceci : https://forums.commentcamarche.net/forum/affich-29423778-creation-d-une-structure-debutant#7 ?
0
Réponse 3 / 4
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
7 janv. 2014 à 00:31
Voilà à peu près à quoi ressemblera mon programme, merci de m'avoir aidé ! :D 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void)
{
    //Initialisation
    int i = 0;
    char lettre;
    int coupsRestants = 10;
    int bonneLettre = 0;
    FILE* fichier = NULL;
    #define TAILLE_MAX 1000
    char motAtrouver[TAILLE_MAX] = "";
    fichier = fopen("dictionnaire.txt", "r");
    int nombre_mots = 0;
    int caractereActuel = 0;
    int nombre_aleatoire = 0;


    if (fichier != NULL)
    {
        do
        {
            caractereActuel = fgetc(fichier);
            if (caractereActuel == '\n')
                {
                    nombre_mots = nombre_mots + 1; //on comptabilise le nombre de mots dans le dictionnaire
                }
        } while (caractereActuel != EOF);

        fseek(fichier, 0, SEEK_SET); //On remet le pointeur au début du fichier

        int nombre_aleatoire = rand() % nombre_mots; //On choisi un nombre aléatoire compris entre 0 et le nombre de mots

        while (nombre_aleatoire > 0)
        {
            caractereActuel = fgetc(fichier);
            if (caractereActuel == '\n')
            {
                nombre_aleatoire = nombre_aleatoire - 1;
            }
        }
        fgets(motAtrouver, TAILLE_MAX, fichier); //on va chercher le mot aléatoire
        motAtrouver[strlen(motAtrouver) - 1] = '\0'; //on supprime le retour à la ligne et on ferme la chaine

        fclose(fichier); //on referme le dictionnaire
    }
    else
    {
        printf("Impossible d'ouvrir le dictionnaire");
    }

    //initialisation
    char lettresTrouvees[strlen(motAtrouver) + 1];
    int resteAtrouver = strlen(motAtrouver);


    //Initialisation de lettresTrouvees
    for (i=0 ; i < strlen(motAtrouver); i++)
    {
        lettresTrouvees[i]= '*';
    }
    lettresTrouvees[strlen(motAtrouver)] = '\0';



    while (coupsRestants > 0 & resteAtrouver > 0)
    {
        system("cls");
        printf("\nVoici le mot a trouver : %s \n\n", lettresTrouvees);
        printf("Il vous reste %d chance(s)\n\n", coupsRestants);
        printf("Quelle lettre choississez-vous ? ");
        //scanf(" %c",&lettre);
        lettre = getchar(); //mémorise la lettre tapée
        lettre = toupper(lettre); //mise en majuscule
        while(getchar() != '\n'); //permet de comptabiliser uniquement la première lettre entrée

        for (i=0 ; i < strlen(motAtrouver); i++)
        {
            if (lettre == motAtrouver[i])
            {
                lettresTrouvees[i] = motAtrouver[i];

                bonneLettre = bonneLettre + 1; //permet de savoir si le joueur a trouvé au moins une lettre à cette manche
                resteAtrouver = resteAtrouver - 1;//permet de comptabiliser le nombre de lettre qu'il lui reste à trouver
            }
        }

        if (bonneLettre == 0)
        {
            coupsRestants = coupsRestants - 1;
        }
        bonneLettre = 0; //on remet le compteur a zéro pour chaque manche
    }

    if (resteAtrouver == 0)
    {
        system("cls");
        printf("\nVoici le mot a trouver : %s \n\n", lettresTrouvees);
        printf("Vous avez gagn\202 ! :D \n");
    }
    else
    {
        if (coupsRestants == 0)
        {
            printf("Vous avez perdu, le mot à trouver \202t\202 %s \n",motAtrouver);
        }
        else
        {
                system("cls");
        }
    }
    return 0;
}
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
Modifié par [Dal] le 7/01/2014 à 14:11
Avant d'utiliser rand, tu devrais l'initialiser en appelant srand au début de ton programme (pas dans ta boucle). Vois cet exemple : http://www.cplusplus.com/reference/cstdlib/rand/ qui utilise de façon classique time pour l'initialisation.

Tu devras faire #include <time.h> pour utiliser time et tu as oublié #include <ctype.h> pour toupper.

Tu as déclaré nombre_aleatoire deux fois. Tu peux supprimer l'une des deux déclarations.

Ton 
while (coupsRestants > 0 & resteAtrouver > 0)
est faux, car tu veux certainement dire 
while ( (coupsRestants > 0) && (resteAtrouver > 0) )
(avec "&&", donc).

Quelques petites remarques.

Tu comptes le nombre de mots disponibles dans dictionnaire.txt en décomptant le nombre de '\n' qu'il contient. Cela décomptera un nombre exact si tous les mots, y compris le dernier, sont terminés par un retour à la ligne (ce qui veut dire que dictionnaire.txt doit se terminer par une ligne vide).

Ton dictionnaire doit être en lettres majuscules. C'est un choix, mais s'il contient des caractères accentués, toupper ne les transformera pas et tu devras les inclure en minuscules dans dictionnaire.txt (par exemple : éCOLE).


Dal
0
Réponse 4 / 4
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
22 janv. 2014 à 22:17
Voici le rendu final : 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>


char flettre (char lettre)
{
    int ascii = 0;
    lettre = toupper(lettre); //mise en majuscule
    while(getchar() != '\n'); //permet de comptabiliser uniquement la première lettre entrée
    ascii = lettre;


        while ( (ascii < 65) || (ascii > 90) )
        {
            printf("\nVotre caract\212re n'est pas valide.\nVous devez entrer une lettre.\nLes accents ne sont pas pris en compte.\n\nVeuillez saisir une nouvelle lettre : ");
            lettre = getchar(); //mémorise la lettre tapée
            lettre = toupper(lettre); //mise en majuscule
            while(getchar() != '\n'); //permet de comptabiliser uniquement la première lettre entrée
            ascii = lettre;
        }

return (lettre);
}



int main(void)
{
    //Initialisation
    int i = 0;

    char lettre;
    int coupsRestants = 10;
    int bonneLettre = 0;
    int ascii = 0;
    FILE* fichier = NULL;
    #define TAILLE_MAX 1000
    char motAtrouver[TAILLE_MAX] = "";
    fichier = fopen("dictionnaire.txt", "r");
    int nombre_mots = 0;
    int caractereActuel = 0;
    char lettre_utilisees[26];


        //Initialiser la graine aléatoire:
        srand (time (NULL));


        if (fichier != NULL)
        {
            do
            {
                caractereActuel = fgetc(fichier);
                if (caractereActuel == '\n')
                {
                    nombre_mots = nombre_mots + 1; //on comptabilise le nombre de mots dans le dictionnaire
                }
            } while (caractereActuel != EOF);

            fseek(fichier, 0, SEEK_SET); //On remet le pointeur au début du fichier

            int nombre_aleatoire = rand() % nombre_mots; //On choisi un nombre aléatoire compris entre 0 et le nombre de mots

            while (nombre_aleatoire > 0)
            {
                caractereActuel = fgetc(fichier);
                if (caractereActuel == '\n')
                {
                    nombre_aleatoire = nombre_aleatoire - 1;
                }
            }
            fgets(motAtrouver, TAILLE_MAX, fichier); //on va chercher le mot aléatoire
            motAtrouver[strlen(motAtrouver) - 1] = '\0'; //on supprime le retour à la ligne et on ferme la chaine

            fclose(fichier); //on referme le dictionnaire
        }

        else
        {
            printf("Impossible d'ouvrir le dictionnaire");
        }

        //initialisation
        char lettresTrouvees[strlen(motAtrouver) + 1];
        int resteAtrouver = strlen(motAtrouver);

        //Initialisation de lettresTrouvees
        for (i=0 ; i < strlen(motAtrouver); i++)
        {
            lettresTrouvees[i]= '*';
        }
        lettresTrouvees[strlen(motAtrouver)] = '\0';

        //Initialisation de lettre_utilises
        for (i=0 ; i < strlen(lettre_utilisees); i++)
        {
            lettre_utilisees[i]= '-';
        }
        lettre_utilisees[strlen(lettre_utilisees)] = '\0';

        while ( (coupsRestants > 0) && (resteAtrouver > 0) )
        {
            system("cls");

            switch(coupsRestants)
            {
            case 1 :
                printf("___________________\n");
                printf("|                 |\n");
                printf("|    __________   |\n");
                printf("|    | /     |    |\n");
                printf("|    |/      8    |\n");
                printf("|    |     (O.o)  |\n");
                printf("|    |     /( )\\  |\n");
                printf("|    |      /     |\n");
                printf("| ___|___         |\n");
                printf("|_________________|\n");
                break;
            case 2 :
                printf("___________________\n");
                printf("|                 |\n");
                printf("|    __________   |\n");
                printf("|    | /     |    |\n");
                printf("|    |/      8    |\n");
                printf("|    |     (O.o)  |\n");
                printf("|    |     /( )\\  |\n");
                printf("|    |            |\n");
                printf("| ___|___         |\n");
                printf("|_________________|\n");
                break;
            case 3 :
                printf("___________________\n");
                printf("|                 |\n");
                printf("|    __________   |\n");
                printf("|    | /     |    |\n");
                printf("|    |/      8    |\n");
                printf("|    |     (O.o)  |\n");
                printf("|    |     /( )   |\n");
                printf("|    |            |\n");
                printf("| ___|___         |\n");
                printf("|_________________|\n");
                break;
            case 4 :
                printf("___________________\n");
                printf("|                 |\n");
                printf("|    __________   |\n");
                printf("|    | /     |    |\n");
                printf("|    |/      8    |\n");
                printf("|    |     (O.o)  |\n");
                printf("|    |      ( )   |\n");
                printf("|    |            |\n");
                printf("| ___|___         |\n");
                printf("|_________________|\n");
                break;
            case 5 :
                printf("___________________\n");
                printf("|                 |\n");
                printf("|    __________   |\n");
                printf("|    | /     |    |\n");
                printf("|    |/      8    |\n");
                printf("|    |     (O.o)  |\n");
                printf("|    |            |\n");
                printf("|    |            |\n");
                printf("| ___|___         |\n");
                printf("|_________________|\n");
                break;
            case 6:
                printf("___________________\n");
                printf("|                 |\n");
                printf("|    __________   |\n");
                printf("|    | /     |    |\n");
                printf("|    |/      8    |\n");
                printf("|    |            |\n");
                printf("|    |            |\n");
                printf("|    |            |\n");
                printf("| ___|___         |\n");
                printf("|_________________|\n");
                break;
            case 7:
                printf("___________________\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|    |            |\n");
                printf("|    |            |\n");
                printf("|    |            |\n");
                printf("|    |            |\n");
                printf("|    |            |\n");
                printf("| ___|___         |\n");
                printf("|_________________|\n");
                break;
            case 8:
                printf("___________________\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("| ___ ___         |\n");
                printf("|_________________|\n");
                break;
            case 9:
                printf("___________________\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|_________________|\n");
                break;
            case 10:
                printf("___________________\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|                 |\n");
                printf("|_________________|\n");
                break;
            }

            printf("\nVoici le mot a trouver : %s \n\n", lettresTrouvees);
            printf("Il vous reste %d chance(s)\n\n", coupsRestants);

            printf("Vous avez déja utilisé les lettres suivantes :");
            for (i=0 ; i < strlen(lettre_utilisees) ; i++)
            {
                if (lettre_utilisees[i] != '-')
                {
                    printf("%c",lettre_utilisees[i]);
                }
            }

            printf("\n\nQuelle lettre choississez-vous ? ");
            lettre = getchar(); //mémorise la lettre tapée
            lettre = flettre(lettre);

            ascii = lettre;
            lettre_utilisees[ascii-65] = lettre;

            for (i=0 ; i < strlen(motAtrouver); i++)
            {
                if (lettre == motAtrouver[i])
                {
                    lettresTrouvees[i] = motAtrouver[i];

                    bonneLettre = bonneLettre + 1; //permet de savoir si le joueur a trouvé au moins une lettre à cette manche
                    resteAtrouver = resteAtrouver - 1;//permet de comptabiliser le nombre de lettre qu'il lui reste à trouver
                }
            }

            if (bonneLettre == 0)
            {
                coupsRestants = coupsRestants - 1;
            }
            bonneLettre = 0; //on remet le compteur a zéro pour chaque manche

            if (resteAtrouver == 0)
            {
                printf("\nVous avez gagn\202 ! :D \n");
            }
        }

        if (coupsRestants ==0)
        {
            system("cls");

            printf("___________________\n");
            printf("|                 |\n");
            printf("|    __________   |\n");
            printf("|    | /     |    |\n");
            printf("|    |/      8    |\n");
            printf("|    |     (O.o)  |\n");
            printf("|    |     /( )\\  |\n");
            printf("|    |      / \\   |\n");
            printf("| ___|___         |\n");
            printf("|_________________|\n\n");

            printf("Vous avez perdu, le mot \205 trouver \202t\202 %s \n",motAtrouver);

        }


return 0;
}
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 835
22 janv. 2014 à 22:44
C'est mieux, mais c'est loin d'être le top. D'une manière générale, tu n'utilises pas assez de fonctions(). Du coup ton programme n'est pas lisible.

Ci-dessous quelques remarques pour améliorer ton code. Ce n'est pas exhaustif, j'ai pas lu jusqu'à la fin (ne sachant pas si t'allais tenir compte des remarques ;-)).

#define TAILLE_MAX 1000
C'est moche de mettre ça dans le main. La place est plutôt après les #include.

On aurait préféré plus de fonctions pour l'affichage de pendu (printf()). C'est beaucoup plus propre, et cela allège le main(). Une autre fonction aussi aurait dû être faite pour compter le nombre de lignes dans le fichier.

if (caractereActuel == '\n')
{
nombre_mots = nombre_mots + 1; //on comptabilise le nombre de mots dans le dictionnaire
}
} while (caractereActuel != EOF);
Attention, à bien compter le dernier mot si le fichier ne se termine pas par une ligne vide. T'aurais pu utiliser des fgets(), plus performant pour lire une ligne.

while (nombre_aleatoire > 0)
{
caractereActuel = fgetc(fichier);
if (caractereActuel == '\n')
{
nombre_aleatoire = nombre_aleatoire - 1;
}
}
Pas très lisible fonctionnellement. 
while(nombre_aleatoire >= 0 && fgets(motAtrouver, TAILLE_MAX, fichier) != NULL) {
      nombre_aleatoire--;
}


fseek(fichier, 0, SEEK_SET);
Ou rewind(); tout simplement :-).

int nombre_aleatoire
Généralement, on met les déclarations en début de bloc.

char lettresTrouvees[strlen(motAtrouver) + 1];
Même remarque, plutôt à mettre en début de bloc. La syntaxe que tu utilises n'est pas conseillé (fonctionnalité C99...). Utilise plutôt malloc().

motAtrouver[strlen(motAtrouver) - 1] = '\0'; //on supprime le retour à la ligne et on ferme la chaine
Bof. Cela ne supprime pas le retour à la ligne mais le dernier caractère. La différence se fera ressentir pour le dernier mot du fichier (sauf s'il y a une ligne vide après).
Généralement, on utilise char *p; if ((p = strchr(motAtrouver,'\n')) != NULL) *p='\0';
Bien sûr, dans une fonction, c'est encore mieux :-).

Bon courage,
Cdlt,
0
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
Modifié par Xifly le 22/01/2014 à 23:32
Ah oui ça j'ai remarqué que j'utilisé pas assez de fonctions ... mais j'avoue avoir un peu de mal encore avec celà :S
Sinon oui oui, toutes remarques sont bonnes à prendre, surtout à mon niveau :)
J'essaie de corriger tout ceci ;)
Merci pour tout
Et sinon oui, mon dictionnaire se termine par une ligne vide
0
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
22 janv. 2014 à 23:43
Mettre la lecture du dictionnaire en fonction donnerais qqch comme ceci ? (sachant qu'il dois y avoir une erreur quelque part) : 

char fmotAtrouver (FILE* fichier, char motAtrouver)
{
    int caractereActuel = 0;
    int nombre_mots = 0;
    char *p;
    int nombre_aleatoire = 0;

    if (fichier != NULL)
    {
        do
        {
            caractereActuel = fgetc(fichier);
            if (caractereActuel == '\n')
            {
                nombre_mots = nombre_mots + 1; //on comptabilise le nombre de mots dans le dictionnaire
            }
        } while (caractereActuel != EOF);

        rewind(fichier); //On remet le pointeur au début du fichier

        int nombre_aleatoire = rand() % nombre_mots; //On choisi un nombre aléatoire compris entre 0 et le nombre de mots

        while(nombre_aleatoire >= 0 && fgets(motAtrouver, TAILLE_MAX, fichier) != NULL)
            {
                nombre_aleatoire--;
            }
        fgets(motAtrouver, TAILLE_MAX, fichier); //on va chercher le mot aléatoire
           if ((p = strchr(motAtrouver,'\n')) != NULL) *p='\0';  //on supprime le retour à la ligne et on ferme la chaine

        fclose(fichier); //on referme le dictionnaire
    }

    else
    {
        printf("Impossible d'ouvrir le dictionnaire");
    }
return motAtrouver;
}
0
[Dal] Messages postés 6174 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 2 février 2024 1 083
23 janv. 2014 à 10:48
Salut Xifly,

Le prototype de ta fonction sera plutôt 
void fmotAtrouver(FILE* fichier, char * motAtrouver)


Tu passes motAtrouver qui est un tableau de char. Lorsqu'il est passé à la fonction de cette façon 
fmotAtrouver(fichier, motAtrouver);
, ce que tu passes, c'est le pointeur vers le premier élément du tableau. Vu que tu passes un pointeur, ta fonction va pouvoir directement modifier la variable et tu n'as pas besoin de return.

Tu n'as pas retiré la double déclaration de nombre_aleatoire que je te signalais. Supprime, par exemple la première 
int nombre_aleatoire = 0;
, qui n'est, en fait, pas utilisée dans ton code.

Personnellement, je n'incluerai pas dans la fonction la vérification de l'ouverture correcte du fichier si la fonction n'a pas pour tâche d'ouvrir le fichier. Cela disperse le code pertinent.


Dal
0
Xifly Messages postés 44 Date d'inscription vendredi 3 janvier 2014 Statut Membre Dernière intervention 8 décembre 2017
23 janv. 2014 à 14:55
Donc ma fonction est la suivante : 
void fmotAtrouver(FILE* fichier, char * motAtrouver)
{
    int caractereActuel = 0;
    int nombre_mots = 0;
    char *p;


    do
    {
        caractereActuel = fgetc(fichier);
        if (caractereActuel == '\n')
        {
            nombre_mots = nombre_mots + 1; //on comptabilise le nombre de mots dans le dictionnaire
        }
    } while (caractereActuel != EOF);

    rewind(fichier); //On remet le pointeur au début du fichier

    int nombre_aleatoire = rand() % nombre_mots; //On choisi un nombre aléatoire compris entre 0 et le nombre de mots

    while(nombre_aleatoire >= 0 && fgets(motAtrouver, TAILLE_MAX, fichier) != NULL)
    {
        nombre_aleatoire--;
    }
    fgets(motAtrouver, TAILLE_MAX, fichier); //on va chercher le mot aléatoire

    if ((p = strchr(motAtrouver,'\n')) != NULL) *p='\0';  //on supprime le retour à la ligne et on ferme la chaine

    fclose(fichier); //on referme le dictionnaire

    return motAtrouver;
}



J'appelle ma fonction en faisant ainsi : 
        if (fichier != NULL)
        {
            fmotAtrouver(motAtrouver);
        }
        else
        {
            printf("Impossible d'ouvrir le dictionnaire");
        }


Mais la console m'indique encore une erreur ... J'avoue que là je suis un peu dépassé, je ne comprend pas trop où est l'erreur
0