将数组的所有元素初始化为相同的数字

Question

前段时间，我的老老师发布了这段代码，说这是将数组初始化为相同数字（当然不是零）的另一种方法。

在这种情况下是三个。

他说这种方式比for循环稍微好一点。为什么我需要左移运算符？为什么我需要另一个长数组？ 我不明白这里发生了什么。

int main() {

    short int A[100];

    long int v = 3;
    v = (v << 16) + 3;
    v = (v << 16) + 3;
    v = (v << 16) + 3;
    long *B = (long*)A;

    for(int i=0; i<25; i++)
        B[i] = v;

    cout << endl;
    print(A,100);
}

Answer 1

有很多方法可以用相同的值填充数组，如果您关心性能，则需要进行测量。

C++ 有一个专门的函数可以用一个值填充数组，我会使用它（在#include <algorithm> 和#include <iterator> 之后）：

std::fill(std::begin(A), std::end(A), 3);

你不应该低估优化编译器可以用这样的东西做些什么。

如果您有兴趣了解编译器的功能，那么如果您准备学习一点汇编程序，那么 Matt Godbolt 的 Compiler Explorer 是一个非常好的工具。正如您从here 中看到的那样，编译器可以优化fill 对十二个（以及一点）128 位存储的调用，并展开任何循环。由于编译器了解目标环境，因此无需在源代码中编码任何特定于目标的假设即可做到这一点。

Answer 2

他假设long 比short 长四倍（不能保证；他应该使用 int16_t 和 int64_t）。

他占用了更长的内存空间（64 位）并用四个短的（16 位）值填充它。他通过将位移动 16 个空格来设置值。

然后他想把一个 short 数组当作一个 long 数组，所以他可以通过只做 25 次循环迭代而不是 100 次来设置 100 个 16 位值。

这是你老师的想法，但正如其他人所说，这种演员表是未定义的行为。

Answer 3

真是一派胡言。

1. 对于初学者，v 将在编译时计算。

2. 在 long *B = (long*)A; 之后取消引用 B 的行为未定义，因为类型不相关。 B[i] 是 B 的取消引用。

3. 没有任何理由可以假设 long 是 short 的四倍。

以简单的方式使用for 循环并相信编译器会进行优化。很好，上面加糖。

Answer 4

问题有C++标签（没有C标签），所以应该用C++风格来做：

// C++ 03
std::vector<int> tab(100, 3);

// C++ 11
auto tab = std::vector<int>(100, 3);
auto tab2 = std::array<int, 100>{};
tab2.fill(3);

另外，老师正在尝试超越编译器，它可以做令人兴奋的事情。这样做没有意义，因为如果配置正确，编译器可以为您完成：

• Your code assemblies
• Your code assemblies with tick removed
• Array approach
• Vector approach

如您所见，每个版本的-O2 结果代码（几乎）相同。在-O1 的情况下，技巧会有所改进。

所以归根结底，你必须做出选择：

• 编写难以阅读的代码，不要使用编译器优化
• 编写可读代码并使用-O2

使用 Godbolt 站点来试验其他编译器和配置。 另见the latest cppCon talk。

Answer 5

正如其他答案所解释的，该代码违反了类型别名规则并做出了标准不保证的假设。

如果您真的想手动进行此优化，这将是一种具有明确行为的正确方法：

long v;
for(int i=0; i < sizeof v / sizeof *A; i++) {
    v = (v << sizeof *A * CHAR_BIT) + 3;
}

for(int i=0; i < sizeof A / sizeof v; i++) {
    std:memcpy(A + i * sizeof v, &v, sizeof v);
}

使用sizeof 修复了关于对象大小的不安全假设，使用std::memcpy 修复了别名冲突，无论基础类型如何，它都具有明确定义的行为。

也就是说，最好让您的代码保持简单，让编译器发挥它的魔力。

---

为什么我需要左移运算符？

重点是用较小整数的多个副本填充较大的整数。如果您将两个字节的值 s 写入一个大整数 l，然后 shift 剩下两个字节的位（我的固定版本应该更清楚这些幻数的来源）然后您将拥有一个整数，其中包含构成值s 的两个字节副本。重复此操作，直到 l 中的所有字节对都设置为相同的值。要进行班次，您需要班次运算符。

当这些值被复制到包含两字节整数数组的数组上时，单个副本会将多个对象的值设置为较大对象的字节值。由于每对字节具有相同的值，因此数组中较小的整数也将具有相同的值。

为什么我需要另一个 long 数组？

没有long 的数组。只有short 的数组。

Answer 6

你的老师给你看的代码是一个格式错误的程序，不需要诊断，因为它违反了指针实际指向它们声称指向的东西的要求（也称为“严格别名”）。

作为一个具体的例子，编译器可以分析您的程序，注意到A 没有被直接写入，也没有short 被写入，并证明A 在创建后从未更改。

在 C++ 标准下，所有与 B 相关的问题都可以证明是无法在格式良好的程序中修改 A。

for(;;) 循环甚至是 ranged-for 都可能被优化为 A 的静态初始化。你老师的代码，在优化编译器下，将优化为未定义的行为。

如果你真的需要一种方法来创建一个用一个值初始化的数组，你可以使用这个：

template<std::size_t...Is>
auto index_over(std::index_sequence<Is...>) {
  return [](auto&&f)->decltype(auto) {
    return f( std::integral_constant<std::size_t, Is>{}... );
  };
}
template<std::size_t N>
auto index_upto(std::integral_constant<std::size_t, N> ={})
{
  return index_over( std::make_index_sequence<N>{} );
}
template<class T, std::size_t N, T value>
std::array<T, N> make_filled_array() {
  return index_upto<N>()( [](auto...Is)->std::array<T,N>{
    return {{ (void(Is),value)... }};
  });
}

现在：

int main() {

  auto A = make_filled_array<short, 100, 3>();

  std::cout << "\n";
  print(A.data(),100);
}

在编译时创建填充数组，不涉及循环。

使用godbolt，您可以看到数组的值是在编译时计算的，而值 3 是在我访问第 50 个元素时提取的。

然而，这太过分了（和c++14）。

Answer 7

我认为他试图通过同时复制多个数组元素来减少循环迭代的次数。正如其他用户在这里已经提到的那样，这种逻辑会导致未定义的行为。

如果只是为了减少迭代次数，那么通过循环展开我们可以减少迭代次数。但是对于这么小的数组，它不会明显更快。

int main() {

    short int A[100];

    for(int i=0; i<100; i+=4)
    {
        A[i] = 3;
        A[i + 1] = 3;
        A[i + 2] = 3;
        A[i + 3] = 3;
    }
    print(A, 100);
}