c++ - 可以使用 memcpy() 复制包含指针的结构吗？

Question

前几天我在想这个，我很好奇这是否是个坏主意......假设有一个结构包含指向字符串数组的指针。memcpy() 会在下面的示例中复制“名称”数组指针吗？编辑:在此示例中无法访问 std。

struct charMap
{ 
  unsigned char * name;   
  unsigned char id;       
};
typedef struct charMap CharMapT;

class ABC
{
  public:
  ABC(){}
  void Function();
  CharMapT* structList;
}

void ABC::Function ()
{
  CharMapT list[] = 
  {
    {"NAME1", 1},
    {"NAME2", 2}, 
    {"NAME3", 3}
  };

  structList = new CharMapT[sizeof(list)];
  memcpy(structList, &list, sizeof(list));
}

Answer 1

所提供的代码中有几个错误，我将首先讨论这些错误，然后是我对指针与数组的常用批评。

struct charMap
{ 
  unsigned int * name;   
  unsigned int id;       
};
typedef struct charMap CharMapT;

这声明了一个结构类型，该结构类型包括指向无符号整数的指针作为第一个成员(名称)和一个指向第二个成员(id)的整数。在具有默认字节打包的 32 位系统上，这将是 8 字节 宽(32 位指针 = 4 字节，32 位有符号整数 = 4 字节)。如果这是一台 64 位机器，指针将为 8 字节宽，int 仍然可能为 32 位宽，使得结构大小为 12 字节。

有问题的代码

void ABC::Function ()
{
  CharMapT list[] = 
  {
    {"NAME1", 1},
    {"NAME2", 2}, 
    {"NAME3", 3}
  };

  structList = new CharMapT[sizeof(list)];
  memcpy(structList, &list, sizeof(list));
}

这分配了 CharMapT 结构的动态数组。多少？比你想像中的还要多。 sizeof(list)将返回 list[] 的字节数大批。由于 CharMapT 结构是 8 字节宽(见上文)，这将是 3 * 8，或 24 个 CharMapT 项(如果使用 64 位指针，则为 36 个项)。

然后我们memcpy()来自 list 的 24 字节(或 36 字节) (&中的&list是不必要的)到新分配的内存。这将复制 3 个 CharMapT 结构，而我们分配的其他 21 个保持不变(超出它们的初始默认构造)。

注意:您正在初始化一个 const char *声明为 unsigned int * 的字段，所以即使这样编译，基本数据类型也会不同。假设您修复了结构并将指针类型更改为 const char * , const 数据段中某处的静态字符串常量的地址(“NAME”常量的地址)将被分配给 structList[0].name、structList[2].name 和 structList[2].name 中元素的指针变量分别为 structList[3].name.

这不会复制指向到的数据。它只会复制指针值。如果您想要数据的拷贝，那么您必须对它们进行原始分配(malloc、new 等)。

更好的是，使用 std::vector<CharMapT> , 使用 std::string对于 CharMapT::name ，并使用 std::copy()复制源代码(甚至直接赋值)。

我希望这能解释您正在寻找的内容。

---

指针与数组的对比

永远不要将指针与数组混淆。指针是一个变量，它保存一个地址。就像一个 int变量保存一个整数值，或 char变量保存的是字符类型，指针保存的值是地址

数组不同。它也是一个变量(很明显)，但它不能是左值，几乎每个通常使用它的地方都会发生转换。从概念上讲，这种转换会产生一个指向数组数据类型的临时指针，并保存第一个元素的地址。有时该概念不会发生(例如应用地址运算符)。

void foo(const char * p)
{
}

char ar[] = "Hello, World!";
foo(ar); // passes 'ar', converted to `char*`, into foo. 
         // the parameter p in foo will *hold* this address

或者这个:

char ar[] = "Goodbye, World!";
const char *p = ar;  // ok. p now holds the address of first element in ar
++p;                 // ok. address in `p` changed to address (ar+1)

但不是这个:

char ar[] = "Goodbye, World!";
++ar; //  error. nothing to increment.