返回指向 char* 的指针会破坏数据

Question

我正在尝试编写一个函数，该函数将在不更改原始字符串的情况下沿空格 (' ') 拆分字符串，将所有标记放入数组中，然后返回该数组。我遇到的问题是返回指针。下面是我的代码。

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

char **split_line(char *ln) {
    char **tokens, *tok, line[256];
    int j;

    strcpy(line, ln);

    tokens = calloc(64, sizeof(char*));
    for (int i = 0; i < 64; i++)
        tokens[i] = calloc(64, sizeof(char));

    tokens[0] = strtok(line, " ");
    for (j = 1; (tok = strtok(NULL, " ")) != NULL && j < 63; j++) 
        tokens[j] = tok;
    tokens[j] = NULL;

    return tokens;
}

int main(void) {
    char **cut_ln, *input;

    input = "Each word in this string should be an element in cut_ln.";
    cut_ln = split_line(input);

    printf("`%s`\n", input);
    for (int i = 0; cut_ln[i] != NULL; i++)
        printf("[%d]: `%s`\n", i, cut_ln[i]);

    return 0;
}

运行时，会给出：

`This word in this string should be an element in cut_ln.`
[0]: `This`
[1]: `wo1`
[2]: `�={G+s`
[3]: `G+s`
[4]: `string`
[5]: ``
[6]: `0����`
[7]: `��`
[8]: ``
[9]: ``
[10]: ``

当我尝试在split_line 函数中打印tokens 的内容时，它给出了预期的结果。但是，当 tokens 返回并分配给一个变量，然后打印时，它会给出如上所示的结果。我做错了什么？

Answer 1

当您返回tokens 时，它包含从strtok 返回的指针，它们是指向line 的指针。但line此时已不存在。

您分配了内存并使tokens 的各个元素指向该分配的内存。不要用strtok 返回的值覆盖这些值。

Answer 2

对于初学者来说，函数应该至少像这样声明

char ** split_line( const char *ln );

因为传递的字符串在函数内没有被改变。

如果声明第二个参数来指定分隔符，该函数将更加灵活。

char ** split_line( const char *ln, const char *delim );

其次，使用64 或256 之类的幻数是个坏主意。如果传递的字符串包含多个63 标记，或者当字符串包含至少一个长度大于63 的标记时，该函数将不起作用。

你在这个循环中动态分配了 64 个数组

for (int i = 0; i < 64; i++)
    tokens[i] = calloc(64, sizeof(char));

并将它们的地址分配给变量tokens 指向的数组元素。但是您立即使用本地数组 line 内的地址重新分配了指针。

tokens[0] = strtok(line, " ");
for (j = 1; (tok = strtok(NULL, " ")) != NULL && j < 63; j++) 
    tokens[j] = tok;

因此该函数会产生大量内存泄漏。并且返回的指针数组会包含无效的指针，因为本地数组line在退出函数后将不再存在。

还有这个说法

tokens[j] = NULL;

是多余的。使用calloc，您最初已经将所有指针设置为NULL。

该函数可以如下面的演示程序所示。

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

char ** split_line( const char *s, const char *delim )
{
    size_t n = 0;
    
    for ( const char *p = s; *p; )
    {
        p += strspn( p, delim );
        
        if ( *p )
        {
            ++n;
            p += strcspn( p, delim );
        }
    }
    
    char **tokens = calloc( n + 1, sizeof( char * ) );
    
    if ( tokens )
    {
        size_t i = 0;
        int success = 1;
        
        for ( const char *p = s; success && *p; i += success )
        {
            p += strspn( p, delim );
        
            if ( *p )
            {
                const char *q = p;
                p += strcspn( p, delim );
                
                tokens[i] = malloc( p - q + 1 );
                
                if ( ( success = tokens[i] != NULL ) )
                {
                    memcpy( tokens[i], q, p - q );
                    tokens[i][p-q] = '\0';
                }
            }
        }
        
        if ( !success )
        {
            for ( char **p = tokens; *p; ++p )
            {
                free( *p );
            }
            
            free( tokens );
        }
    }
    
    return tokens;
}

int main(void) 
{
    const char *s = "Each word in this string should be an element in cut_ln.";
    
    char **tokens = split_line( s, " " );
    
    if ( tokens )
    {
        for ( char **p = tokens; *p; ++p )
        {
            puts( *p );
        }
        
        for ( char **p = tokens; *p; ++p )
        {
            free( *p );
        }
    }
    
    free( tokens );

    return 0;
}

程序输出是

Each
word
in
this
string
should
be
an
element
in
cut_ln.