一段时间以前，我的老师发布了这段代码，说这是初始化数组到相同数字的另一种方法（当然不是零）。
在这个例子中是三。
他说这种方式比使用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);
}
有许多方法可以用相同的值填充数组，如果您关心性能，那么您需要测量。
C ++有一个专门用于使用值填充数组的函数，我会在包含＃include <algorithm>和＃include <iterator>后使用它：
std::fill(std::begin(A), std::end(A), 3);
你不应该低估优化编译器对这种代码的处理能力。
如果你想看看编译器是如何处理的，那么Matt Godbolt的Compiler Explorer是一个非常好的工具，只要你愿意学一点汇编语言。正如你从这里所看到的，编译器可以将fill调用优化为12个（和一点）128位存储，并展开任何循环。因为编译器了解目标环境，所以它们可以在不将任何特定于目标的假设编码到源代码中的情况下进行优化。
extern？这会导致GCC在A未正确对齐的情况下执行大量无关紧要的操作，使您的观点不太明显。为什么不直接删除extern关键字？ - Ruslanlong比short长四倍（这不是保证；他应该使用int16_t和int64_t）。这些都是胡言乱语。
首先，v 将在 编译时 计算。
在执行 long *B = (long*)A; 后解引用 B 的行为是未定义的，因为这两种类型无关。 B[i] 是对 B 的解引用操作。
完全没有理由认为一个 long 比一个 short 大四倍。
以简单方式使用 for 循环，并信任编译器进行优化。拜托啦，加上糖吧。
这个问题有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);
此外，老师试图聪明地欺骗编译器，但编译器可以执行惊人的事情，如果正确配置，就没有必要这样做。
正如您所看到的，在-O2结果代码方面，每个版本（几乎）相同。对于-O1，技巧可以带来一些改进。
因此，底线是，您必须做出选择：
-O2使用Godbolt网站尝试其他编译器和配置。 另请参阅最新的cppCon演讲。
正如其他答案所解释的那样，该代码违反了类型别名规则，并做出了标准无法保证的假设。
如果您真的想手动进行此优化，这将是一种具有明确定义行为的正确方式：
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，然后向左移动两个字节（我的修正版本应该更清楚地说明这些神奇数字来自哪里），那么你将得到一个整数，其中包含构成值s的字节的两个副本。重复此操作，直到l中的所有字节对都设置为这些相同的值。要执行移位，您需要移位运算符。
当这些值被复制到包含两字节整数数组的数组中时，单个副本将将多个对象的值设置为较大对象的字节值。由于每对字节具有相同的值，因此数组的较小整数也将具有相同的值。
我为什么需要另一个
long数组？
没有long数组，只有short数组。
short int a[4] 而不是 long？ - chialignas。你的建议给了我一个（可能傻）的想法：将两个值写入输出数组，然后复制这两个值，然后复制四个... 这样会给 memcpy 带来相当少的调用（log N），同时避免设置大的“源”数组。这个循环必须在编译时扩展，以便有希望变得更有效率。 - eerorikatemplate<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，您可以看到该数组的值是在编译时计算出来的，并且当我访问第50个元素时提取了值3。
然而，这有些过度（和c++14）。
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);
}
std::array 代替内置数组，并配合一个 make_array 函数模板，该函数将返回一个所有元素均设置为 3（或其他给定数字）的 std::array，如下所示。template<std::size_t N> std::array<int, N> constexpr make_array(int val)
{
std::array<int, N> tempArray{};
for(int &elem:tempArray)
{
elem = val;
}
return tempArray;
}
int main()
{
//-------------------------------V-------->number of elements
constexpr auto arr = make_array<8>(5);
//-------------------------------^---->value of element to be initialized with
//lets confirm if all objects have the expected value
for(const auto &elem: arr)
{
std::cout << elem << std::endl; //prints all 5
}
}
sizeof(long)是8，这种方法可能可行。但它不会比标准方法更快。 - Barmak Shemiranisizeof('a')在C中为sizeof(int)，但在C++中为sizeof(char)）。 - Justin Time - Reinstate Monica