Je continue d'obtenir une erreur de segmentation chaque fois que j'exécute ce programme, mais je ne comprends pas pourquoi

Question

J'ai une fonction qui prend une chaîne entrée par l'utilisateur et la divise en mots individuels en utilisant un tableau bidimensionnel alloué dynamiquement. Les mots sont séparés par des délimiteurs utilisés comme indicateurs de l'endroit où un mot se termine et un autre commence.

Voici mon code:

int countWords(const char * sentence, char * delims) 
{ 
     int wordsInArray = 0; 
     int count = 0; 
     while(*(sentence + count) != '\0') 
     { 
      if(*(sentence + count) == *delims && *(sentence + count + 1) != *delims) 
      { 
       wordsInArray++; 
      } 
      if(*(sentence + count + 1) == '\0') 
      { 
       wordsInArray++; 
      } 
     count++; 
     } 
     return wordsInArray; 
} 

int getLength(const char * sentence) 
{ 
     const char *p = sentence; 
     while(*p != '\0') 
     { 
     p++; 
     } 
     return p-sentence; 
} 


char ** getWords(const char * sentence, int & wordcount) 
{ 
     char delims[] = " .,\t?!"; 
     int sentenceLength = getLength(sentence); 
     wordcount = countWords(sentence, delims); 

     char ** words; 
     words = new char *[wordcount]; 

     int length = 0; 
     int count = 0; 
     for (int a = 0; a < sentenceLength; a++) 
     { 
      if(*(sentence + a) != *delims) 
      { 
      length++; 
      } 

      else if ((*(sentence + a) == *delims && *(sentence + a + 1) != *delims) || *(sentence + a) == '\0') 
      { 
       *(words + count) = new char[length+1]; 
       for (int z = 0; z < length; z++) 
       { 
        *(*(words + count) + z) = *(sentence + z); 
       } 
       length = 0; 
       count++; 
      } 
     } 
     return words; 
} 

Cependant, ma fonction est countWords sans compter correctement les mots dans la chaîne, et je ne sais pas pourquoi.

Answer 1

Essayez quelque chose comme ceci:

int indexOf(const char * sequence, char ch) { 
    const char *p = sequence; 
    while (*p != '\0') { 
     if (*p == ch) { 
      return p - sequence; 
     } 
    } 
    return -1; 
} 

const char* findFirstOf(const char * sequence, const char *chars) { 
    const char *p = sequence; 
    while (*p != '\0') { 
     if (indexOf(chars, *p) != -1) { 
      return p; 
     } 
    } 
    return NULL; 
} 

const char* findFirstNotOf(const char * sequence, const char *chars) { 
    const char *p = sequence; 
    while (*p != '\0') { 
     if (indexOf(chars, *p) == -1) { 
      return p; 
     } 
    } 
    return NULL; 
} 

int countWords(const char * sequence, char * delims) { 
    int count = 0; 
    const char *p = sequence; 
    do { 
     p = findFirstNotOf(p, delims); 
     if (p == NULL) break; 
     ++count; 
     p = findFirstOf(p, delims); 
    } 
    while (p != NULL); 
    return count; 
} 

int getLength(const char * sequence) { 
    const char *p = sequence; 
    while (*p != '\0') { 
     ++p; 
    } 
    return p-sequence; 
} 

char* dupString(const char * sequence, int length = -1) { 
    if (length == -1) { 
     length = getLength(sequence); 
    } 
    char *result = new char[length+1]; 
    for (int i = 0; i < length; ++i) { 
     result[i] = sequence[i]; 
    } 
    result[length] = '\0'; 
    return result; 
} 

char** getWords(const char * sequence, int & wordcount) { 
    const char delims[] = " .,\t?!"; 
    int count = countWords(sequence, delims); 
    char ** words = new char *[count]; 
    if (count > 0) { 
     count = 0; 
     const char *p = sequence; 
     do { 
      p = findFirstNotOf(p, delims); 
      if (p == NULL) break; 
      const char *q = findFirstOf(p, delims); 
      if (q == NULL) { 
       words[count++] = dupString(p); 
       break; 
      } 
      words[count++] = dupString(p, q-p); 
      p = ++q; 
     } 
     while (true); 
    } 
    wordcount = count; 
    return words; 
} 

Cela dit, le fait que vous utilisez new[] signifie que vous utilisez C++, vous devez donc utiliser la STL pour faciliter la vie:

#include <string> 
#include <vector> 

std::vector<std::string> getWords(const std::string & sequence) { 
    const char delims[] = " .,\t?!"; 
    std::vector<std::string> words; 
    std::string::size_type i = 0; 
    do { 
     i = sequence.find_first_not_of(delims, i); 
     if (i == std::string::npos) break; 
     std::string::size_type j = sequence.find_first_of(delims, i); 
     if (j == std::string::npos) { 
      words.push_back(sequence.substr(i)); 
      break; 
     } 
     words.push_back(sequence.substr(i, j-i)); 
     i = ++j; 
    } 
    while (true); 
    return words; 
}