C - l'extraction de mots à partir de la chaîne

Je suis assez nouveau dans C et donc de rencontrer un peu de confusion avec l'aide de pointeurs.

Je suis d'essayer d'extraire des mots à partir d'une chaîne de caractères ASCII.
Par exemple, si j'ai la chaîne @@Bonjour..monde>>, je veux obtenir les mots "Bonjour" et "monde" de la chaîne et de les ajouter à ma liste liée.

Un mot est défini comme une séquence de lettres, et chaque mot est à plus de 64 octets. Aussi, le caractère et la fonction isspace() renvoie une valeur non nulle est considérée comme un espace.

En gros, je suis la numérisation dans les chaînes de caractères à partir d'un fichier à l'aide de fscanf, ensuite, pour chaque chaîne de l'appel de ma fonction read_words(char *s) pour obtenir les mots appropriés de la chaîne et de les ajouter à ma liste liée pour une utilisation ultérieure.

Voici mon code qui semble être de lancer une erreur qui a à voir avec un pointeur. 

struct node {
    char *val;
    struct node *next;
    int count;
} *words = NULL;


void read_words(char *s)
{
    struct node *tmp;
    char word[64+1];
    int i, check, wordStarted = 0, count = 0;

    for (i = 0; s[i] != '
struct node {
char *val;
struct node *next;
int count;
} *words = NULL;
void read_words(char *s)
{
struct node *tmp;
char word[64+1];
int i, check, wordStarted = 0, count = 0;
for (i = 0; s[i] != '\0'; i++)
{
if ((isspace(s[i]) != 0) || !isalpha(s[i]))
{
if (wordStarted == 1)
{
check = check_list(word);
if (check != 1) {
word[count] = '\0';
tmp = malloc(sizeof(struct node));
tmp->val = word;
tmp->count = 1;
tmp->next = words;
words = tmp;
}
count = 0;
wordStarted = 0;
}
}
else
{
word[count++] = s[i];
wordStarted = 1;
}
}
}
'; i++)
    {
            if ((isspace(s[i]) != 0) || !isalpha(s[i]))
            {
                    if (wordStarted == 1)
                    {
                            check = check_list(word);
                            if (check != 1) {
                                    word[count] = '
struct node {
char *val;
struct node *next;
int count;
} *words = NULL;
void read_words(char *s)
{
struct node *tmp;
char word[64+1];
int i, check, wordStarted = 0, count = 0;
for (i = 0; s[i] != '\0'; i++)
{
if ((isspace(s[i]) != 0) || !isalpha(s[i]))
{
if (wordStarted == 1)
{
check = check_list(word);
if (check != 1) {
word[count] = '\0';
tmp = malloc(sizeof(struct node));
tmp->val = word;
tmp->count = 1;
tmp->next = words;
words = tmp;
}
count = 0;
wordStarted = 0;
}
}
else
{
word[count++] = s[i];
wordStarted = 1;
}
}
}
';
                                    tmp = malloc(sizeof(struct node));
                                    tmp->val = word;
                                    tmp->count = 1;
                                    tmp->next = words;
                                    words = tmp;
                            }
                            count = 0;
                            wordStarted = 0;
                    }
            }
            else
            {
                    word[count++] = s[i];
                    wordStarted = 1;
            }
    }

}

Toute aide avec ce serait bien apprécié!

Merci!

  • Essayez strtok. Il divise une chaîne en pièces fondée sur un certain nombre de fractionnement des personnages.
  • Avez-vous essayé de debug de votre code?
  • merci de poster votre check_list() de la mise en œuvre
  • Aussi, vous pouvez juste dire if(isspace(s[i])) au lieu de if(isspace(s[i]) != 0). Rien à votre problème, juste l'écriture nettoyeur de code 😉
  • vous savez que votre algorithme est d'écraser les tmp->val chaque itération suivante de droite? Utilisation strtok, malloc tmp->val, et strcpy le jeton.
InformationsquelleAutor Shabu | 2012-03-09
  1. 6

    Vous aurez envie de marquer la chaîne, au lieu de la mise en œuvre de votre propre algorithme et ajouter les pièces à votre liste liée. Utilisation strtok (ref).

    À partir du lien ci-dessus.. exemple:

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

int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
  {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
  }
  return 0;
}

    De sortie:

    Splitting string "- This, a sample string." into tokens:
