C++函数调用传参：数组传递的底层原理与高效实践

共计 2657 个字符，预计需要花费 7 分钟才能阅读完成。

在 C ++ 开发中，数组作为函数参数传递是一个看似简单却暗藏玄机的操作。很多开发者都曾遇到过 sizeof 失效、数组退化为指针等问题，这些现象背后其实是 C ++ 对数组处理的特殊机制。本文将深入探讨数组传参的三种主要方式，分析它们的底层实现，并给出实际开发中的最佳实践建议。

数组传参的典型问题

让我们先来看一个最常见的错误示例：

void printSize(int arr[]) {std::cout << "Array size in function:" << sizeof(arr) << std::endl;
}

int main() {int arr[5] = {1, 2, 3, 4, 5};
    std::cout << "Array size in main:" << sizeof(arr) << std::endl;
    printSize(arr);
    return 0;
}

运行这段代码，你会发现 main 中的 sizeof(arr) 输出的是数组总大小（比如 20 字节，假设 int 是 4 字节），而函数中的 sizeof(arr) 却输出指针大小（通常是 8 字节）。这是因为在函数参数中，数组会退化为指向其首元素的指针。

传统指针方案

最基础的数组传参方式就是使用指针。让我们看看编译器是如何处理这种传参方式的：

void processArray(int* arr, size_t size) {for(size_t i = 0; i < size; ++i) {arr[i] *= 2;
    }
}

对应的 x86-64 汇编代码大致如下（AT&T 语法）：

processArray:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    %rdi, -8(%rbp)    # 存储 arr 指针
    movq    %rsi, -16(%rbp)   # 存储 size
    movq    $0, -24(%rbp)     # i = 0
.L3:
    movq    -24(%rbp), %rax
    cmpq    -16(%rbp), %rax   # 比较 i 和 size
    jnb     .L1               # 如果 i >= size，跳转到.L1
    movq    -8(%rbp), %rax    # 加载 arr 指针
    movq    -24(%rbp), %rdx   # 加载 i
    salq    $2, %rdx          # i * 4 (int 大小)
    addq    %rdx, %rax        # 计算 arr[i]地址
    movl    (%rax), %eax      # 加载 arr[i]
    leal    (%rax,%rax), %edx # arr[i] * 2
    movq    -8(%rbp), %rax
    movq    -24(%rbp), %rcx
    salq    $2, %rcx
    addq    %rcx, %rax
    movl    %edx, (%rax)      # 存储回 arr[i]
    addq    $1, -24(%rbp)     # i++
    jmp     .L3
.L1:
    popq    %rbp
    ret

从汇编代码可以看出，数组是通过指针传递的，并且需要额外传递数组大小参数。这种方式的优点是简单直接，但缺点也很明显：

• 容易发生数组越界访问
• 需要手动管理数组大小
• 缺乏类型安全检查

引用传递方案

C++ 提供了引用传递数组的方式，可以保留数组类型信息：

template <size_t N>
void processArray(int (&arr)[N]) {for(size_t i = 0; i < N; ++i) {arr[i] *= 2;
    }
}

或者非模板版本：

void processArray(int (&arr)[5]) {for(size_t i = 0; i < 5; ++i) {arr[i] *= 2;
    }
}

引用传递的优势在于：

1. 保留了数组的原始类型信息
2. 不需要额外传递大小参数
3. 编译器可以检查数组大小是否匹配

但是，非模板版本只能处理特定大小的数组，灵活性较差。模板版本则会在编译时为不同大小的数组生成不同的函数实例。

C++11 array 容器方案

现代 C ++ 推荐使用 std::array 代替原始数组，它提供了更好的安全性和接口：

#include <array>
#include <algorithm>

void processArray(std::array<int, 5>& arr) {std::for_each(arr.begin(), arr.end(), [](int& n) {n *= 2;});
}

std::array的关键优势：

• 保存大小信息（通过 size() 方法）
• 支持迭代器接口
• 可以直接赋值和比较
• 提供边界检查（通过 at() 方法）

我们可以通过 data() 方法获取原始指针，与 C 接口兼容：

void c_api_function(int* arr, size_t size);

void wrapper() {std::array<int, 5> arr = {1, 2, 3, 4, 5};
    c_api_function(arr.data(), arr.size());
}

性能对比

我们在以下环境中测试三种方案的性能：

• CPU: Intel Core i7-9700K @ 3.6GHz
• 编译器: g++ 9.3.0
• 编译选项: -O3

测试 100 万次调用（处理大小为 10 的数组）的结果：

可以看到，三种方案在开启优化后的性能差异不大，引用传递略优。std::array虽然指令数稍多，但提供了更好的安全性。

避坑指南

多线程环境

在多线程环境下共享数组时需要注意：

1. 避免不同线程同时修改同一数组元素
2. 考虑使用原子操作或互斥锁保护共享数据
3. 注意 false sharing 问题（多个线程访问同一 cache line 的不同元素）

SIMD 优化

当使用 SIMD 指令集（如 AVX）优化数组处理时：

1. 确保数组内存对齐（通常需要 16/32/64 字节对齐）
2. 可以使用 alignas 指定对齐方式
3. 剩余元素需要单独处理

#include <immintrin.h>

void simdProcess(float* arr, size_t size) {
    // 假设 size 是 8 的倍数
    for(size_t i = 0; i < size; i += 8) {__m256 data = _mm256_load_ps(arr + i);
        // SIMD 处理...
        _mm256_store_ps(arr + i, data);
    }
}

思考题

1. 当数组作为类成员时，如何设计移动语义？考虑以下情形：

   class Matrix {
       std::array<double, 16> data;
   public:
       // 如何实现移动构造函数和移动赋值运算符？};

2. 对比 C 风格数组与 std::array 在constexpr场景下的差异。哪种更适合在编译期计算中使用？为什么？

通过这些分析和比较，我们可以看到，在现代 C ++ 开发中，虽然原始指针方案仍然可用，但引用传递和 std::array 提供了更好的安全性和表达力。在实际项目中，应根据具体需求选择最合适的方案，在性能和安全性之间取得平衡。