0

I'm a beginer. I'm confused about the difference between them. I have read a few answers and realized one of the difference is that the dynamic array can be deleted while the normal array can't. But are there any other differences? Such as their functions, sizes or whatsoever?

Well I have read such an example, and I don't see any difference if I replace the dynamic array {p= new (nothrow) int[i];} with a normal array {int p [i];}.

    #include <iostream>
    #include <new>
    using namespace std;
    int main ()
    {
      int i,n;
      int * p;
      cout << "How many numbers would you like to type? ";
      cin >> i;
      p= new (nothrow) int[i];
      if (p == 0)
      cout << "Error: memory could not be allocated";
      else
      {
        for (n=0; n<i; n++)
        {
          cout << "Enter number: ";
          cin >> p[n];
        }
        cout << "You have entered: ";
        for (n=0; n<i; n++)
        cout << p[n] << ", ";
        delete[] p;
      }
      return 0;
    }
4

2 回答 2

5

但是还有其他区别吗？

编译并运行它，看看会发生什么：

int main(int argc, char** argv){
    char buffer[1024*1024*64];
    buffer[0] = 0;
    return 0;
}

解释：

  1. 好吧，普通数组要么放在堆栈上，要么放在代码段内（如果它是全局变量或静态局部变量）。至少在 Windows/Linux PC 上。堆栈的大小有限（尽管您可以使用 linux 中的 ulimit 和 windows 上的编译器设置来更改它）。所以你的数组对于堆栈来说太大了，你的程序会在输入带有该数组的函数时立即崩溃（Linux 上的“分段错误”，Windows 上的“堆栈溢出”或“访问冲突”（忘记哪一个））。数组大小的默认限制在 Windows (x86) 上为 1 兆字节，在 linux 上为 8 兆字节。

  2. 您无法确定分配给 的块的大小new。int *p = new int[146]; std::cout << sizeof(p) << std::endl. 将打印 sizeof(int*)，而不是分配的内存大小。但是，sizeof适用于数组。

  3. 从理论上讲，使用动态内存分配，您可以根据需要分配尽可能多的内存（不过，操作系统可能会施加限制，在 32 位系统上，最大分配的块大小为 2..3 GB）。您还可以通过释放内存来控制资源使用，这样您的程序就不会无缘无故地占用系统内存/交换文件。

  4. 动态数组不会自动释放，您需要delete手动释放它们。

这只是一个简短的概述。

动态内存分配提供了更好的资源控制并消除了局部变量的一些限制。

说到这里，虽然你可以使用new/ delete，但如果你想使用可变大小的数组，你应该使用它std::vector。手动内存管理容易出错，因此您应该尽可能让编译器为您执行此操作。因此，建议至少学习STL(Standard Template Library)、智能指针、RAII、Rule of Three。

于 2013-06-15T05:49:31.127 回答
0

动态就是这样。您可以在运行时而不是编译时更改结果数组的大小。有一些编译器扩展允许您像动态数组一样使用静态数组 (int array[CONSTANT])，因为您可以在运行时指定大小，但这些都是非标准的。

动态数组也分配在堆上而不是堆栈上。这允许您在必要时使用所有可用内存来创建阵列。堆栈的大小有限，具体取决于操作系统。

例如，在堆上分配内存允许您执行以下操作： 

int* createArray(int n) {  
    int* arr = new int[n];  
    return arr;  
}  

int main()  
{  
    int* myArray = createArray(10);  
    // this array is now valid and can be used  

    delete[] myArray;  
}

我敢肯定，动态数组和静态数组之间还有许多其他错综复杂的地方，但这些都是大问题。

于 2013-06-15T04:28:25.430 回答