c++ - 在 C++ 中将数组作为参数传递

Question

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

//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);
}

请注意，此 mergeSort 函数不起作用，因为我还没有弄清楚如何合并它们(这是我的任务)。我想在处理之前对我的两个 vector 进行排序，但我无法编译它，因为我需要将数组作为参数传递。我不明白指针，所以如果这是解决方案，我的借口是无知。我现在正在学习编程，以 C++ 作为第一语言，并且只对语言的特性有基本的了解。谢谢您的帮助。

Answer 1

为了稍微扩展一下，请记住 C++ 数组正是 C 数组。所以你所拥有的只是一块声称(不保证)是一个数组的内存的地址。
更新
好的，我们再扩展一点。
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_p我们告诉编译器获取包含在 ar_p 中的地址的东西. `.
这称为取消引用指针。
如果我们说

ar_p = ar;

然后 *ar_p和 ar[0]指同一件事。
当我们说 ar[0]我们告诉编译器我们想要来自 ar 的地址 0 字节处的东西. ar[1]是地址一 int ，或 4 个字节，来自 ar .所以， *(ar_p+3)指的是与 ar[3]相同的东西. (我们需要括号，因为我们要先在地址上加 3，然后再查看内容。 *ar_p+3 将首先获取 ap_p 指向的内容，然后将其加 3。
问题是，C 不知道，也不知道数组到底有多大。如果我来做 ar[365] ，编译器会很高兴地生成代码来查看单元格 1000+(365× sizeof(int) )。如果它在您的数组中，那很好，但如果它只是随机内存，那也很好。 C 不在乎。
(记住 C 来自电话公司。“我们不在乎；我们没有必要。我们是电话公司。”)
所以，现在，我们知道了一些规则，我已经移到这里了。将“≡”读作“相当于”或“等于”。
您可以依赖的内容:

foo(TYPE t[]) ≡ foo(TYPE * t)

由于 C 不知道指针和数组之间的区别，因此您可以声明任何一个。当你定义一个函数时，你可以写

void foo(int[] ar){

或者

void foo(int* ar){

并获得完全相同的效果。

t[i] ≡ *(t+i)

这是上面的。任何你可以写的地方 ar[i] ，您可以将其替换为 *(ar+i) . (实际上有一个奇怪的侧面案例打破了这一点，但作为初学者你不会遇到它。)

哪里TYPE *t , (t+i)将等于 t 处的地址加i*sizeof(TYPE)

上面也解释了这一点。当您对数组进行索引时，例如 ar[42] ，这意味着您想要从起始地址开始的第 42 个。所以，如果你使用 int ，那么你需要移动超过 42 次，无论宽 int是，也就是说 sizeof(int) .
现在，这就是所有的 C，并且由于 C++ 被定义为“一种”C，因此它也适用于 C++。除了

除非 TYPE是重载 operator[] 的用户定义类型和 operator* .

在 C++ 中，您可以决定定义一个与任何其他类型一样的新类型，但您可以更改语言执行特定操作的方式。因此，程序员可以决定“重载”——即替换——数组引用和指针解引用操作符的默认行为，用他们自己设计的东西。作为初学者，您不应该很快面对，但您应该意识到这一点。