1

我有一些代码在使用 sprintf 将 aa 指针复制到字符串时进行堆栈转储。我正在尝试将动物的内容复制到一个名为 output 的新指针数组中。但是，我得到了一个堆栈转储。

输出中应该有以下内容：新动物兔子新动物马新动物驴

我会以正确的方式解决这个问题吗？

非常感谢

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

void p_init(const char **animals, char **output);

int main(int argc, char **argv)
{
    char *animals[] = {"rabbit", "horse", "donkey", '\0'};  
    char **prt_animals = animals;
    char *output[sizeof(*animals)];

        /* print the contents here */
    while(*prt_animals)
    {
        printf("Animal: %s\n", *prt_animals++);
    }

        /* copy and update in the output buffer */
    p_init(*&animals, *&output);

    getchar();

    return 0;


void p_init(const char **animals, char **output)
{
    while(*animals)
    {
        sprintf(*output, "new animal %s", *animals); 
        *output++;
    }
}
4

5 回答 5

7

该数组animals是一个指针数组。它不是某个大小的缓冲区数组。因此，如果你这样做

sizeof(*animals)

您将获得该数组第一个元素的 sizeof。相当于

sizeof(char*)

因为您的数组存储指针。因此，在读取的行中

char *output[sizeof(*animals)];

您在一个数组中分配 4 或 8 个指针（取决于平台上指针的宽度。通常是 4 或 8）。但这当然没有意义！您想要做的是创建一个与animals. 您必须首先获取动物数组的总大小，然后除以一个元素的大小

char *output[sizeof(animals)/sizeof(*animals)];

现在，这就是你想要的。但是指针仍将具有不确定的值...接下来，您使用数组传递数组*&animals（另一个相同）。为什么？可以animals直接通过。获取它的地址然后取消引用与一开始什么都不做是一样的。

然后在您调用的函数中，将元素指向的字符串复制animal到某个不确定的目的地（请记住output数组的元素 - 指针 - 尚未确定值。我们还没有分配它们！）。您首先必须分配适量的内存并使元素指向它。

while(*animals) {
        // now after this line, the pointer points to something sensible
        *output = malloc(sizeof("new animal ") + strlen(*animals));
        sprintf(*output, "new animal %s", *animals); 
        output++; // no need to dereference the result
        animals++; // don't forget to increment animals too!
}

另外，大约上面的sizeof

您必须确定一件重要的事情。这是我们计算大小的方式。无论您做什么，请确保您始终有足够的空间容纳您的琴弦！AC 字符串由字符和一个终止空字符组成，它标志着字符串的结束。因此，*output应该指向一个缓冲区，该缓冲区至少要包含"new animal "和的空间*animals。第一个包含 11 个字符。第二个取决于我们实际复制的内容 - 它的长度是strlen返回的内容。所以，总的来说我们需要

12 + strlen(*animals)

所有字符的空间，包括终止的空值。现在，将该数字硬编码到您的代码中并不是一种好的风格。前缀可能会发生变化，您可能会忘记更新数字或误数一两个字符。这就是我们使用 的原因sizeof，我们提供了我们想要预先添加的字符串文字。回想一下，sizeof表达式的计算结果是其操作数的大小。您之前使用它main来获取数组的总大小。现在您将它用于字符串文字。所有字符串文字都是字符数组。字符串文字由您键入的字符和空字符组成。因此，以下条件成立，因为strlen计算 C 字符串的长度，并且不包括终止空字符到它的长度

// "abc" would have the type char[4] (array of 4 characters)
sizeof "..." == strlen("...") + 1

我们不必除以一个元素的大小，因为 char 的 sizeof 无论如何都是 1，所以不会有任何区别。为什么我们使用sizeof而不是strlen？因为它已经考虑了终止空字符，并且它在编译时进行评估。编译器可以从字面上替换 sizeof 表达式返回的大小。

于 2009-03-19T17:15:07.173 回答
2 
char *output[sizeof(*animals)];

创建一个大小为 4 的指针数组char。但是，它不会为这些指针分配内存。这些数组成员包含垃圾（即指向您不拥有的内存）。尝试写入该内存会调用 UB。在您的情况下，UB 通过堆栈转储显示自己。您的函数的其他一些问题p_init如下所示：

void p_init(const char **animals, char **output)
{
    /* runs an infinite loop -- since *animals is never incremented */
    /* need to pass size of *animals so that you can terminate your loop */
    while(*animals)
    {
        /* allocate some memory */
        sprintf(*output, "new animal %s", *animals); 
        *output++;
    }
}

一个固定的代码将是这样的：

void p_init(const char ** animals, const size_t nanimals, char **output)
{
    const char **w = animals;
    size_t len = 0;
    while (w < animals + nanimals)
    {
        len = strlen(*w);
        *output = malloc(len + sizeof "new animal " + 1);
        sprintf(*output, "new animal %s", *w); 
        output++;          
        w++;
    }
}

int main(int argc, char **argv)
{
    char *a[] = { "rat", "dog", "lion" };
    char *o[ sizeof a/ sizeof *a ];
    p_init((const char**)a, sizeof a / sizeof *a, o);
    for (size_t i = 0; i < sizeof a / sizeof *a; ++i) printf("%s\n", o[ i ]);
    for (size_t i = 0; i < sizeof a / sizeof *a; ++i) free(o[ i ]);
    return 0;
}

随意放入所需的标题。

于 2009-03-19T17:12:40.970 回答
2

您尚未在输出数组中分配任何空间来放入副本。在使用 sprintf 复制到该缓冲区之前，您需要使用 malloc 分配一些空间。

void p_init(const char **animals, char **output)
{
    while(*animals)
    {
        size_t stringSize = 42; /* Use strlen etc to calculate the size you need, and don't for get space for the NULL! */
        *output = (char *)malloc(stringSize);
        sprintf(*output, "new animal %s", *animals); 
        output++;
        animals++;
    }
}

完成后不要忘记在分配的内存上调用 free() 。

于 2009-03-19T17:13:03.230 回答
1

首先，有什么意义

p_init(*&animals, *&output);

与

p_init(animals, *&output);

?

其次，出于此处解释的原因，将 char** 转换为 const char** 是非法的。

最后，您的主要问题是测试

while (*animals)

当您到达动物数组末尾的空字符串时，您期望失败，这是错误的。该语句实际上是检查指向字符串的指针是否为 NULL，而不是检查字符串是否为 EMPTY。空字符串（包含单个字符 '\0' 的字符串）与空指针不同。

换句话说，一旦你到达了 animals 数组的最后一个元素，*animals 的计算结果就是一个非 NULL 指针，它恰好指向一个空字符串。因此测试通过了，你的循环永远继续下去（嗯，它一直持续到你跑到动物数组的末尾足够远而导致段错误）。

您可以通过在创建动物数组时将 '\0' 替换为 NULL 来解决此问题，或者您可以更改 while 检查以检查 strlen(*animals) == 0 （或任何其他检查空字符串而不是一个空指针。

编辑：请注意，其他人指出了我错过的同样严重的问题。

于 2009-03-19T17:12:27.290 回答
1

您没有创建一个非常大的缓冲区 -在 32 位系统sizeof(*animals)上sizeof(char*)是 4 个字节；您没有创建任何地方来放置输出字符串；并且您没有使用诸如snprintf写入缓冲区之类的安全机制，因此您会崩溃而不是安全失败。

以下是针对这些的修复，保持您的零终止数组使用：

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

void p_init ( const char **animals, char **output );

int main(int argc, char **argv) {
    // no reason to use char 0 rather than int 0 to mark end here
    const char* animals[] = {"rabbit", "horse", "donkey", "pig", 0};

    printf("sizeof(*animals) = %zd\n", sizeof(*animals));
    printf("number of elements in animals = %zd\n", sizeof(animals) / sizeof(*animals));

    char *output[sizeof(animals)/sizeof(*animals)];

    // print animals
    for ( const char**p = animals; *p; ++p)
        printf ( "Animal: %s\n", *p );

    // format animals to output
    p_init ( animals, output);

    // print output
    for ( char**p = output; *p; ++p)
        printf ( "Animal: %s\n", *p );

    // free output
    for ( char**p = output; *p; ++p )
        free(*p);

    return 0;
}

void p_init ( const char **animals, char **output ) {
    while ( *animals ) {
        size_t  len = strlen ( *animals );
        char*   buf = malloc ( len + 13 );

        snprintf ( buf, len + 13, "new animal %s", *animals );

        *output = buf;

        ++animals;
        ++output;
    }

    *output = 0;
}
于 2009-03-19T17:14:38.657 回答