blocks|key|1380191|text|使用{}时，您可以在声明元素时对其进行赋值；其余元素将被初始化为0。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1380192|如果没有要初始化的=+{}，则内容未定义。|offset|length|style|CODE|1380193|entityMap^0|0|9|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

With {} you assign the elements as they are declared; the rest is initialized with 0.

If there is no <code>= {}</code> to initalize, the content is undefined.

blocks|key|1382345|text|使用您使用的语法，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382346|int+array[100]+=+{-1};|code-block|syntax|javascript|1382347|表示“将第一个元素设置为-1，其余元素设置为0”，因为所有省略的元素都设置为0。|offset|length|style|CODE|1382348|在C%2B%2B中，要将它们都设置为-1，可以使用类似于std::fill_n+(来自<algorithm>)的命令：|1382349|std::fill_n(array,+100,+-1);|1382350|在可移植的C中，你必须使用你自己的循环。有编译器扩展，或者您可以依赖于实现定义的行为作为快捷方式，如果这是可以接受的。|1382351|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/algorithm/fill_n^0|0|0|C|2|M|1|12|1|0|E|2|O|B|13|B|O|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]]|9|@$I|1G|J|1H|1|1I]]|A|$]]|$1|O|3|P|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1K|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

Using the syntax that you used,

<pre><code>int array[100] = {-1};
</code></pre>

says "set the first element to <code>-1</code> and the rest to <code>0</code>" since all omitted elements are set to <code>0</code>.

In C++, to set them all to <code>-1</code>, you can use something like <a href="http://en.cppreference.com/w/cpp/algorithm/fill_n" rel="noreferrer"><code>std::fill_n</code></a> (from <code>&lt;algorithm&gt;</code>):

<pre><code>std::fill_n(array, 100, -1);
</code></pre>

In portable C, you have to roll your own loop. There are compiler-extensions or you can depend on implementation-defined behavior as a shortcut if that's acceptable.

blocks|key|1380227|text|您链接的页面状态|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1380228|1380229|如果指定了显式数组大小，但指定了较短的初始化列表，则未指定的元素将设置为零。|blockquote|1380230|1380231|1380232|速度问题:对于这么小的数组，任何差异都可以忽略不计。如果您使用大型数组，并且速度比大小重要得多，那么您可以拥有一个包含默认值(在编译时初始化)的常量数组，然后将它们memcpy到可修改的数组中。|offset|length|style|CODE|1380233|entityMap^0|0|0|0|0|0|2A|6|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|R|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@$J|V|K|W|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|O|$]]

The page you linked states

<blockquote>
 If an explicit array size is specified, but an shorter initiliazation list is specified, the unspecified elements are set to zero.
</blockquote>

Speed issue: Any differences would be negligible for arrays this small. If you work with large arrays and speed is much more important than size, you can have a const array of the default values (initialized at compile time) and then <code>memcpy</code> them to the modifiable array.

blocks|key|1034859|text|1)当您使用初始化器时，对于结构或类似的数组，未指定的值基本上是默认构造的。对于像In这样的原始类型，这意味着它们将被置零。请注意，这是递归应用的:您可以有一个包含数组的结构数组，如果只指定第一个结构的第一个字段，则所有其他的结构都将使用零和默认构造函数进行初始化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1034860|2)编译器可能会生成至少和你手工做的一样好的初始化器代码。在可能的情况下，我倾向于让编译器为我做初始化。|1034861|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

1) When you use an initializer, for a struct or an array like that, the unspecified values are essentially default constructed. In the case of a primitive type like ints, that means they will be zeroed. Note that this applies recursively: you could have an array of structs containing arrays and if you specify just the first field of the first struct, then all the rest will be initialized with zeros and default constructors.

2) The compiler will probably generate initializer code that is at least as good as you could do by hand. I tend to prefer to let the compiler do the initialization for me, when possible.

