C++语法差异:2D和一维数组(指针算法)

Question

问题

我正在学习C++，并编写代码给转置2D数组和反转一维数组。

请看呼叫。为什么我必须使用reverse(arr, 4)作为反向，而我必须使用transpose(*in_matrix, *out_matrix)进行转置？

编写每个函数签名的方法有两种。两者的结果似乎是一样的。

谢谢。

编辑:我知道如何用数组下标来解决这个问题。我故意这样做是为了练习。现在我明白了没有必要尝试这个。不过，我在以下答覆中加入了一些摘要。

码

#include <iostream>
using namespace std;

const int LENGTH = 2;
const int WIDTH = 3;

void printArray(const int arr[], const int N) {
    cout << arr[0]; 
    for (int i = 1; i < N; ++i) {
        cout << ", " << arr[i];
    }
    cout << "\n";
}

// void transpose(int* const input, int* const output) { // both these signatures
void transpose(const int input[], int output[]) {        // works (I find the top one clearer)
    for (int i = 0; i < WIDTH; ++i) {
        for (int j = 0; j < LENGTH; ++j) {
            *(output + j * WIDTH + i) = *(input + i * LENGTH + j);
        }
    }
}

// void reverse(int arr[], const int N) { // both these signatures
void reverse(int* arr, const int N) {     // works (I prefer this one)
    for (int i = 0; i < N / 2; ++i) { 
        int temp = *(arr + i);
        *(arr + i) = *(arr + N - 1 - i);
        *(arr + N - 1 - i) = temp;
    }
}

int main() {
    int arr[4] = {2,4,6,8};
    printArray(arr, 4);
    reverse(arr, 4); // this works
    // reverse(*arr, 4); // this doesn't work
    printArray(arr, 4);
     
    int in_matrix[WIDTH][LENGTH];
    in_matrix[0][0] = 1;
    in_matrix[0][1] = 2;
    in_matrix[1][0] = 3;
    in_matrix[1][1] = 4;
    in_matrix[2][0] = 5;
    in_matrix[2][1] = 6;

    int out_matrix[LENGTH][WIDTH];
    // transpose(in_matrix, out_matrix); // this doesn't work
    transpose(*in_matrix, *out_matrix); // this works

    cout << "in_matrix is:\n";
    for (int i = 0; i < WIDTH; ++i) {
        printArray(in_matrix[i], LENGTH);
    }

    cout << "out_matrix is:\n";
    for (int i = 0; i < LENGTH; ++i) {
        printArray(out_matrix[i], WIDTH);
    }
    return 0;
}

答案综述

LESSON: DO NOT USE pointer-arithmetic for 2D-arrays

              decay
KEY IDEA: arr -----> &arr[0]        type int*
This is also the reason the two function signatures are equivalent.

        // transpose(int* const input, int* const output) // alt.
Signature: transpose(const int input[], int output[])
i.e. it expects an array of ints (or equiv., a pointer to an int)

             (id)
IDENTITY: a[i] = *(a + i)           ALWAYS TRUE

Reason transpose(in_matrix, out_matrix) doesn't work:
           decay
out_matrix -----> &out_matrix[0]    type int(*)[WIDTH]

Reason transpose(*in_matrix, *out_matrix) works:
           (id)             decay
*out_matrix = out_matrix[0] -----> &(out_matrix[0])[0]

Answer 1

在C中，数组和指针有点复杂。数组可以被认为是一个指针，其上附加了一些“大小”信息(它没有存储在任何地方，但编译器知道)。因此，当在数组上使用sizeof时，给出整个数组的内容的大小，而在指针上，它给出指针的大小。

当将数组传递给函数时，大小信息会丢失--实际上，数组会衰减到指针。对于大多数实际用途，指向类型的指针可以完全像该类型的一维数组一样使用。数组下标表示法([])也可用于使用指针访问连续元素。

然而，对于2D数组，这会变得更加复杂。2D数组和双指针可以使用表单a[i][j]的相同访问语法，但它们不能互换。2D数组衰变为指向数组的指针，而双指针则是指向指针的指针。

回到您的问题上，编写函数签名的两种方法本质上是等价的，因为一维数组在传递给函数时会衰减为指针。所以void reverse(int* arr, const int N)和void reverse(int arr[], const int N)是一样的。

然而，在转置函数中，您要传递一个2D数组。它会衰减到指向数组的指针。但是在函数声明中，您接受这些参数作为数组(或者实际上是指针)。这仍然很好，因为C的怪癖，2D数组也可以被看作是一个大的一维数组，每个行都是连续排列的。然而，这并不是最好的办法。这也反映了这样一个事实:当您将数组名称传递给transpose函数时，必须取消引用它们，因为它需要一个一维数组(或指针)，而不是一个2D数组(或指向数组的指针)。

此外，C/C++提供了一种更优雅的方法来访问数组，而不是使用笨拙的指针算法。下面是我推荐的方法。它的工作方式应该与您最初发布的代码完全一样，但是它会更干净、更易读。

#include <iostream>
using namespace std;

const int LENGTH = 2;
const int WIDTH = 3;

void printArray(const int arr[], const int N) {
    cout << arr[0]; 
    for (int i = 1; i < N; ++i) {
        cout << ", " << arr[i];
    }
    cout << "\n";
}

void transpose(const int input[][LENGTH], int output[][WIDTH]) {
    for (int i = 0; i < WIDTH; ++i) {
        for (int j = 0; j < LENGTH; ++j) {
            output[j][i] = input[i][j];
        }
    }
}

void reverse(int* arr, const int N) {
    for (int i = 0; i < N / 2; ++i) { 
        int temp = arr[i];
        arr[i] = arr[N - 1 - i];
        arr[N - 1 - i] = temp;
    }
}

int main() {
    int arr[4] = {2,4,6,8};
    printArray(arr, 4);
    reverse(arr, 4);
    printArray(arr, 4);
     
    int in_matrix[WIDTH][LENGTH];
    in_matrix[0][0] = 1;
    in_matrix[0][1] = 2;
    in_matrix[1][0] = 3;
    in_matrix[1][1] = 4;
    in_matrix[2][0] = 5;
    in_matrix[2][1] = 6;

    int out_matrix[LENGTH][WIDTH];
   
    transpose(in_matrix, out_matrix);

    cout << "in_matrix is:\n";
    for (int i = 0; i < WIDTH; ++i) {
        printArray(in_matrix[i], LENGTH);
    }

    cout << "out_matrix is:\n";
    for (int i = 0; i < LENGTH; ++i) {
        printArray(out_matrix[i], WIDTH);
    }
    return 0;
}