5

我试图在我的脑海中弄清楚这一点。

int* arrayA = new int[3];
int arrayB[3] = {1,2,3}

arrayA = arrayB;

的值是否arrayB被复制到arrayA？还是arrayA变成了一个指针arrayB？

4

5 回答 5

7

赤裸new是邪恶的，尤其是对于数组。std::vector如果您需要动态数组并且需要静态数组，请使用std::array。1

现在实际的答案很简单。arrayA是一个指针。所以它指向arrayB. 这具有额外的效果：

  1. 你现在泄露了分配的指针。
  2. 尝试delete arrayA现在会崩溃或其他不愉快的事情，因为您将尝试释放未分配的内存。

实际上，虽然 C++ 允许分配结构和类，但它根本不支持分配数组。除非对象的一部分在中管理std::vector或作为数组成员在中std::array（注意：std::array是 C++11）。

1主要原因是容器保证资源将在其析构函数中释放，即所谓的RAII idiom，避免了大多数内存泄漏和悬空引用的机会。

于 2013-09-24T08:33:50.767 回答
6 
int* arrayA = new int[3];

arrayA 现在将地址存储在不同内存块的内存中，该内存块大到足以包含存储在堆上的 3 个整数。

int arrayB[3] = {1,2,3};

arrayB 是一个足够大的内存块，可以包含存储在堆栈中的 3 个整数。

arrayA = arrayB;

将存储在堆栈中的内存块的地址复制到变量 arrayA 中。您现在丢失了对存储在堆上的内存块的唯一引用，并且无法释放内存（内存泄漏）

当当前函数返回时，存储在堆栈上并且现在由 arrayA 指向的内存将无法安全访问。特别是返回arrayA（或arrayB）是不安全的。

于 2013-09-24T08:34:02.973 回答
2

为了

arrayB 的值是否被复制到 arrayA？

没有。它不会将arrayB 复制到arrayA。如果你想这样做，你可以这样做，

for (int i=0;i<3;i++) arrayA[i]=arrayB[i]; //This is two arrays has same value

arrayA 是否成为指向 arrayB 的指针？

是的。它成为指向arrayB数组的指针。在arrayA = arrayB之后；声明，第一行分配的内存无法访问，这是一个泄漏。

数组A=数组B；导致将arrayB的地址复制到arrayA。arrayA 将开始指向 arrayB。检查它使用，

printf("\n Base address of A[%u] base address of B[%u]", arrayA, arrayB);

希望这可以帮助。

于 2013-09-24T09:04:54.880 回答
0

数组名代表数组的基地址。

数组A=数组B；

将arrayB的基地址存储到arrayA。可以通过增加指针arrayA 来访问更多的值。

IE

*(arrayA) 值为 1

*(arrayA+1) 值为 2

*(arrayA+2) 值为 3

创建的内存应在最后使用时释放

删除[]数组A

于 2013-10-08T09:15:34.730 回答
0 
Q. Does the value of arrayB get copied over to arrayA? 
Ans. NO

或者

Q. does arrayA become a pointer to arrayB?
Ans YES.

但是您使用 new 分配的内存块丢失了。因为没有人拥有作为该块起点的地址。

这个程序证明了这一点：

#include<iostream>
using namespace std;

const int MAX=4;
int main(){
   int* arrayA = new int[MAX];
   for(int i=0;i<MAX;i++){  arrayA[i]=i;    }
   int arrayB[MAX] = {10,20,30,40};
   arrayA = arrayB;
   for(int i=0; i<MAX;i++){ cout<<" a["<<i<<"] = "<<arrayA[i]<<endl;    }
   return 0;
}

这段代码的输出是：

 a[0] = 10
 a[1] = 20
 a[2] = 30
 a[3] = 40

上

g++ (Ubuntu 4.8.4-2ubuntu1~14.04) 4.8.4

一般情况下也是如此。

这个的可视化有点像这样

arrayA-> [0][1][2][3]
arrayB-> [10][20][30][40]

最初 arrayA 的地址为 [0] （ + sum extra memory on thenegative index for size used by compiler to do the de-allocation ）。

在
数组A =数组B之后；

arrayA 的地址为 [10]；

假设你在 arrayA 上调用 delete 会发生什么？

*** Error in `./a.out': double free or corruption (out): 0x00007fff561281d0 ***

从下面的代码也可以看出这一点

#include<iostream>
using namespace std;

const int MAX=4;
int main(){
    int* arrayA = new int[MAX*2];
    for(int i=0;i<MAX;i++){ arrayA[i]=i;    }
    int* arrayC = new int[MAX];
    int j=0;
    for(int i=MAX*100;i>=0;i-=10,j++){  arrayC[j]=i;    }
    arrayA = arrayC;
    for(int i=0; i<MAX;i++){    cout<<" a["<<i<<"] = "<<arrayA[i]<<endl;    }

    delete[] arrayA;
return 0;
}

输出是：

 a[0] = 400
 a[1] = 390
 a[2] = 380
 a[3] = 370
*** Error in `./a.out': free(): invalid next size (fast): 0x0000000002028040 ***
Aborted (core dumped)

请注意：

“下一个尺寸无效”

这清楚地说明了在负索引中 arrayA 之前写入的大小值。

于 2016-04-18T07:37:59.497 回答