blocks|key|79869|text|您链接到的页面已经给出了第一部分的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|79870|79871|如果指定了显式数组大小，但指定了较短的初始化列表，则未指定的元素将设置为零。|blockquote|79872|79873|79874|没有内置的方法可以将整个数组初始化为某个非零值。|79875|至于哪个更快，通常的规则是：“给予编译器最大自由度的方法可能更快”。|79876|int+array[100]+=+{0};|code-block|syntax|javascript|79877|简单地告诉编译器“将这100个整数设置为零”，编译器可以自由优化。|79878|for+(int+i+=+0;+i+<+100;+%2B%2Bi){
++array[i]+=+0;
}|79879|更加具体。它告诉编译器创建一个迭代变量i，它告诉它元素应该被初始化的顺序，等等。当然，编译器可能会对此进行优化，但问题的关键在于，您在这里过度指定了问题，迫使编译器更加努力地工作以获得相同的结果。|offset|length|style|CODE|79880|最后，如果希望将数组设置为非零值，则应该(至少在C%2B%2B中)使用std::fill|79881|std::fill(array,+array%2B100,+42);+//+sets+every+value+in+the+array+to+42|79882|同样，您也可以对数组执行相同的操作，但这更简洁，并给了编译器更多的自由。您只是想让整个数组充满值42。你没有说任何关于它应该按什么顺序完成的事情，或者任何其他的事情。|79883|entityMap^0|0|0|0|0|0|0|0|0|0|0|J|1|0|V|9|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1A|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1D|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1E|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1F|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1H|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1I|8|@$W|1J|X|1K|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1L|8|@$W|1M|X|1N|Y|Z]]|9|@]|A|$]]|$1|12|3|13|5|N|7|1O|8|@]|9|@]|A|$O|P]]|$1|14|3|15|5|6|7|1P|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|17|$]]

The page you linked to already gave the answer to the first part:

<blockquote>
 If an explicit array size is
 specified, but an shorter
 initiliazation list is specified, the
 unspecified elements are set to zero.
</blockquote>

There is no built-in way to initialize the entire array to some non-zero value.

As for which is faster, the usual rule applies: "The method that gives the compiler the most freedom is probably faster".

<pre><code>int array[100] = {0};
</code></pre>

simply tells the compiler "set these 100 ints to zero", which the compiler can optimize freely.

<pre><code>for (int i = 0; i &lt; 100; ++i){
 array[i] = 0;
}
</code></pre>

is a lot more specific. It tells the compiler to create an iteration variable <code>i</code>, it tells it the order in which the elements should be initialized, and so on. Of course, the compiler is likely to optimize that away, but the point is that here you are overspecifying the problem, forcing the compiler to work harder to get to the same result.

Finally, if you want to set the array to a non-zero value, you should (in C++, at least) use <code>std::fill</code>:

<pre><code>std::fill(array, array+100, 42); // sets every value in the array to 42
</code></pre>

Again, you could do the same with an array, but this is more concise, and gives the compiler more freedom. You're just saying that you want the entire array filled with the value 42. You don't say anything about in which order it should be done, or anything else.

blocks|key|1034951|text|有一个对gcc编译器的扩展，它允许使用以下语法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1034952|int+array[100]+=+{+[0+...+99]+=+-1+};|code-block|syntax|javascript|1034953|这会将所有元素设置为-1。|1034954|这就是所谓的“指定初始化器”。有关详细信息，请参阅here。|offset|length|1034955|注意:这不是为gcc+c%2B%2B编译器实现的。|1034956|entityMap|0|LINK|mutability|MUTABLE|url|http://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html^0|0|0|0|P|4|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$K|10|L|11|1|12]]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

There is an extension to the gcc compiler which allows the syntax:

<pre><code>int array[100] = { [0 ... 99] = -1 };
</code></pre>

This would set all of the elements to -1.

This is known as "Designated Initializers" see <a href="http://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html" rel="noreferrer">here</a> for further information.

Note this isn't implemented for the gcc c++ compiler.

blocks|key|1034995|text|对于单字节元素数组的情况，可以使用memset将所有元素设置为相同的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1034996|这里有一个here的例子。|offset|length|1034997|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/clibrary/cstring/memset/^0|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

