C++ 在C+中作为参数传递数组+；

我正在编写一个合并排序函数，现在我只使用一个测试用例数组（没有输入-目前这是静态的）。我不知道如何将数组作为参数传递。这是我现在的代码：

//merge sort first attempt

#include <iostream>

#include <algorithm>

#include <vector>

int mergeSort(int[]);
int main() {
    int originalarray[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    mergeSort(originalarray[]);
}

int mergeSort(int[] originalarray) {
    int num = (sizeof(originalarray) / sizeof(int));
    std::vector < int > original(num);

    if (num > 2) {
        return num;
    }

    // Fill the array using the elements of originalarray
    // This is just for demonstration, normally original will be a parameter,
    // so you won't be filling it up with anything.
    std::copy(originalarray, originalarray + num, original.begin());

    // Create farray and sarray of the appropriate size
    std::vector < int > farray(num / 2);
    std::vector < int > sarray(num - farray.size());

    // Fill those using elements from original
    std::copy(original.begin(), original.begin() + farray.size(), farray.begin());
    std::copy(original.begin() + farray.size(), original.end(), sarray.begin());

    mergeSort(farray);
    mergeSort(sarray);
}

//第一次尝试合并排序
#包括
#包括
#包括
int合并排序（int[]）；
int main（）{
int originalarray[]={1,3,5,7,9,2,4,6,8,10}；
合并排序（原始数组[]）；
}
int合并排序（int[]原始数组）{
int num=（sizeof（originalarray）/sizeof（int））；
标准：：向量原始值（num）；
如果（数值>2）{
返回num；
}
//使用originalarray的元素填充数组
//这只是为了演示，通常原始值是一个参数，
//这样你就不会在里面装满任何东西了。
std:：copy（originalarray，originalarray+num，original.begin（））；
//创建适当大小的farray和sarray
std:：vectorfarray（num/2）；
std:：vectorsarray（num-farray.size（））；
//使用原始元素填充这些元素
std:：copy（original.begin（），original.begin（）+farray.size（），farray.begin（））；
std:：copy（original.begin（）+farray.size（）、original.end（）、sarray.begin（））；
合并排序（法拉利）；
合并排序（sarray）；
}

---

请注意，这个mergeSort函数不起作用，因为我还没有弄清楚如何合并它们（这是我的任务）。我想在处理之前对我的两个向量进行排序，但我无法编译它，因为我需要将数组作为参数传递。我不懂指针，所以如果这是解决办法，我的借口就是无知。我现在正在学习编程，C++是第一语言，只有掌握语言的基本特征。谢谢你的帮助。

你不应该像那样使用

sizeof（originalarray）/sizeof（int）

。它只适用于静态声明的数组（大小在编译时已知）。你必须把尺寸和它一起传递。为什么不从数组中生成一个

向量

，然后传递它呢

旁注：根据经验，请务必注意

sizeof

将在编译时进行翻译。因此，它无法知道作为参数传递的数组的大小。

• 当您将数组传递给函数时，它们会衰减为指向数组第一个元素的指针，尽管使用了符号。因此，您的

  sizeof

  无法按预期工作

• 传入数组时，最好传入数组大小，以便知道在哪里停止。将其作为附加参数添加

---

我看到您包括了

。我建议您不要使用数组，只使用

vector

类。您可以看到如何使用STL容器，如<代码> vector < /CODE> .< /P> < P> JUT来扩展这一点，请记住C++数组是C数组。因此，您所拥有的只是一段内存的地址，它声称（没有任何保证）是一个something数组

更新 好的，我们再扩大一点

C（因此C++）实际上并没有这样的“数组”。它只有地址和指针。所以，当你把某个东西做成一个“数组”时，真正发生的是你告诉编译器某个变量代表一个地址

在C语言中区分声明和定义是很有用的。在一个声明中，你只需要给某个东西一个名字和一个类型；在定义中，实际上是分配空间

如果我们先定义一个数组，比如

int ar[100];

这意味着我们要告诉编译器我们需要100个

int

的空间，我们希望所有的空间都分配到一个块中，我们要使用

ar

这个名称。

sizeof

操作符给出类型或对象使用的字节数，因此我们的数组

ar

将占用100个×

sizeof（int）

字节。在大多数机器上，这将是400字节，但它因机器而异

如果我们定义一个变量

int * ar_p;   // using '_p' as a reminder this is a pointer

我们正在为包含地址的变量定义空间。它的大小将是

sizeof（int*）

，通常是4或8，但在某些机器上可能是2到16，在某些机器上，您不太可能很快遇到

数组的名称是

ar

。编译器将该名称转换为地址，因此我们可以使用

ar_p = ar ;     // THIS WORKS

现在，为了方便起见，我们假设数组

ar

恰好从内存中的位置1000开始

该名称

ar

没有分配任何空间；它就像一个常数，一个数字。所以，你不能逆转这个任务

ar = ar_p ;     // THIS WON'T WORK

因为同样的原因你不能说

1000 = ar_p ;   // THIS WON'T WORK EITHER

即，您不能更改1000的值。（早在FORTRAN的早期版本中，由于复杂的原因，这一技巧是可行的。这是一个错误。在尝试调试“2”的值为3的程序之前，您从未活过。）

C中的数组总是以零为基的，也就是说，第一个索引总是零。任何其他索引都只是使用该索引计算的地址。所以，

ar[0]

就是地址1000加上0字节的偏移量，或者说1000

ar[1]

是1000加上

int

大小的1倍，因此下一个int超过。事实上，这在C中总是正确的

这称为数组引用

当我们使用语法

*ar\u p

时，我们告诉编译器在

ar\u p

中包含的地址获取内容

这称为取消对指针的引用

如果我们说

ar_p = ar;

然后

*ar\u p

和

ar[0]

指的是同一件事

当我们说

ar[0]

时，我们告诉编译器我们想要的东西位于

ar

中0字节的地址

ar[1]

是地址

int

，或

ar

中的4个字节。因此，

*（ar_p+3）

指的是与

ar[3]

相同的东西。（我们需要括号

void foo(int[] ar){

void foo(int* ar){

int mergeSort(int originalarray[20])
{
    // do something
}

int originalarray[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
const size_t arraySize = sizeof originalarray / sizeof originalarray[0];
int mergeSort(int array[arraySize])
{
    // do something
}

int originalarray[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
const size_t arraySize = sizeof originalarray / sizeof originalarray[0];

int mergeSort(int *array, const size_t size)
{
    // do something
}

mergeSort(&(originalArray[0]), arraySize);

int main()
{
   std::vector<int> originalarray;
   for (int data = 1; data <= 10; data++)
   {
      originalarray.push_back(data);
   }
   mergeSort(originaldata);
}

int mergeSort(std::vector<int>& originalarray)
{
   // The rest of your code, note that now you are passing 
   // in your array for sorting, so you can continue with your code to split
   // the vector into farray and sarray

   // then call sort on your halves.
   mergeSort(farray);
   mergeSort(sarray);

   // I'm guessing at this point you'd write code to combine your farray sarray, and
   // put it back into originalarray...don't forget to clear original array first!
}