32

我对正在发生的事情感到非常困惑。我一直认为char *并且char []可以互换，但是在查看内存地址之后，它似乎char *在堆中分配空间，而char []在堆栈上分配内存。

char stack[] = "hello";
char *heap = "hello";

char *heap_string_malloc = malloc(5);
heap_string_malloc = "hello";

printf("Address of stack[0]: %p\n", stack);
printf("Address of heap[0]: %p\n", heap);
printf("Address of heap_string_malloc[0]: %p\n", heap_string_malloc);

输出以下内容：

Address of stack[0]: 0x7fff8b0b85b0
Address of heap[0]: 0x400760
Address of heap_string_malloc[0]: 0x400760

这是否意味着char *是动态分配的？

更令我困惑的是，为什么分配与已经分配malloc的内存地址相同的内存地址？char *heap我没有运行任何优化（只是gcc file.c）。

4

5 回答 5

40

数组不是指针。您的程序正在逐行执行的是

// Allocate 6 bytes in the stack and store "hello" in them
char stack[] = "hello";

// Allocate pointer on the stack and point it to a static, read-only buffer
// containing "hello"
char *heap = "hello";

// Malloc 5 bytes (which isn't enough to hold "hello" due to the NUL byte)
char *heap_string_malloc = malloc(5);

// Reset heap_string_malloc to point to a static buffer; memory leak!
heap_string_malloc = "hello";

您看到同一个指针两次的原因是编译器优化掉了第二个包含"hello".

于 2013-10-29T10:50:23.470 回答
15

当你这样做时

char *heap = "hello";

指针heap实际上并不指向堆，它指向由操作系统加载器与程序的其余部分一起加载的静态数据。事实上，正确的应该是

const char *heap = "hello";

asheap指向一块恒定的只读内存。

此外，虽然数组衰减为（并且可以用作）指针，并且指针可以与数组语法一起使用，但它们并不相同。最大的区别在于，对于一​​个数组，您可以使用例如sizeof获取实际数组的字节大小，而指针则不可能。

第三件事，当你在做

char *heap_string_malloc = malloc(5);
heap_string_malloc = "hello";

您有内存泄漏，因为您首先分配了一些东西，heap_string_malloc然后直接重新分配heap_string_malloc以指向完全不同的东西。

至于您获得相同地址的原因heap，heap_string_malloc这是因为两者都指向相同的文字字符串。

于 2013-10-29T10:50:19.873 回答
12

诸如此类的字符串文字"hello"以这样一种方式存储，即它们在程序的整个生命周期内都被保存。它们通常存储在一个单独的数据段（不同于堆栈或堆）中，该数据段可能是只读的。

当你写

char stack[] = "hello";

您正在创建一个auto类型为“6 元素数组”的新（“堆栈”）变量char（大小取自字符串文字的长度），并将字符串文字的内容复制"hello"到其中。

当你写

char *heap = "hello";

您正在创建一个类型为“pointer to ”的新auto（“stack”）变量，并将字符串文字的地址复制到其中。 char"hello"

这是它在我的系统上的外观：

       Item        Address   00   01   02   03
       ----        -------   --   --   --   --
    "hello"       0x400b70   68   65   6c   6c    hell
                  0x400b74   6f   00   22   68    o."h

      stack 0x7fffb00c7620   68   65   6c   6c    hell
            0x7fffb00c7624   6f   00   00   00    o...

       heap 0x7fffb00c7618   70   0b   40   00    p.@.
            0x7fffb00c761c   00   00   00   00    ....

      *heap       0x400b70   68   65   6c   6c    hell
                  0x400b74   6f   00   22   68    o."h

如您所见，字符串文字"hello"有自己的存储空间，从地址 0x400b70 开始。两个stackahdheap 变量都被创建为auto（“堆栈”）变量。 stack包含字符串文字内容的副本，而heap包含字符串文字的地址。

现在，假设我用来malloc为字符串分配内存并将结果分配给heap：

heap = malloc( sizeof *heap * strlen( "hello" + 1 ));
strcpy( heap, "hello" );

现在我的内存映射如下所示：

       Item        Address   00   01   02   03
       ----        -------   --   --   --   --
    "hello"       0x400b70   68   65   6c   6c    hell
                  0x400b74   6f   00   22   68    o."h

      stack 0x7fffb00c7620   68   65   6c   6c    hell
            0x7fffb00c7624   6f   00   00   00    o...

       heap 0x7fffb00c7618   10   10   50   00    ..P.
            0x7fffb00c761c   00   00   00   00    ....

      *heap       0x501010   68   65   6c   6c    hell
                  0x501014   6f   00   00   00    o...