For the case of an array of single-byte elements, you can use memset to set all elements to the same value.

There's an example <a href="http://www.cplusplus.com/reference/clibrary/cstring/memset/" rel="nofollow noreferrer">here</a>.

blocks|key|1382469|text|在C%2B%2B中，还可以使用元编程和可变模板。下面的帖子展示了如何做到这一点：Programmatically+create+static+arrays+at+compile+time+in+C%2B%2B。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1382470|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2978259/programmatically-create-static-arrays-at-compile-time-in-c^0|10|1O|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

In C++, it is also possible to use meta programming and variadic templates. The following post shows how to do it: <a href="https://stackoverflow.com/questions/2978259/programmatically-create-static-arrays-at-compile-time-in-c">Programmatically create static arrays at compile time in C++</a>.

blocks|key|1035067|text|在C%2B%2B编程语言V4中，Stroustrup建议使用向量或valarrays而不是内置数组。使用valarrary，当您创建它们时，您可以将它们初始化为一个特定值，如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1035068|valarray+<int>seven7s=(7777777,7);|code-block|syntax|javascript|1035069|初始化具有"7777777“的7个成员长度的数组。|1035070|这是一种使用C%2B%2B数据结构而不是“普通的C”数组实现答案的C%2B%2B方法。|1035071|我切换到使用valarray作为在我的代码中尝试使用C%2B%2B体系结构与C体系结构的尝试……|1035072|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In the C++ programming language V4, Stroustrup recommends using vectors or valarrays over builtin arrays. With valarrary's, when you create them, you can init them to a specific value like:

<pre><code>valarray &lt;int&gt;seven7s=(7777777,7);
</code></pre>

To initialize an array 7 members long with "7777777".

This is a C++ way of implementing the answer using a C++ data structure instead of a "plain old C" array.

I switched to using the valarray as an attempt in my code to try to use C++'isms v. C'isms....

blocks|key|1035113|text|将数组初始化为公用值的另一种方法是实际生成一系列定义中的元素列表：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1035114|#define+DUP1(+X+)+(+X+)
#define+DUP2(+X+)+DUP1(+X+),+(+X+)
#define+DUP3(+X+)+DUP2(+X+),+(+X+)
#define+DUP4(+X+)+DUP3(+X+),+(+X+)
#define+DUP5(+X+)+DUP4(+X+),+(+X+)
.
.
#define+DUP100(+X+)+DUP99(+X+),+(+X+)

#define+DUPx(+X,+N+)+DUP##N(+X+)
#define+DUP(+X,+N+)+DUPx(+X,+N+)|code-block|syntax|javascript|1035115|可以轻松地将数组初始化为公用值：|1035116|#define+LIST_MAX+6
static+unsigned+char+List[+LIST_MAX+]=+{+DUP(+123,+LIST_MAX+)+};|1035117|注意:引入DUPx是为了在DUP的参数中启用宏替换|1035118|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Another way of initializing the array to a common value, would be to actually generate the list of elements in a series of defines:

<pre><code>#define DUP1( X ) ( X )
#define DUP2( X ) DUP1( X ), ( X )
#define DUP3( X ) DUP2( X ), ( X )
#define DUP4( X ) DUP3( X ), ( X )
#define DUP5( X ) DUP4( X ), ( X )
.
.
#define DUP100( X ) DUP99( X ), ( X )

#define DUPx( X, N ) DUP##N( X )
#define DUP( X, N ) DUPx( X, N )
</code></pre>

Initializing an array to a common value can easily be done:

<pre><code>#define LIST_MAX 6
static unsigned char List[ LIST_MAX ]= { DUP( 123, LIST_MAX ) };
</code></pre>

Note: DUPx introduced to enable macro substitution in parameters to DUP

blocks|key|4252605|text|C%2B%2B11有另一个(不完美的)选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4252606|std::array<int,+100>+a;
a.fill(-1);|code-block|syntax|javascript|4252607|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

C++11 has another (imperfect) option:

<pre><code>std::array&lt;int, 100&gt; a;
a.fill(-1);
</code></pre>

