C++ 如何使用指针从不同的函数访问局部变量？

我可以在不同的函数中访问局部变量吗？如果是，怎么做

void replaceNumberAndPrint(int array[3]) {
    printf("%i\n", array[1]);
    printf("%i\n", array[1]);
}

int * getArray() {
    int myArray[3] = {4, 65, 23};
    return myArray;
}

int main() {
    replaceNumberAndPrint(getArray());
}

上面代码段的输出：

65
4202656

我做错了什么？“4202656”是什么意思

---

我是否必须在

replacementNumberAndPrint（）

函数中复制整个数组才能多次访问它？

myArray

是一个局部变量，因此指针只在其作用域结束（在本例中是包含函数

getArray

）之前有效。如果您稍后访问它，则会得到未定义的行为

实际上，调用

printf

会覆盖

myArray

使用的堆栈部分，然后它会包含一些其他数据

要修复代码，您需要在足够长的作用域（示例中的

main

函数）中声明数组，或者在堆上分配数组。如果你将它分配到堆上，你需要手动地释放它，或者在C++中使用RAII.< /P>来自由。

---

我错过的一个替代方法（如果数组不太大，可能是这里最好的方法）是将数组包装到结构中，从而使其成为值类型。然后返回它会创建一个在函数返回后仍然存在的副本。有关此操作的详细信息，请参阅。

myArray在您离开getArray后立即超出范围。您需要在堆上为它分配空间。

一旦局部变量超出范围，就无法访问它。这就是局部变量的含义

在

replaceNumberAndPrint

函数中访问数组时，结果未定义。它第一次出现的事实只是一个幸运的巧合。您所指向的内存位置可能未在堆栈上分配，并且仍然为第一次调用正确设置，但是对

printf

的调用会在其操作过程中通过将值推到堆栈上来覆盖该位置，这就是为什么对

printf

的第二次调用会显示一些不同的内容

---

您需要将数组数据存储在堆上并传递一个指针，或者保存在作用域中的变量中（例如，一个全局变量或主函数中的某个作用域）。

您的代码调用未定义的行为，因为

myArray

一旦

getArray（）

返回并尝试使用（取消引用）就会超出作用域悬挂的指针是UB。

试试这样的方法。这样做会“杀死”

myArray

因为它是本地定义的

#include <stdio.h>
#include <stdlib.h>

void replaceNumberAndPrint(int * array) {
 printf("%i\n", array[0]);
 printf("%i\n", array[1]);
 printf("%i\n" , array[2]);
 free(array);
}

int * getArray() {
 int * myArray = malloc(sizeof(int) * 3);
 myArray[0] = 4;
 myArray[1] = 64;
 myArray[2] = 23;
 //{4, 65, 23};
 return myArray;
}

int main() {
 replaceNumberAndPrint(getArray());
}

#包括
#包括
void replaceNumberAndPrint（int*数组）{
printf（“%i\n”，数组[0]）；
printf（“%i\n”，数组[1]）；
printf（“%i\n”，数组[2]）；
自由（数组）；
}
int*getArray（）{
int*myArray=malloc（sizeof（int）*3）；
myArray[0]=4；
myArray[1]=64；
myArray[2]=23；
//{4, 65, 23};
返回myArray；
}
int main（）{
replaceNumberAndPrint（getArray（））；
}

更多：

编辑：正如评论正确指出的那样：更好的方法是：

#include <stdio.h>
#include <stdlib.h>

void replaceNumberAndPrint(int * array) {
    if(!array)
        return;

    printf("%i\n", array[0]);
    printf("%i\n", array[1]);
    printf("%i\n" , array[2]);
}

int * createArray() {
    int * myArray = malloc(sizeof(int) * 3);

    if(!myArray)
        return 0;

    myArray[0] = 4;
    myArray[1] = 64;
    myArray[2] = 23;
    return myArray;
}

int main() {
    int * array = createArray();
    if(array)
    {
        replaceNumberAndPrint(array);
        free(array);
    }
    return 0;
}

#包括
#包括
void replaceNumberAndPrint（int*数组）{
if（！数组）
返回；
printf（“%i\n”，数组[0]）；
printf（“%i\n”，数组[1]）；
printf（“%i\n”，数组[2]）；
}
int*createArray（）{
int*myArray=malloc（sizeof（int）*3）；
如果（！myArray）
返回0；
myArray[0]=4；
myArray[1]=64；
myArray[2]=23；
返回myArray；
}
int main（）{
int*array=createArray（）；
if（数组）
{
替换编号和打印（数组）；
自由（数组）；
}
返回0；
}

