C++中数组作为函数参数传递，和使用指针作为函数参数有什么区别？

在C++里，数组作为函数参数传递和使用指针作为函数参数在很多方面表现出相似性，但也存在一些显著区别，下面从多个维度展开详细分析。

1. 语法形式

数组作为函数参数：在函数定义时，数组参数一般以如下形式呈现：

void function(int arr[], int size);

这里的arr看似是数组，不过实际上它会被编译器当作指针来处理。size用于明确数组的元素数量，因为函数内部无法直接获取数组的大小。

指针作为函数参数：函数定义时指针参数的形式为：

void function(int* ptr, int size);

ptr是一个指向int类型的指针，size同样是用来指明所指向数组的元素数量。

2. 本质

数组作为函数参数：当把数组名作为参数传递给函数时，数组名会隐式转换为指向数组首元素的指针。也就是说，函数接收的是数组首元素的地址，而非整个数组的副本。

#include <iostream>
void modifyArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        arr[i] *= 2;
    }
}
int main() {
    int myArray[3] = {1, 2, 3};
    modifyArray(myArray, 3);
    for (int i = 0; i < 3; ++i) {
        std::cout << myArray[i] << " ";
    }
    return 0;
}

在上述代码中，modifyArray函数对arr的操作会直接影响到main函数里的myArray，这表明传递的是数组首元素的地址。

指针作为函数参数：传递的就是一个指针变量，该指针指向某个内存地址，可能是数组的首地址，也可能是其他变量的地址。

#include <iostream>
void modifyValue(int* ptr) {
    *ptr = 10;
}
int main() {
    int num = 5;
    modifyValue(&num);
    std::cout << num << std::endl;
    return 0;
}

此代码中，modifyValue函数接收一个指向int类型的指针，通过解引用操作修改了指针所指向变量的值。

3. 数组大小信息

数组作为函数参数：函数内部无法直接获取数组的大小。这是因为数组名在传递过程中退化为指针，丢失了数组大小的信息。所以，通常需要额外传递一个表示数组大小的参数。

#include <iostream>
void printArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}
int main() {
    int myArray[3] = {1, 2, 3};
    printArray(myArray, 3);
    return 0;
}

指针作为函数参数：同样，函数内部不能直接从指针获取所指向数组的大小，也需要额外传递数组大小的信息。

#include <iostream>
void printArray(int* ptr, int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << ptr[i] << " ";
    }
    std::cout << std::endl;
}
int main() {
    int myArray[3] = {1, 2, 3};
    printArray(myArray, 3);
    return 0;
}

4. 多维数组处理

数组作为函数参数：对于多维数组，除了第一维的大小可以省略，其他维度的大小必须明确指定。

#include <iostream>
void print2DArray(int arr[][3], int rows) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << arr[i][j] << " ";
        }
        std::cout << std::endl;
    }
}
int main() {
    int my2DArray[2][3] = {{1, 2, 3}, {4, 5, 6}};
    print2DArray(my2DArray, 2);
    return 0;
}

指针作为函数参数：处理多维数组时，指针的使用会更复杂，需要使用多级指针或者指针数组。

#include <iostream>
void print2DArray(int** ptr, int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << ptr[i][j] << " ";
        }
        std::cout << std::endl;
    }
}
int main() {
    int** my2DArray = new int*[2];
    for (int i = 0; i < 2; ++i) {
        my2DArray[i] = new int[3];
        for (int j = 0; j < 3; ++j) {
            my2DArray[i][j] = i * 3 + j + 1;
        }
    }
    print2DArray(my2DArray, 2, 3);
    for (int i = 0; i < 2; ++i) {
        delete[] my2DArray[i];
    }
    delete[] my2DArray;
    return 0;
}

5. 可读性和语义

数组作为函数参数：使用数组作为函数参数，在语义上更能体现函数是对数组进行操作，代码的可读性较好，尤其是在处理数组相关的任务时，能让代码更直观。
指针作为函数参数：指针的使用更加灵活，但也更抽象。在一些情况下，使用指针作为参数可能会让代码的可读性降低，特别是对于不熟悉指针操作的开发者来说。

综上所述，数组作为函数参数传递和使用指针作为函数参数本质上很相似，不过在语法形式、多维数组处理以及代码可读性等方面存在一些差异。在实际编程中，需要根据具体的需求和场景来选择合适的方式。

秒客网