blocks|key|1035205|text|使用std::array，我们可以在C%2B%2B14中以一种相当简单的方式做到这一点，在C%2B%2B11中也可以做到，但是稍微复杂一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1035206|我们的接口是编译时大小和默认值。|1035207|template<typename+T>
constexpr+auto+make_array_n(std::integral_constant<std::size_t,+0>,+T+&&)+{
++++return+std::array<std::decay_t<T>,+0>{};
}

template<std::size_t+size,+typename+T>
constexpr+auto+make_array_n(std::integral_constant<std::size_t,+size>,+T+&&+value)+{
++++return+detail::make_array_n_impl<size>(std::forward<T>(value),+std::make_index_sequence<size+-+1>{});
}


template<std::size_t+size,+typename+T>
constexpr+auto+make_array_n(T+&&+value)+{
++++return+make_array_n(std::integral_constant<std::size_t,+size>{},+std::forward<T>(value));
}|code-block|syntax|javascript|1035208|第三个函数主要是为了方便，所以用户不必自己构造std::integral_constant<std::size_t,+size>，因为这是一个相当繁琐的构造。真正的工作是由前两个函数之一完成的。|1035209|第一个重载非常简单:它构造一个大小为0的std::array。没有复制的必要，我们只需要构造它。|1035210|第二个重载有点棘手。它转发它作为源获得的值，它还构造了make_index_sequence的一个实例，并只是调用一些其他实现函数。这个函数是什么样子的？|1035211|namespace+detail+{

template<std::size_t+size,+typename+T,+std::size_t...+indexes>
constexpr+auto+make_array_n_impl(T+&&+value,+std::index_sequence<indexes...>)+{
++++//+Use+the+comma+operator+to+expand+the+variadic+pack
++++//+Move+the+last+element+in+if+possible.+Order+of+evaluation+is+well-defined
++++//+for+aggregate+initialization,+so+there+is+no+risk+of+copy-after-move
++++return+std::array<std::decay_t<T>,+size>{+(static_cast<void>(indexes),+value)...,+std::forward<T>(value)+};
}

}+++//+namespace+detail|1035212|这通过复制我们传入的值来构造第一个size+-1参数。在这里，我们使用我们的可变参数包索引作为扩展。在该包中有大小为1的条目(正如我们在make_index_sequence的构造中指定的那样)，它们的值为0、1、2、3、...、大小-+2。但是，我们并不关心这些值(因此我们将其强制转换为空，以使任何编译器警告静默)。参数包扩展将我们的代码扩展为如下所示(假设大小为==+4)：|1035213|return+std::array<std::decay_t<T>,+4>{+(static_cast<void>(0),+value),+(static_cast<void>(1),+value),+(static_cast<void>(2),+value),+std::forward<T>(value)+};|1035214|我们使用这些括号来确保可变包扩展...扩展了我们想要的内容，并确保我们使用的是逗号运算符。如果没有括号，看起来就像是我们向数组初始化传递了一堆参数，但实际上，我们是在计算索引，将其强制转换为void，忽略void结果，然后返回值，该值被复制到数组中。|1035215|最后一个参数，也就是我们调用std::forward的参数，是一个小的优化。如果有人传入一个临时std::string并说“生成一个5个这样的数组”，我们希望有4个副本和1个移动，而不是5个副本。std::forward确保我们做到这一点。|1035216|完整的代码，包括头文件和一些单元测试：|1035217|#include+<array>
#include+<type_traits>
#include+<utility>

namespace+detail+{

template<std::size_t+size,+typename+T,+std::size_t...+indexes>
constexpr+auto+make_array_n_impl(T+&&+value,+std::index_sequence<indexes...>)+{
++++//+Use+the+comma+operator+to+expand+the+variadic+pack
++++//+Move+the+last+element+in+if+possible.+Order+of+evaluation+is+well-defined
++++//+for+aggregate+initialization,+so+there+is+no+risk+of+copy-after-move
++++return+std::array<std::decay_t<T>,+size>{+(static_cast<void>(indexes),+value)...,+std::forward<T>(value)+};
}

}+++//+namespace+detail