局部变量在返回时超出范围，因此无法返回指向局部变量的指针

您需要使用

malloc

或

new

动态地（在堆上）分配它。例如：

int *create_array(void) {
    int *array = malloc(3 * sizeof(int));
    assert(array != NULL);
    array[0] = 4;
    array[1] = 65;
    array[2] = 23;
    return array;
 }
 void destroy_array(int *array) {
     free(array);
 }
 int main(int argc, char **argv) {
     int *array = create_array();
     for (size_t i = 0; i < 3; ++i)
         printf("%d\n", array[i]);
     destroy_array(array);
     return 0;
 }

int *get_array(void) {
    static int array[] = { 4, 65, 23 };
    return array;
 }
 int main(int argc, char **argv) {
     int *array = get_array();
     for (size_t i = 0; i < 3; ++i)
         printf("%d\n", array[i]);
     return 0;
 }

int*创建数组（无效）{
int*array=malloc（3*sizeof（int））；
断言（数组！=NULL）；
数组[0]=4；
数组[1]=65；
数组[2]=23；
返回数组；
}
无效销毁数组（int*数组）{
自由（数组）；
}
int main（int argc，字符**argv）{
int*array=create_array（）；
对于（尺寸i=0；i<3；++i）
printf（“%d\n”，数组[i]）；
摧毁_阵列（阵列）；
返回0；
}

或者，您可以将数组声明为静态数组，记住语义是不同的。例如：

int *create_array(void) {
    int *array = malloc(3 * sizeof(int));
    assert(array != NULL);
    array[0] = 4;
    array[1] = 65;
    array[2] = 23;
    return array;
 }
 void destroy_array(int *array) {
     free(array);
 }
 int main(int argc, char **argv) {
     int *array = create_array();
     for (size_t i = 0; i < 3; ++i)
         printf("%d\n", array[i]);
     destroy_array(array);
     return 0;
 }

int *get_array(void) {
    static int array[] = { 4, 65, 23 };
    return array;
 }
 int main(int argc, char **argv) {
     int *array = get_array();
     for (size_t i = 0; i < 3; ++i)
         printf("%d\n", array[i]);
     return 0;
 }

int*get_数组（void）{
静态int数组[]={4,65,23}；
返回数组；
}
int main（int argc，字符**argv）{
int*array=get_array（）；
对于（尺寸i=0；i<3；++i）
printf（“%d\n”，数组[i]）；
返回0；
}

---

如果您不知道什么是静态的，请阅读。

正确的方法如下：

struct Arr {
   int array[3];
};
Arr get_array() {
   Arr a;
   a.array[0] = 4;
   a.array[1] = 65;
   a.array[2] = 23;
   return a;
}
int main(int argc, char **argv) {
   Arr a = get_array();
   for(size_t i=0; i<3; i++)
       printf("%d\n", a.array[i]);
   return 0;
}

struct-Arr{
int数组[3]；
};
Arr get_数组（）{
arra；
a、 数组[0]=4；
a、 数组[1]=65；
a、 数组[2]=23；
返回a；
}
int main（int argc，字符**argv）{
arra=获取数组（）；
对于（size_t i=0；i在本代码中，您使用了指向本地对象的指针，但当函数返回时，所有本地变量都超出范围。如果您将分配内存（使用
malloc（）
函数进行分配），则不会丢失或覆盖任何数据

int* getArray(int size) {
    int *myArray = (int*)malloc(size*sizeof(int));
    myArray[0] = 4;
    myArray[1] = 65;
    myArray[2] = 23;
    return myArray;
}

int main() {
    int i;
    int *vector = getArray(3);
    for(i=0;i<3;i++)
    {
        printf("%i\n",vector[i]);
    }
    getch();
    return 0;
}

int*getArray（int大小）{
int*myArray=（int*）malloc（size*sizeof（int））；
myArray[0]=4；
myArray[1]=65；
myArray[2]=23；
返回myArray；
}
int main（）{
int i；
int*vector=getArray（3）；
对于（i=0；iC++解决方案：

我可以访问其他函数中的局部变量吗？如果可以，如何访问

答案是否定的，不是在函数结束后。局部变量在这一点上被销毁

在
C++
中，处理返回数组的方法是在容器（固定大小）或（动态大小）中管理它们

例如：

void replaceNumberAndPrint（常量std:：数组和数组）{
printf（“%i\n”，数组[0]）；
printf（“%i\n”，数组[1]）；
printf（“%i\n”，数组[2]）；
}
std:：数组getArray（）{
std:：array myArray={4