C++-在函数内部声明数组

函数退出后，将删除所有自动变量，包括数组。这通常都是非静态的局部变量。

函数中声明的数组在程序堆栈上分配。当程序退出函数时，堆栈上的局部变量将弹出，并且包含数组的内存将不再可访问。另一种选择是new一个在程序堆上分配的数组指针，它将在函数退出后继续存在，随后必须delete，否则将发生内存泄漏。

对程序堆栈的一个相当一般的解释是留出一块内存，用于保存函数的局部变量。当调用函数时，保存函数的局部变量所需的内存量被推到堆栈的顶部，即堆栈指针向上移动该量。当函数退出时，堆栈顶部会弹出确切数量的内存，堆栈指针会下移到函数调用前的上一个位置。另一方面，程序堆是没有堆栈语义的内存，当函数请求新的内存块时使用。然后，该程序负责管理该内存的释放。

C++中经常使用智能指针来自动处理内存的分配和释放，以避免与内存管理相关的错误/内存泄漏。

谷歌很快就给出了C++中栈与堆的解释。

当程序退出函数时，堆栈上的所有局部变量（包括您在内部声明的数组）都会弹出，并且在函数外部不再可访问。如下所示：

（不工作）

void func1(){
    int x[3]={1,2,3};
}
int main(){
    func1()
    cout<<x[1];
    return 0;
}

现在，你的第二个赌注是以某种方式返回数组，这可以通过以下方式完成：

1.由于C++不主张将局部变量的地址返回到函数外部，因此您必须将局部变量定义为静态变量

（工作）

int * func( ) {
    static int  x[3]={1,2,3};
    return r;           
    }       
int main () {    
     // a pointer to an int.
    int *x;
    x = func();
    cout<<x[1];           
    return 0;        
}

2.另一种方法是将指针作为参数传递给函数，并将数组传递给变量

（不工作）

void func(int *ptr){
    int x[3]={1,2,3};
    ptr=x;
}
int main{
    int *ptr;
    cout<<ptr[1];
    retrun 0;
}

这不起作用，因为在func中声明的数组是局部变量，并且在程序退出函数后被销毁，这就是为什么我们必须动态声明数组

（不起作用）

void func(int *ptr){
    int *x{ new int[3]{1,2,3 } };
    ptr=x;
}
int main(){
    int *ptr;
    func(ptr);
    cout<<ptr[1];
    return 0;
}

即使这样也不起作用，这是因为如果将指针作为参数传递给函数并试图进行修改，那么对指针所做的更改不会反映到该函数之外。这是因为只有指针的副本被传递给函数。上述问题可以通过将指针的地址传递给函数而不是实际函数的副本来解决。为此，函数参数应接受如下程序所示的"指针对指针"：

（有效，指针到指针）

#include<bits/stdc++.h>
using namespace std;
void func(int **ptr){
    int *x{ new int[3]{1,2,3 } };
    //cout<<*ptr<<endl;
    //cout<<ptr<<endl;
    *ptr=x;
    //cout<<ptr<<endl;
    //cout<<x<<endl;
}
int main(){
    int *ptr;
    func(&ptr);
    cout<<ptr[1]<<endl;
    return 0;
}

或者通过传递引用允许被调用函数修改调用方函数的局部变量。例如，考虑下面的示例程序，其中fun（）能够修改main（）的局部变量x。

（工作，引用指针）

#include<bits/stdc++.h>
using namespace std;
void func(int *&ptr){
    int *x{ new int[3]{1,2,3 } };
    //cout<<ptr<<endl;
    ptr=x;
    //cout<<ptr<<endl;
    //cout<<x<<endl;
}
int main(){
    int *ptr;
    func(ptr);
    cout<<ptr[1]<<endl;
    return 0;
}