이 프로그램을 실행할 때마다 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; 
}