将字符串转换为单词数组时的 IOT 指令

错误：

1. get_words_number越界（相差 1），并且可能会在字符串之后读取任意内存（请检查我在 中包含的示例）。main
2. 您需要在阵列中增加一个插槽来放置一个终止 .NULL
3. 如果以后需要输入指针，请停止抖动输入指针（在打印循环中和打印循环中）。my_free_word_arraymain
4. 编辑：正如 Fe2O3 评论的那样，我错过了函数中的另一个错误。您还应该确保在最后一个循环中。fill_array*i!=0

建议：

1. 下次通过包含所有必需的标头来制作一个最小的、可重现的示例;
2. strndup不是标准的（除非您具有并将定义定义为 1）。__STDC_ALLOC_LIB____STDC_WANT_LIB_EXT2__
3. 您根本不需要该函数。free_corrupted_array
4. 编辑：如果您也在检查，检查是没有用的. 不可打印，因此无需进行第一次检查。*i!=0isprint(*i)0

#define _CRT_SECURE_NO_WARNINGS
#ifdef __STDC_ALLOC_LIB__
#define __STDC_WANT_LIB_EXT2__ 1
#else
#include <stdlib.h>
#include <string.h>
char *strndup(const char *str, size_t size)
{
    return strncpy(calloc(size + 1, 1), str, size);
}
#endif

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

size_t get_words_number(char const *str)
{
    size_t count = 0;
    const char *i = str;
    while (*i != 0) {
        if (isprint(*i)) {
            count++;
        }
        while (*i != 0 && isprint(*i)) {
            i++;
        }
        if (*i != 0) { // <--- This was missing
            i++;
        }
    }
    return count;
}

void my_free_word_array(char **word_array) // <--- Moved up
{
    if (!word_array) {
        return;
    }
    for (size_t i = 0; word_array[i] != NULL; ++i) { // <--- Stop thrashing word_array
        free(word_array[i]);
    }
    free(word_array);
}

char **fill_array(char **array, const char *str, size_t word_count)
{
    size_t word_size = 0, j = 0;
    const char *i = str;
    while (j < word_count) {
        while (*i != 0 && isprint(*i)) {
            word_size++;
            i++;
        }
        array[j] = strndup(i - word_size, word_size); 
        if (!array[j]) {
            my_free_word_array(array); // <--- No need for another free here
            return NULL;
        }
        word_size = 0;
        j++;
        while (*i != 0 && !isprint(*i)) {
            i++;
        }
    }
    array[j] = NULL;
    return array;
}

char **my_str_to_word_array(char const *str)
{
    char **word_array = NULL;
    size_t word_count = 0;
    if (!str) {
        return NULL;
    }
    word_count = get_words_number(str);
    word_array = malloc((word_count + 1) * sizeof(char *)); // <--- You need a +1 here
    if (!word_array) {
        return NULL;
    }
    word_array = fill_array(word_array, str, word_count);
    return word_array;
}

int main(int argc, char **argv)
{
    char test[] = "My name is John Doe.\nI have 0 GPA.\nI will survive.\nThis will be removed from the string";
    *strrchr(test,'\n') = 0;
    char **word_array = my_str_to_word_array(test);
    if (word_array) {
        for (size_t i = 0; word_array[i] != NULL; ++i) { // <--- Stop thrashing word_array
            printf("%s\n", word_array[i]);
        }
        printf("Test print original size %zu\n", strlen(test));
        my_free_word_array(word_array);
    }
    return 0;
}

OP 的代码错过了对 null 字符的检查。@Costantino格拉纳

候选get_words_number（）更正和简化：

计数从“非单词”到“单词”的转换。

用于函数中所有字符的定义用途。unsigned char*is...()

#include <ctype.h>
#include <stdbool.h>

size_t get_words_number(char const *str) {
  const unsigned char *ustr = (const unsigned char *) str;
  size_t count = 0;
  bool previous_not_a_word = true;
  
  while (*ustr) {
    count += previous_not_a_word && isprint(*ustr);
    previous_not_a_word = !isprint(*ustr);
    ustr++;
  }
  return count;
}

OP 代码的最大问题是它被分解成如此多的辅助函数，以至于几乎不可读。一个简单的过程被这种碎片化弄得一团糟。

下面是解决此问题的“单次通过”版本。它不涉及辅助函数及其参数和令人抓狂的变量名称。

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

int main() {
    // OP string still as "string literal"
    char *test = "My name is John Doe.\nI have 0 GPA.\nI will survive.";

    // mutable copy of that string
    char *copy = malloc( strlen( test ) + 1 ); // Verify!
    strcpy( copy, test );

    // get one element that is NULL
    size_t cnt = 0;
    char **arr = calloc( ++cnt, sizeof *arr ); // Verify!!

    // chop copy on separators
    char *cp = copy;
    while( *cp ) {
        // skip leading/trailing separators
        while( *cp && !isprint( *cp ) ) cp++;
        if( !*cp ) break; // was 1 or more trailing seps

        // search for end of segment
        char *ep = cp;
        while( isprint( *ep ) ) ep++;

        // remember if this is the final segment
        bool atEnd = *ep == '\0';

        // terminate segment and store pointer
        *ep = '\0';
        arr = realloc( arr, ++cnt * sizeof *arr ); // Verify!!!
        arr[ cnt-2 ] = cp;
        arr[ cnt-1 ] = NULL;

        // move on (only if there is more to examine).
        cp = ep + !atEnd;
    }

    // output
    cnt = 0;
    do
        printf( "%d: %s\n", cnt, arr[ cnt ] ? arr[ cnt ] : "END OF ARRAY" );
    while( arr[ cnt++ ] );

    // cleanup
    free( arr );
    free( copy );

    return 0;
}

特意省略了对堆分配函数返回值的关键验证，以提高此示例代码的清晰度。这些验证留给读者作为练习。