通过指针与通过数组引用扩展数组索引序列

Question

我正在查看来自 libstdc++ here 的 to_array 实现，并注意到他们使用了一个聪明的技巧来避免使用 bool 模板参数为函数编写额外的重载决定函数是否应该将元素移动或复制到新创建的数组。

我决定试试这个技巧并写了一些测试代码：

template <typename ...P>
void dummy(P...) {}

template <typename T>
int bar(T& ref) {
    printf("Copying %d\n", ref);
    return ref;
}

template <typename T>
int bar(T&& ref) {
    printf("Moving %d\n", ref);
    T oldref = ref;
    ref = 0;
    return oldref;
}

template <bool Move, typename T, std::size_t... I>
void foo(T (&a)[sizeof...(I)], std::index_sequence<I...>) {
    if constexpr (Move) {
        dummy(bar(std::move(a[I]))...);
    } else {
        dummy(bar(a[I])...);
    }
}

template <typename T, std::size_t N>
void baz(T (&a)[N]) {
    foo<false>(a, std::make_index_sequence<N>{});
}

template <typename T, std::size_t N>
void baz(T (&&a)[N]) {
    foo<true>(a, std::make_index_sequence<N>{});
}

在弄乱这个时，我偶然发现了我最初认为是编译器中的一个错误，其中将 a 参数从 T(&a)[...] 更改为 T(a)[...] 产生了相同的汇编代码，但在我查看了汇编代码中的 demangled 标识符后，我得出结论，它确实不是，只是稍微更改了对 foo 函数的调用签名。

例如：

int main() {
    int a1[] = {1, 2, 3, 4};
    baz(a1);
    for (int i = 0; i < 4; i++) {
        printf("%d\n", a1[i]);
    }
    baz(std::move(a1));
    for (int i = 0; i < 4; i++) {
        printf("%d\n", a1[i]);
    }
}

印刷

Copying 4
Copying 3
Copying 2
Copying 1
1
2
3
4
Moving 4
Moving 3
Moving 2
Moving 1
0
0
0
0

在这两种情况下都生成了相同的汇编代码，但是当使用 T(&a)[...] 时，函数调用看起来像

void foo<false, int, 0ul, 1ul, 2ul, 3ul>(int (&) [4], std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>)

其中使用 T(a)[...] 导致函数调用看起来像

void foo<false, int, 0ul, 1ul, 2ul, 3ul>(int*, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>)

区别在于第一个参数的签名从对 int 数组的引用更改为指向 int（也称为 int 数组）的指针。

我用 clang++11 和 g++11（没有优化）测试了代码，结果是一致的。

我的问题是，当两者都产生相同的汇编代码并且按预期运行时，为什么您会选择一个选项而不是另一个选项？是否存在它们的行为不同导致使用 T(&a) 版本的 libstdc++ 的情况？

Here 是我的 Compiler Explorer 会话。

Answer 1

有很多模板代码涵盖了一个比较简单的主题。

在下面的示例中，您将通过引用传递一个数组:

#include <iostream>

void baz(int (&arr)[4]) {
    for (const auto e : arr) { std::cout << e << " "; }
}

int main() {
    int a1[] = {1, 2, 3, 4};
    baz(a1);  // 1 2 3 4
    
    return 0;
}

使用特定的 T (&param_name)[SIZE] 参数语法。

但是，如果将baz的arr参数的类型修改为int (arr)[4]，则括号不再有任何意义，这相当于int arr[4]，即尝试按值传递数组。然而，这是 array to pointer decay，例如如果我们尝试使用参数，就好像它实际上是范围可转换的一样，Clang 甚至会给我们一个非常明显的错误消息：

#include <iostream>

void baz(int arr[4]) {
    for (const auto e : arr) { std::cout << e << " "; }
}

int main() {
    int a1[] = {1, 2, 3, 4};
    baz(a1);  // error: cannot build range expression with array
              // function parameter 'arr' since parameter with array 
              // type 'int [4]' is treated as pointer type 'int *'
    
    return 0;
}

事实上，我们可以对您的更复杂的示例应用相同的测试：

void foo(T (&a)[sizeof...(I)], std::index_sequence<I...>) {
    for (const auto e : a) { (void)e; }  // Ok!
    // ...
}

void foo(T (a)[sizeof...(I)], std::index_sequence<I...>) {
    for (const auto e : a) { (void)e; }
        // Error: invalid range expression of type 'int *'; 
        // no viable 'begin' function available
    // ...
}

通过指针与通过数组引用扩展数组索引序列

Array index sequence expansion by pointer vs by array reference

c++

c++20

libstdc++