template<typename+T>
constexpr+auto+make_array_n(std::integral_constant<std::size_t,+0>,+T+&&)+{
++++return+std::array<std::decay_t<T>,+0>{};
}

template<std::size_t+size,+typename+T>
constexpr+auto+make_array_n(std::integral_constant<std::size_t,+size>,+T+&&+value)+{
++++return+detail::make_array_n_impl<size>(std::forward<T>(value),+std::make_index_sequence<size+-+1>{});
}

template<std::size_t+size,+typename+T>
constexpr+auto+make_array_n(T+&&+value)+{
++++return+make_array_n(std::integral_constant<std::size_t,+size>{},+std::forward<T>(value));
}



struct+non_copyable+{
++++constexpr+non_copyable()+=+default;
++++constexpr+non_copyable(non_copyable+const+&)+=+delete;
++++constexpr+non_copyable(non_copyable+&&)+=+default;
};

int+main()+{
++++constexpr+auto+array_n+=+make_array_n<6>(5);
++++static_assert(std::is_same<std::decay_t<decltype(array_n)>::value_type,+int>::value,+"Incorrect+type+from+make_array_n.");
++++static_assert(array_n.size()+==+6,+"Incorrect+size+from+make_array_n.");
++++static_assert(array_n[3]+==+5,+"Incorrect+values+from+make_array_n.");

++++constexpr+auto+array_non_copyable+=+make_array_n<1>(non_copyable{});
++++static_assert(array_non_copyable.size()+==+1,+"Incorrect+array+size+of+1+for+move-only+types.");

++++constexpr+auto+array_empty+=+make_array_n<0>(2);
++++static_assert(array_empty.empty(),+"Incorrect+array+size+for+empty+array.");

++++constexpr+auto+array_non_copyable_empty+=+make_array_n<0>(non_copyable{});
++++static_assert(array_non_copyable_empty.empty(),+"Incorrect+array+size+for+empty+array+of+move-only.");
}|1035218|entityMap^0|2|A|0|0|0|N|15|0|K|A|0|R|J|0|0|1W|J|0|0|G|3|0|E|C|2Q|C|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|W|3|X|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|14|3|15|5|J|7|20|8|@]|D|@]|E|$K|L]]|$1|16|3|-4|5|6|7|21|8|@]|D|@]|E|$]]]|17|$]]

Using <code>std::array</code>, we can do this in a fairly straightforward way in C++14. It is possible to do in C++11 only, but slightly more complicated.

Our interface is a compile-time size and a default value.

<pre><code>template&lt;typename T&gt;
constexpr auto make_array_n(std::integral_constant&lt;std::size_t, 0&gt;, T &amp;&amp;) {
 return std::array&lt;std::decay_t&lt;T&gt;, 0&gt;{};
}

template&lt;std::size_t size, typename T&gt;
constexpr auto make_array_n(std::integral_constant&lt;std::size_t, size&gt;, T &amp;&amp; value) {
 return detail::make_array_n_impl&lt;size&gt;(std::forward&lt;T&gt;(value), std::make_index_sequence&lt;size - 1&gt;{});
}


template&lt;std::size_t size, typename T&gt;
constexpr auto make_array_n(T &amp;&amp; value) {
 return make_array_n(std::integral_constant&lt;std::size_t, size&gt;{}, std::forward&lt;T&gt;(value));
}
</code></pre>

The third function is mainly for convenience, so the user does not have to construct a <code>std::integral_constant&lt;std::size_t, size&gt;</code> themselves, as that is a pretty wordy construction. The real work is done by one of the first two functions.

The first overload is pretty straightforward: It constructs a <code>std::array</code> of size 0. There is no copying necessary, we just construct it.

The second overload is a little trickier. It forwards along the value it got as the source, and it also constructs an instance of <code>make_index_sequence</code> and just calls some other implementation function. What does that function look like?