This
a
sample
string
    • C'est génial, fonctionne perfectlty pour l'analyse des arguments de ligne de commande avec un peu de peaufinage.
    InformationsquelleAutor Mario Aguilera
  2. 1

    Meilleure solution pour La norme ANSI C.

    Utilisation strtok() il n'est pas toujours bonne:

    1. il va changer l'origine de tableau.
    2. séparateur de l'espace", " ignorer les caractères similaires: "\n", "\t" et d'autres.

    Essayer la prochaine et lire les commentaires pour plus de détails:

    #include <stdio.h>      //printf
#include <string.h>     //strlen, strncpy
#include <ctype.h>      //isalnum
#include <stdlib.h>     //malloc, calloc
/*
A logical type
*/
typedef enum {
false,
true,
} bool;
/*
A Struct for hold 2D-array with count items
*/
typedef struct _ListWithLength {
char **list;
size_t length;
} ListWithLength;
/*
Parse a text and return pointer to a ListWithLength words and count it
*/
ListWithLength* getWords(char *text) {
//a variable for count words
int count = 0;
//keep length of the text
size_t text_len = strlen(text);
//a flag indicating the a beginning of a word
bool new_word = false;
//an index of a start found a word
int index_start_word = 0;
//2D-array for found word
//it will be same memory size as the original text
char **words = malloc(text_len * sizeof(char));
for (int i = 0; i <= text_len; ++i) {
//if found ascii letter or digits and new no traced early
//keep index of beginning a new word
//and change the flag
if (isalnum(text[i]) != 0) {
if (new_word == false) {
new_word = true;
index_start_word = i;
}
//if it is not ascii letter or digits and a word traced early
//it means the word ended
} else {
if (new_word == true) {
//allocate a memory for a new word in the array of words
words[count] = malloc(i - index_start_word * sizeof(char) + 1);
//copy the found word from the text by indexes
strncpy(words[count], text + index_start_word, i - index_start_word);
//change the flag
new_word = false;
//increase the counter of words
count++;
}
};
}
//bind the found words and it count to a structure and return it
ListWithLength *list_with_length = malloc(sizeof(ListWithLength));
list_with_length->length = count;
list_with_length->list = words;
return list_with_length;
}
/*
Print information of a ListWithLength
*/
void printListWithLength(ListWithLength *list_with_length) {
printf("Total items: %li\n", list_with_length->length);
puts("----------------------");
for (int i = 0; i < list_with_length->length; ++i) {
printf("%d. %s\n", i + 1, list_with_length->list[i]);
}
}
int main(int argc, char const *argv[])
{
char c_keywords[300] = "auto else    long    switch\
break\t   enum \t register    typedef\
\ncase    extern,  return  union\
?char    float.   short   unsigned\
const   !for signed  void\
continue    goto    sizeof  volatile\
.default???? if  static  while\
do  int struct,,,,  _Packed\
double.......";
ListWithLength *list_with_length = getWords(c_keywords);
printListWithLength(list_with_length);
return 0;
}

    Compiler et voir le résultat:

    $ gcc -Wall -ansi -std=c11 -o main main.c
$ ./main 
Total items: 33
----------------------
1. auto
2. else
3. long
4. switch
5. break
6. enum
7. register
8. typedef
9. case
10. extern
11. return
12. union
13. char
14. float
15. short
16. unsigned
17. const
18. for
19. signed
20. void
21. continue
22. goto
23. sizeof
24. volatile
25. default
26. if
27. static
28. while
29. do
30. int
31. struct
32. Packed
33. double
    InformationsquelleAutor Seti Volkylany