C++ 是否可以在分配内存之前复制动态分配的数组指针？

首先，如果以前有人问过这个问题，我道歉。我似乎找不到正确的信息

以下代码并不像我想象的那样打印“300”：

#include <iostream>

int main()
{
  int *array;
  int *arrayCopy = array;

  array = new int[4];

  array[0] = 100;
  array[1] = 200;
  array[2] = 300;
  array[3] = 400;

  std::cout << arrayCopy[2];

  return 0;
}

在上面代码中它后面的行下面。为什么呢

---

（注：我知道有内存泄漏，而且std:：vector更好……我只是好奇）。

不，当你这样做时，

int*arrayCopy=array

此时将

array

的值捕获到

arrayCopy

中，因此如果进行修改（请注意，最初

array

指向某个随机位置，可以通过执行

new

使其指向正确的位置）将

数组

复制到

阵列副本

后，更改的数组将不会反映回

阵列副本

int *array;                   // array is ???
int *arrayCopy = array;       // copy is ???
array = new int[4];           // array is valid pointer, copy still ???

此代码段执行以下操作：

• 创建一个不确定值的

  int

  指针（可以是任何值）
• 将该不确定值复制到副本
• 更改原始指针的值以指向新创建的数组

换句话说，第三行“断开”两个指针，使副本仍然指向一个不确定的位置

取消对指针副本的引用是未定义的行为，而不是您想要处理的事情

相反，如果序列更改为（如您的问题中所述）：

然后，在初始化原始文件以指向数组后，将复制指针设置为原始文件。不会发生断开连接，因此

数组[2]

与

arrayCopy[2]

有效相同

是否可以在分配内存之前复制动态分配的数组指针

没有

但是，您可以这样做：

int *array;
int *&arrayReference = array;

---

也许你在考虑使用指针的引用？以下是当前代码的情况：

int *array; // Currently points to an undefined (invalid) memory location.
int *arrayCopy = array; // Now this points to the same undefined memory location as array.

array = new int[4]; // Now array points to valid memory, but arrayCopy still points to undefined space.

如果你做了这样的事情，那就不同了：

int *array; // Points to undefined
int *&arrayCopy = array; // This is a reference to array. That means if you change array, arrayCopy will also reflect the changes.

array = new int[4]; // Now since array points to valid space, arrayCopy does too.

从技术上讲，这并不完全正确，因为不同的事情正在发生。引用本质上与指针的间接寻址级别相同，只是编译器为您执行所有的取消引用。但我描述的基本上是它的工作原理。如果你只是把额外的

&

放在那里，你的代码就会按照你的想法运行

int *array; // points to some random value
int *arrayCopy = array; // points to the same value

array = new int[4]; // array points to a new value, arrayCopy does not

如果您想使指针始终指向“数组”指向的任何对象，请创建一个双指针

---

顺便说一句，它打印300而不是200:）这里没有内存泄漏。任何时候都不会因为更改指针而使分配的块“丢失”。@paxdiablo我认为需要删除

array

，因为内存是使用

new

分配的。不是这样吗？@ PaxDabLo我仍然认为这是内存泄漏，因为没有<代码>删除< /代码>。如果此分配是在除

main

以外的任何其他函数中完成的，则这是内存泄漏。@Marlon，但它不是在“除main以外的任何其他函数”中完成的，因此它不是泄漏。

int *array; // Points to undefined
int *&arrayCopy = array; // This is a reference to array. That means if you change array, arrayCopy will also reflect the changes.

array = new int[4]; // Now since array points to valid space, arrayCopy does too.

int *array; // points to some random value
int *arrayCopy = array; // points to the same value

array = new int[4]; // array points to a new value, arrayCopy does not