<pre><code>namespace detail {

template&lt;std::size_t size, typename T, std::size_t... indexes&gt;
constexpr auto make_array_n_impl(T &amp;&amp; value, std::index_sequence&lt;indexes...&gt;) {
 // Use the comma operator to expand the variadic pack
 // Move the last element in if possible. Order of evaluation is well-defined
 // for aggregate initialization, so there is no risk of copy-after-move
 return std::array&lt;std::decay_t&lt;T&gt;, size&gt;{ (static_cast&lt;void&gt;(indexes), value)..., std::forward&lt;T&gt;(value) };
}

} // namespace detail
</code></pre>

This constructs the first size - 1 arguments by copying the value we passed in. Here, we use our variadic parameter pack indexes just as something to expand. There are size - 1 entries in that pack (as we specified in the construction of <code>make_index_sequence</code>), and they have values of 0, 1, 2, 3, ..., size - 2. However, we do not care about the values (so we cast it to void, to silence any compiler warnings). Parameter pack expansion expands out our code to something like this (assuming size == 4):

<pre><code>return std::array&lt;std::decay_t&lt;T&gt;, 4&gt;{ (static_cast&lt;void&gt;(0), value), (static_cast&lt;void&gt;(1), value), (static_cast&lt;void&gt;(2), value), std::forward&lt;T&gt;(value) };
</code></pre>

We use those parentheses to ensure that the variadic pack expansion <code>...</code> expands what we want, and also to ensure we are using the comma operator. Without the parentheses, it would look like we are passing a bunch of arguments to our array initialization, but really, we are evaluating the index, casting it to void, ignoring that void result, and then returning value, which is copied into the array.

The final argument, the one we call <code>std::forward</code> on, is a minor optimization. If someone passes in a temporary std::string and says "make an array of 5 of these", we would like to have 4 copies and 1 move, instead of 5 copies. The <code>std::forward</code> ensures that we do this.

The full code, including headers and some unit tests:

<pre><code>#include &lt;array&gt;
#include &lt;type_traits&gt;
#include &lt;utility&gt;

namespace detail {

template&lt;std::size_t size, typename T, std::size_t... indexes&gt;
constexpr auto make_array_n_impl(T &amp;&amp; value, std::index_sequence&lt;indexes...&gt;) {
 // Use the comma operator to expand the variadic pack
 // Move the last element in if possible. Order of evaluation is well-defined
 // for aggregate initialization, so there is no risk of copy-after-move
 return std::array&lt;std::decay_t&lt;T&gt;, size&gt;{ (static_cast&lt;void&gt;(indexes), value)..., std::forward&lt;T&gt;(value) };
}

} // namespace detail

template&lt;typename T&gt;
constexpr auto make_array_n(std::integral_constant&lt;std::size_t, 0&gt;, T &amp;&amp;) {
 return std::array&lt;std::decay_t&lt;T&gt;, 0&gt;{};
}

template&lt;std::size_t size, typename T&gt;
constexpr auto make_array_n(std::integral_constant&lt;std::size_t, size&gt;, T &amp;&amp; value) {
 return detail::make_array_n_impl&lt;size&gt;(std::forward&lt;T&gt;(value), std::make_index_sequence&lt;size - 1&gt;{});
}

template&lt;std::size_t size, typename T&gt;
constexpr auto make_array_n(T &amp;&amp; value) {
 return make_array_n(std::integral_constant&lt;std::size_t, size&gt;{}, std::forward&lt;T&gt;(value));
}



struct non_copyable {
 constexpr non_copyable() = default;
 constexpr non_copyable(non_copyable const &amp;) = delete;
 constexpr non_copyable(non_copyable &amp;&amp;) = default;
};

