C ++中的静态数组与动态数组

C ++中的静态数组和动态数组有什么区别？

我必须为我的课程做一个分配，它说不要使用静态数组，而只能使用动态数组。我在书中和网上都看过，但我似乎不太明白。

我以为静态是在编译时创建的，动态是在运行时创建的，但是我可能会误以为是内存分配。

您能解释一下C ++中静态数组和动态数组之间的区别吗？

本地数组是在堆栈上创建的，并且具有自动存储期限-您不需要手动管理内存，但是当它们使用完函数时它们会被破坏。它们的大小一定是固定的：

int foo[10];

使用创建的数组operator new[]具有动态存储持续时间，并存储在堆中（从技术上讲是“免费存储”）。它们可以有任意大小，但是由于它们不属于堆栈框架，因此您需要自己分配和释放它们：

int* foo = new int[10];
delete[] foo;

static是C和C ++中的关键字，因此，static不是应用于一般的描述性术语，而是应用于变量或数组时具有非常特定的含义。更令人困惑的是，它在不同上下文中具有三种不同的含义。因此，静态数组可以是固定的，也可以是动态的。

让我解释：

首先是特定于C ++的：

• 静态类成员是未使用构造函数实例化或未使用析构函数删除的值。这意味着必须以其他方式初始化和维护成员。静态成员可以是初始化为null的指针，然后在首次调用构造函数时进行分配。（是的，这将是静态的和动态的）

有两个是从C继承的：

• 在函数中，静态变量是指在两次调用之间保留其内存位置的静态变量。它是静态的，因为它仅初始化一次并在函数调用之间保留其值（使用静态函数会使函数不可重入，即不是线程安全的）

• 在函数外部声明的静态变量是全局变量，只能从同一模块（带有任何其他#include的源代码文件）内访问

您要问的问题（我认为）是动态数组与固定或编译时数组之间的区别。这是一个更简单的问题，编译时数组是预先确定的（在编译程序时），并且是函数堆栈框架的一部分。它们在主功能运行之前分配。动态数组是在运行时使用“ new”关键字（或C中的malloc系列）分配的，它们的大小事先未知。在程序停止运行之前，不会自动清除动态分配。

我认为您的课堂中使用的语义令人困惑。“静态”可能意味着“恒定大小”，而“动态”可能意味着“可变大小”。那么，在这种情况下，恒定大小的数组可能如下所示：

int x[10];

“动态”结构将是允许在运行时增加或减少基础存储的任何一种结构。大多数时候，std::vectorC ++标准库中的类就足够了。像这样使用它：

std::vector<int> x(10); // this starts with 10 elements, but the vector can be resized.

std::vector已operator[]定义，因此您可以使用与数组相同的语义。

静态数组是在编译时分配的内存，而内存是在堆栈上分配的。而动态数组是在运行时分配的，而内存是从堆分配的。

int arr[] = { 1, 3, 4 }; // static integer array.   
int* arr = new int[3]; // dynamic integer array.

对术语的含义有明确的定义很重要。不幸的是，对于静态和动态数组的含义似乎有多种定义。

静态变量是使用静态内存分配定义的变量。这是一个独立于C / C ++的一般概念。在C / C ++中，我们可以创建具有全局，文件或局部范围的静态变量，如下所示：

int x[10]; //static array with global scope
static int y[10]; //static array with file scope
foo() {
    static int z[10]; //static array with local scope

通常使用基于堆栈的内存分配来实现自动变量。可以使用C / C ++创建自动数组，如下所示：

foo() {
    int w[10]; //automatic array

这些数组x, y, z，和w的共同点是，每个的大小都是固定的，并且是在编译时定义的。

理解自动数组和静态数组之间的区别很重要的原因之一是，静态存储通常是在目标文件的数据部分（或BSS部分）中实现的，并且编译器可以使用绝对地址来访问数组这是基于堆栈的存储所无法实现的。

什么是通常由意味着动态数组没有一个是可调整大小的，但一个使用实现动态内存分配有一个固定的大小在运行时确定。在C ++中，这是使用newoperator来完成的。

foo() {
   int *d = new int[n]; //dynamically allocated array with size n     

但是可以使用alloca以下命令在运行时定义一个具有固定大小的自动数组：

foo() {
    int *s = (int*)alloca(n*sizeof(int))

对于真正的动态数组，应该使用std::vectorC ++中的某种东西（或C中的可变长度数组）。

OP的问题对任务意味着什么？我认为很明显，所需的不是静态或自动数组，而是使用new运算符使用动态内存分配或使用eg的非固定大小数组std::vector。

我认为在这种情况下，它的大小固定是静态的。使用std :: vector。它具有resize（）函数。

您可能有一个伪动态数组，其大小由用户在运行时设置，但之后会固定。

int size;
cin >> size;
int dynamicArray[size];

静态数组：

1. 静态数组是在编译时分配的内存。
2. 大小是固定的。
3. 位于堆栈存储空间中。
4. 例如。：int数组[10]; //大小为10的数组

动态数组：

1. 内存是在运行时分配的。
2. 大小不固定。
3. 位于堆内存空间中。
4. 例如。：int * array = new int [10];

是的，是的，静态数组是在编译时创建的，而动态数组是在运行时创建的。就它们的内存位置而言，最大的区别在于静态变量位于堆栈上，而动态变量位于堆上。除非存在垃圾收集器（如.net框架的情况），否则放置在堆上的所有内容都需要进行内存管理，否则存在内存泄漏的风险。

静态数组：效率。不需要动态分配或取消分配。

用C，C ++在函数中声明的数组（包括静态修饰符）是静态的。示例：static int foo [5];

静态arrary意味着在数组的侧面赋予元素

动态arrary意思是不放弃数组中的元素

例：

     char a[10]; //static array
       char a[];  //dynamic array