该heap变量现在包含一个不同的地址，它指向另一个包含字符串“hello”的 6 字节内存块。

编辑

对于 byteofthat，这是我用来生成上述地图的代码：

垃圾车.h：

#ifndef DUMPER_H
#define DUMPER_H

/**
 * Dumps a memory map to the specified output stream
 *
 * Inputs:
 *
 *   names     - list of item names
 *   addrs     - list of addresses to different items
 *   lengths   - length of each item
 *   count     - number of items being dumped
 *   stream    - output destination
 *
 * Outputs: none
 * Returns: none
 */
void dumper(char **names, void **addrs, size_t *lengths, size_t count, FILE *stream);

#endif

自卸车.c:

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

#include "dumper.h"

/**
 * Dumps a memory map to the specified output stream
 *
 * Inputs:
 *
 *   names     - list of item names
 *   addrs     - list of addresses to different items
 *   lengths   - length of each item
 *   count     - number of items being dumped
 *   stream    - output destination
 *
 * Outputs: none
 * Returns: none
 */
void dumper(char **names, void **addrs, size_t *lengths, size_t count, FILE *stream)
{
  size_t i;
  int maxlen = 15;

  for ( size_t j = 0; j < count; j++ )
  {
    if (strlen(names[j]) > maxlen && strlen(names[j]) < 50)
      maxlen = strlen(names[j]);
  }

  fprintf(stream,"%*s%15s%5s%5s%5s%5s\n", maxlen, "Item", "Address", "00", "01",
    "02", "03");
  fprintf(stream,"%*s%15s%5s%5s%5s%5s\n", maxlen, "----", "-------", "--", "--",
    "--", "--");

  for (i = 0; i < count; i++)
  {
    size_t j;
    char *namefield = names[i];
    unsigned char *p = (unsigned char *) addrs[i];
    for (j = 0; j < lengths[i]; j+=4)
    {
      size_t k;

      fprintf(stream,"%*.*s", maxlen, maxlen, namefield);
      fprintf(stream,"%15p", (void *) p);
      for (k = 0; k < 4; k++)
      {
        fprintf(stream,"%3s%02x", " ", p[k]);
      }
      fprintf(stream, "    ");
      for ( k = 0; k < 4; k++)
      {
        if (isgraph(p[k]))
          fprintf(stream,"%c", p[k]);
        else
          fprintf(stream, ".");
      }
      fputc('\n', stream);
      namefield = " ";
      p += 4;
    }
    fputc('\n', stream);
  }
}

以及如何使用它的示例：

#include <stdio.h>

#include "dumper.h"

int main(void)
{
  int x = 0;
  double y = 3.14159;
  char foo[] = "This is a test";

  void *addrs[] = {&x, &y, foo, "This is a test"};
  char *names[] = {"x", "y", "foo", "\"This is a test\""};
  size_t lengths[] = {sizeof x, sizeof y, sizeof foo, sizeof "This is a test"};

  dumper(names, addrs, lengths, 4, stdout);

  return 0;
}
于 2013-10-29T15:57:27.173 回答
1

这将在堆栈上创建一个数组，其中包含静态字符串“hello”的副本：

char stack[] = "hello";

这会在堆栈上创建一个指针，其中包含静态字符串“hello”的地址：

char *heap = "hello";

这将在堆栈上创建一个指针，其中包含 5 个字节的动态分配缓冲区的地址：

char *heap_string_malloc = malloc(5);

但是在所有这三种情况下，你都在堆栈上放了一些东西。char*不是“在堆上”。它是一个指针（在堆栈上），它指向某处的某物。

于 2013-10-29T11:38:04.007 回答
0

“stack”是一个静态字符数组，因此它将在堆栈中分配并在函数结束后自动释放，因为它的大小自定义以来就已知。虽然 "heap" 和 "heap_string_malloc" 都被声明为指向 char 缓冲区的指针，并且需要使用 malloc 动态分配以定义其内容的大小，但这就是它们将驻留在堆内存中的原因。通过做：

char *heap = "hello";

和：

heap_string_malloc = "hello";

您正在修改指针它们自己（使用静态缓冲区值），而不是它们指向的内容。您应该使用 memcpy 用您的数据修改“heap_string_malloc”指针指向的内存：

memcpy(heap_string_malloc, "hello", 5);
于 2013-10-29T11:09:10.497 回答