int main() {
 constexpr auto array_n = make_array_n&lt;6&gt;(5);
 static_assert(std::is_same&lt;std::decay_t&lt;decltype(array_n)&gt;::value_type, int&gt;::value, "Incorrect type from make_array_n.");
 static_assert(array_n.size() == 6, "Incorrect size from make_array_n.");
 static_assert(array_n[3] == 5, "Incorrect values from make_array_n.");

 constexpr auto array_non_copyable = make_array_n&lt;1&gt;(non_copyable{});
 static_assert(array_non_copyable.size() == 1, "Incorrect array size of 1 for move-only types.");

 constexpr auto array_empty = make_array_n&lt;0&gt;(2);
 static_assert(array_empty.empty(), "Incorrect array size for empty array.");

 constexpr auto array_non_copyable_empty = make_array_n&lt;0&gt;(non_copyable{});
 static_assert(array_non_copyable_empty.empty(), "Incorrect array size for empty array of move-only.");
}
</code></pre>

blocks|key|4252677|text|我希望它是一个标准功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4252678|#include+<stdio.h>

+__asm__
+(
"++++.global+_arr;++++++"
"++++.section+.data;++++"
"_arr:+.fill+100,+1,+2;+"
+);

extern+char+arr[];

int+main()+
{
++++int+i;
++
++++for(i+=+0;+i+<+100;+%2B%2Bi)+{
++++++++printf("arr[%25u]+=+%25u.\n",+i,+arr[i]);
++++}
}|code-block|syntax|javascript|4252679|在Fortran中，你可以这样做：|4252680|program+main
++++implicit+none

++++byte+a(100)
++++data+a+/100*2/
++++integer+i

++++do+i+=+0,+100
++++++++print+*,+a(i)
++++end+do
end|4252681|不过，据我所知，它没有无符号的数字。|4252682|我希望现代的C/C%2B%2B能像下面的代码一样用它来速记：|4252683|#include+<stdio.h>
#include+<stdint.h>

/*+did+I+count+it+correctly?+I'm+not+quite+sure.+*/
uint8_t+arr[]+=+{
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
++++2,+2,+2,+2,+2,+2,+2,+2,+2,+2,
};++++

int+main(int+argc,+char+**argv)+
{
++++int+i;

++++for(i+=+0;+i+<+100;+%2B%2Bi)+{
++++++++printf("arr[%25u]+=+%25u.\n",+i,+arr[i]);
++++}
++++
++++return+0;
}|4252684|如果它是一个1,000,000字节的数组，它将会令人沮丧得多，可能会让人们选择在运行时使用函数进行填充。|4252685|它是完全可移植的，它没有理由不在语言中。|4252686|就像这样破解它：|4252687|#include+<stdio.h>
#include+<stdint.h>

/*+a+byte+array+of+100+twos+declared+at+compile+time.+*/
uint8_t+twos[]+=+{100:2};

int+main()
{
++++uint_fast32_t+i;
++++for+(i+=+0;+i+<+100;+%2B%2Bi)+{
++++++++printf("twos[%25u]+=+%25u.\n",+i,+twos[i]);
++++}

++++return+0;
}|4252688|破解它的一种方法是通过预处理...(下面的代码没有涵盖边缘情况，但编写这些代码是为了快速演示可以完成的工作。)|4252689|#!/usr/bin/perl
use+warnings;
use+strict;

open+my+$inf,+"<main.c";
open+my+$ouf,+">out.c";

my+@lines+=+<$inf>;

foreach+my+$line+(@lines)+{
++++if+($line+=~+m/({(\d%2B):(\d%2B)})/)+{
++++++++printf+("$1,+$2,+$3");++++++++
++++++++my+$lnew+=+"{"+.+"$3,+"x($2+-+1)+.+$3+.+"}";
++++++++$line+=~+s/{(\d%2B:\d%2B)}/$lnew/;
++++++++printf+$ouf+$line;
++++}+else+{
++++++++printf+$ouf+$line;
++++}
}

close($ouf);
close($inf);|4252690|注意:这是2016年的一个幼稚(笨拙的膝跳)的答案，当时兼容性问题还没有打击到我，我真的很想拥有这个功能，并试图天真地自己“自动化”它。我不再希望语言“仅仅因为我想要它们就获得很酷的新功能”，因为处理由此产生的向后兼容性是一场噩梦，维护自定义工具以实现自动化也不是特别有趣。|4252691|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1H|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|1J|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

