C 试图通过按地址将数组传递给函数对数组进行排序时出现分段错误11

有什么问题吗？

根据您的

arrayCopy（）<代码> >声明编译器将考虑第一个参数作为双指针<代码> < FROMARLY 将有“代码>初始数组/<代码>的地址，<代码> *FROMARLY 将包含<代码> 540 <代码>，在函数定义中，您试图遵从<代码> 540 >代码>无效的地址，因此更改<代码>无效数组复制（INT*FROMARLY[]），int*toArray[]，int size）->
void arrayCopy（int-fromrarray[]，int-toArray[]，int-size）并检查以下修改的程序

proj1.c:12:12: warning: incompatible pointer types passing 'int (*)[4]' to parameter of type 'int **' [-Wincompatible-pointer-types]
    arrayCopy(&initialArray, &copiedArray, size); //copy 
              ^~~~~~~~~~~~~
proj1.c:4:21: note: passing argument to parameter 'fromArray' here
void arrayCopy(int* fromArray[], int* toArray[], int size);
                ^
proj1.c:12:27: warning: incompatible pointer types passing 'int (*)[size]' to parameter of type 'int **' [-Wincompatible-pointer-types]
    arrayCopy(&initialArray, &copiedArray, size); //copy 
                             ^~~~~~~~~~~~
proj1.c:4:39: note: passing argument to parameter 'toArray' here
void arrayCopy(int* fromArray[], int* toArray[], int size);
                                  ^
proj1.c:20:7: warning: incompatible pointer types passing 'int (*)[size]' to parameter of type 'int **' [-Wincompatible-pointer-types]
    sort(&copiedArray, size);
         ^~~~~~~~~~~~
proj1.c:5:17: note: passing argument to parameter 'arr' here
void sort (int* arr[], int size);
            ^
3 warnings generated.

#包括
#包括
void arrayCopy（int-fromrarray[]，int-toArray[]，int-size）；
无效排序（int arr[]，int size）；
内部主（空）{
int initialArray[]={540,2100,5150,3}；
int size=sizeof（initialArray）/sizeof（initialArray[0]）；//获取数组的长度
int copiedArray[size]；//以初始数组的大小创建新数组
int i；
arrayCopy（initialArray，copiedArray，size）；//复制
对于（i=0；icopiedArray，%d:%d\n”，i，initialArray[i]，i，copiedArray[i]）；
}
printf（“\n”）；
排序（复制阵列、大小）；
printf（“排序数组：{”）；
对于（i=0；i
&initialArray
是类型为
int（*）[4]
的指针。这与您声明要使用的函数的
int**
不兼容

最简单的解决方案是让函数取
int*
，作为指向数组第一个元素的指针。例如：

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

void arrayCopy(int fromArray[], int toArray[], int size);  
void sort (int arr[], int size);

int main(void){
    int initialArray[] = {540, 2100, 5150, 3};
    int size = sizeof(initialArray) / sizeof(initialArray[0]); //get length of array
    int copiedArray[size]; //make new array at size of initial array
    int i;

    arrayCopy(initialArray, copiedArray, size); //copy 

    for(i = 0; i < size; i++){
        printf("initialArray, %d: %d -> copiedArray, %d: %d\n", i, initialArray[i], i,  copiedArray[i]);
    }

    printf("\n");

    sort(copiedArray, size);

    printf("Sorted array: {");
    for(i = 0; i < size; i++){
        printf("%d,", copiedArray[i]);
    }

    printf("}\n");

    return 0;
}

/*

copies all the elements from one array to another

*/

void arrayCopy(int fromArray[], int toArray[], int size) {
    int i;
    for(i = 0; i < size; i++){
        toArray[i] = fromArray[i];
    }
}

/*

sorts a given array in ascending order

*/

void sort(int arr[], int size) {
    int i;
    for(i = 0; i < size - 1; i++){
        if(arr[i] < arr[i + 1]){
            int temp = arr[i + 1];
            arr[i + 1] = arr[i];
            arr[i] = temp;
        }
    }
}

你这样称呼它：

void arrayCopy(int const *from, int *to, size_t num_ints)
{
     memcpy(to, from, num_ints * sizeof(int));
}

在此上下文中写入
初始数组
与写入
初始数组[0]
相同；因此，函数有一个指向第一个数组元素的指针，还有数组元素的计数，因此函数有它所需要的所有信息

通常不能这样分配数组（
int-copiedaray[size]；
）。编译器允许这样做，因为大小在编译时是已知的。如果不硬编码initialArray（例如，希望用户在运行时填充），则程序将无法编译。在这种情况下，请使用
malloc
（而不是
new[]
，因为您是用C编写的，而不是C++）

指针。正确使用它们。

void数组复制（int-fromArray[]，int-toArray[]，int-size）{
对于（int i=0；i

排序函数缺少一个嵌套循环。Google bubble排序

一旦你有了定义：

void arrayCopy(int fromArray[], int toArray[], int size) {
for(int i = 0; i < size; i++){
        toArray[i] = fromArray[i];
}
...
arrayCopy(initialArray, copiedArray, size);

arr
已经是指向该数组的指针，相当于
&arr[0]
，因此在这种情况下使用
&arr
只是没有定义（第一个元素的地址地址……没有这样的事情）

由于
arr
已经是内存中数组的指针，因此要在函数中修改该数组，只需传递
arr
和数组大小：

int arr[N];

然后你可以这样调用这个函数：

void my_func(int array_to_sort[], int array_size);

void arrayCopy（int*fromrarray[]，int*toArray[]，int size）；
->
void arrayCopy（int-fromrarray[]，int-toArray[]，int-size）；
并相应修改定义。与
sort（）类似
functionStandard C99允许大小可变的静态数组。这完全可以。@AlexLop，如果您使用常量表达式声明两个数组，则无需使用C99问题，并且您的代码可以移植到C99之前的编译器。当您使用常量数组初始化第一个数组时，您可以使用该数组的大小作为常量表达式您在第二个声明中需要的sion。恐怕不是。
arr
根据定义，是指向数组第一个元素的指针引用，因此在本例中，类型为
int*
。&arr
也是数组的地址，因此类型为
int（*）[N]
（指向N个元素数组的指针）。如果您尝试打印
sizeof*arr
和
sizeof*&arr
@LuisColorado，您可以检查这两个指针是否指向同一地址，并且它们的类型是否不同。谢谢路易斯。我学到了一些新东西。事实上，我从未使用过&arr，因为我没有理由这么做。但现在我发现我对这种表示有错误的理解激动。
int arr[N];

void my_func(int array_to_sort[], int array_size);

my_func(arr, N);