私はこのプログラムを実行するたびにsegfaultを取得し続けますが、なぜわかりません

Question

私はユーザが入力した文字列を取り、それを動的に割り当てられた2次元配列を使って個々の単語に分割する関数を持っています。単語は区切り記号で区切られ、区切り記号は区切り記号で区切られています。ここで

が私のコードです：

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

しかし、私のcountWords機能が正しく文字列内の単語を数えていない、と私は理由を知りません。

Answer 1

より、このような何か試してみてください：言われていること

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

を、あなたはnew[]を使用しているという事実は、あなたが簡単に生活をするためにSTLを使用する必要がありますので、あなたがC++を使用している意味：

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