I wish it was a standard feature:
<pre><code>#include &lt;stdio.h&gt;

 __asm__
 (
&quot; .global _arr; &quot;
&quot; .section .data; &quot;
&quot;_arr: .fill 100, 1, 2; &quot;
 );

extern char arr[];

int main() 
{
 int i;
 
 for(i = 0; i &lt; 100; ++i) {
 printf(&quot;arr[%u] = %u.\n&quot;, i, arr[i]);
 }
}
</code></pre>
In Fortran you could do:
<pre><code>program main
 implicit none

 byte a(100)
 data a /100*2/
 integer i

 do i = 0, 100
 print *, a(i)
 end do
end
</code></pre>
Though, as far as I know, it does not have unsigned numbers.
I wish modern C/C++ had it as a shorthand to doing things like in the code below:
<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdint.h&gt;

/* did I count it correctly? I'm not quite sure. */
uint8_t arr[] = {
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
}; 

int main(int argc, char **argv) 
{
 int i;

 for(i = 0; i &lt; 100; ++i) {
 printf(&quot;arr[%u] = %u.\n&quot;, i, arr[i]);
 }
 
 return 0;
}
</code></pre>
If it was an array of 1,000,000 bytes it would be a lot more frustrating, probably making people to opt for doing the filling at runtime using a function.
It's perfectly portable, there's no reason for it not to be in the language.
Just hack it in like:
<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdint.h&gt;

/* a byte array of 100 twos declared at compile time. */
uint8_t twos[] = {100:2};

int main()
{
 uint_fast32_t i;
 for (i = 0; i &lt; 100; ++i) {
 printf(&quot;twos[%u] = %u.\n&quot;, i, twos[i]);
 }

 return 0;
}
</code></pre>
One way to hack it in is via preprocessing... (Code below does not cover edge cases, but is written to quickly demonstrate what could be done.)
<pre><code>#!/usr/bin/perl
use warnings;
use strict;

open my $inf, &quot;&lt;main.c&quot;;
open my $ouf, &quot;&gt;out.c&quot;;

my @lines = &lt;$inf&gt;;

foreach my $line (@lines) {
 if ($line =~ m/({(\d+):(\d+)})/) {
 printf (&quot;$1, $2, $3&quot;); 
 my $lnew = &quot;{&quot; . &quot;$3, &quot;x($2 - 1) . $3 . &quot;}&quot;;
 $line =~ s/{(\d+:\d+)}/$lnew/;
 printf $ouf $line;
 } else {
 printf $ouf $line;
 }
}

close($ouf);
close($inf);
</code></pre>
note: this is a naive(clumsy knee jerk) answer from 2016, at the time the issues of compatibility didn't hit me, and I really wanted to have this feature and tried to naively &quot;automate&quot; it myself. I no longer want languages to get &quot;cool new features just because I want them&quot; because dealing with backward compatibility from that is a nightmare, and maintaining custom tools to automate conveniences is also not particularly fun.

<a href="http://www.fredosaurus.com/notes-cpp/arrayptr/array-initialization.html" rel="noreferrer">C++ Notes: Array Initialization</a> has a nice list over initialization of arrays. I have a

<pre><code>int array[100] = {-1};
</code></pre>

expecting it to be full with -1's but its not, only first value is and the rest are 0's mixed with random values.

The code

<pre><code>int array[100] = {0};
</code></pre>

works just fine and sets each element to 0.

What am I missing here.. Can't one initialize it if the value isn't zero ?

And 2: Is the default initialization (as above) faster than the usual loop through the whole array and assign a value or does it do the same thing?

Initialization of all elements of an array to one default value in C++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有一个关于数组初始化的很好的列表。我有一个int array[100] = {-1};期望它充满-1，但事实并非如此，只有第一个值是，其余的都是0和随机值的混合。代码int array[100] = {0};工作正常，并将每个元素设置为0。我在这里错过了什么..。如果值不是零，就不能初始化它吗？和2:默认初始化(如上所...

问是否在C++中将数组的所有元素初始化为一个默认值？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否在C++中将数组的所有元素初始化为一个默认值？EN