使用内存地址在没有指针的情况下更改 C 中函数内的数组

Question

在教程点上学习指针、数组和函数时，我意识到我可以通过在主函数中创建一个新数组、创建一个指针并分配函数的返回值来实现从函数返回数组的目标到这个指针，然后在 main 函数中使用 for 循环递增指针以将数组的值重新分配给排序函数内部的数组。

但是我想知道，因为在函数返回后内存返回到堆栈中，为什么数组中的值没有重新分配给其他东西，其次有没有一种方法可以使用内存地址更改实际数组中的排序函数里面的main函数然后返回void？我正在使用冒泡排序算法，这是我目前的排序功能；

#include <stdbool.h>
int *arr_sort(int *arr){    

int *ptr = arr;
bool flag = true;
while(flag){

    flag = false;
    int i = 0;
    for(i;i<4;i++){
        if(arr[i]>arr[i+1]){
            flag = true;
            arr[i]+=arr[i+1];
            arr[i+1] = arr[i]-arr[i+1];
            arr[i]-= arr[i+1];
            }

        //  printf("%d : %d\t%d : %d \n",i,arr[i],i+1,arr[i+1]); *Included to display the values as they are being switched
    }
printf("\n\n");
}   

return arr;

}

然后是 main 中的 for 循环，将我的数组（称为 unsorted_array）分配给指针，因为它通过在排序函数中创建的数组递增

    ptr = arr_sort(unsorted_array);
        for(j;j<5;j++){
        unsorted_array[j]=*(ptr+j);

整个事情都像一个程序一样工作，但我只是想知道有兴趣积累知识（很久没有用 C 编程了），有没有更好的方法来做到这一点？

Answer 1

无需从您的函数中返回数组。只需将您的功能定义为

void arr_sort(int *arr){    

     bool flag = true;
     while(flag){

         flag = false;
         int i;
         for(i = 0; i < 4; i++){
              if(arr[i] > arr[i+1]){
                   flag = true;
                   arr[i]+=arr[i+1];
                   arr[i+1] = arr[i]-arr[i+1];
                   arr[i]-= arr[i+1];
              }

         }
         printf("\n\n");
     }   
}  

对arr 的所有更改都将在main 中的数组中进行。

Answer 2

我假设您“在主函数中创建一个新数组”的意思是这样的：

int main(int argc, const char *argv[]) 
{
   char unsorted_array[ARRAY_SIZE];
   // ... Code
}

在调用另一个函数时，位于堆栈上的任何变量（平凡、指针或数组）都会被保留，但是被调用函数位于堆栈上的任何变量都是函数返回时失效。

但是：位于堆栈上的指针可能指向堆上的数组。也就是说，如果数组是由 malloc() 分配的，在函数内部被声明为静态的，或者是一个全局变量。在这种情况下，数组的内容当然会在函数返回时保留，并且可以通过例如返回指针来提供给 调用 函数。当函数返回时，只有指针（例如通常为 4 个字节）被复制到 调用 函数堆栈，而不是指针指向的数组。

类似地，通过向 被调用 函数提供指向该数组的指针，可以使位于堆栈上的数组对 被调用 函数可用，就像您所做的那样.复制到被调用函数堆栈的，只有指针（4字节），因此被调用函数可以访问和修改数组，而数组本身不无效当函数返回时。

注意：在 C 中，调用声明为的函数时

void afun(char anarray[ARRAY_SIZE);

编译器隐含地把函数当作它被声明为

void afun(char *anarray);

即调用afun 只会将指针，而不是数组复制到被调用函数的堆栈中。