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

小开

使用{}可以在声明元素时赋值;其余部分初始化为0。

如果没有= {}来初始化，则内容是未定义的。

小开

最佳答案

用你用过的语法，

int array[100] = {-1};

表示“将第一个元素设置为-1，其余的设置为0”，因为所有省略的元素都设置为0。

在c++中，要将它们全部设置为-1，你可以使用类似std::fill_n (from <algorithm>)的东西:

std::fill_n(array, 100, -1);

在便携式C语言中，你必须自己进行循环。有编译器扩展，或者如果可以接受，可以依赖实现定义的行为作为快捷方式。

小开

您链接的页面状态

如果指定了显式数组大小，但指定了较短的初始化列表，则未指定的元素将被设置为零。

速度问题:对于这么小的数组，任何差异都可以忽略不计。如果你使用大型数组，并且速度比大小重要得多，你可以有一个默认值的const数组(在编译时初始化)，然后memcpy它们到可修改数组。

小开

1)当你使用初始化式时，对于一个结构或数组，未指定的值本质上是默认构造的。对于像int这样的基本类型，这意味着它们将被归零。注意，这是递归应用的:你可以有一个包含数组的结构体数组，如果你只指定第一个结构体的第一个字段，那么其余的都将用0和默认构造函数初始化。

2)编译器生成的初始化代码至少和你手工编写的一样好。如果可能的话，我倾向于让编译器为我进行初始化。

小开

你所链接的页面已经给出了第一部分的答案:

如果显式数组大小为指定，但更短初始化列表，则未指定的元素被设置为0

没有内置方法将整个数组初始化为某个非零值。

至于哪个更快，通常的规则是:“给编译器最大自由的方法可能更快”。

int array[100] = {0};

简单地告诉编译器“将这100个整数设置为零”，编译器可以自由优化。

for (int i = 0; i < 100; ++i){
array[i] = 0;
}

更加具体。它告诉编译器创建一个迭代变量i，它告诉编译器应该在其中初始化元素的订单，等等。当然，编译器很可能会优化掉这个问题，但问题的关键在于，这里您过度指定了问题，迫使编译器更加努力地工作才能得到相同的结果。

最后，如果你想将数组设置为一个非零值，你应该(至少在c++中)使用std::fill:

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

同样，你也可以用数组来做同样的事情，但是这样更简洁，并且给了编译器更多的自由。你只是说你想让整个数组充满值42。你没有说应该按什么顺序做，或者其他什么。

小开

gcc编译器有一个扩展，允许以下语法:

int array[100] = { [0 ... 99] = -1 };

这将把所有元素都设为-1。

这被称为“指定初始化器”，详见在这里。

注意，这不是gcc c++编译器实现的。

小开

对于单字节元素数组，可以使用memset将所有元素设置为相同的值。

有一个例子在这里。

小开

在c++编程语言V4中，Stroustrup建议使用vector或valarray而不是内置数组。使用valarray，当你创建它们时，你可以初始化它们为一个特定的值，比如:

valarray <int>seven7s=(7777777,7);

初始化一个包含"7777777"成员的数组。

这是一种c++实现答案的方式，使用c++数据结构而不是“普通的旧C”数组。

我转而使用valarray作为在我的代码中尝试使用c++ 'isms v. C'isms....的尝试

小开

另一种将数组初始化为公共值的方法是实际生成一系列定义中的元素列表:

#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 )

将数组初始化为一个公共值很容易做到:

#define LIST_MAX 6
static unsigned char List[ LIST_MAX ]= { DUP( 123, LIST_MAX ) };

注意:引入DUPx是为了在参数中对DUP进行宏替换

小开

c++ 11还有另一个(不完善的)选项:

std::array<int, 100> a;
a.fill(-1);

小开

使用std::array，我们可以在c++ 14中以相当直接的方式做到这一点。这只能在c++ 11中实现，但是稍微复杂一些。

我们的接口是一个编译时大小和默认值。

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));
}

第三个函数主要是为了方便，所以用户不必自己构造std::integral_constant<std::size_t, size>，因为那是一个相当冗长的构造。真正的工作是由前两个函数中的一个完成的。

第一个重载非常简单:它构造了一个大小为0的std::array。没有复制的必要，我们只是构造它。

第二个过载有点棘手。它沿着它得到的值作为源转发，它还构造了make_index_sequence的一个实例，并调用其他一些实现函数。这个函数是什么样的呢?

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

它通过复制传入的值来构造第一个size - 1参数。在这里，我们使用可变参数包索引作为扩展。该包中有大小为- 1的条目(正如我们在make_index_sequence的构造中指定的那样)，它们的值为0,1,2,3，…，大小- 2。但是，我们并不关心这些值(因此将其强制转换为void，以消除任何编译器警告)。参数包展开将我们的代码展开成这样(假设size == 4):

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) };

我们使用这些圆括号来确保可变包展开...展开了我们想要的内容，也确保我们使用了逗号操作符。如果没有括号，看起来就像我们在给数组初始化传递一堆参数，但实际上，我们是在计算索引，将它强制转换为void，忽略void结果，然后返回value，它被复制到数组中。

最后一个参数，即我们称之为std::forward on的参数，是一个小的优化。如果有人传入一个临时的std::string并说“创建一个5个这样的数组”，我们希望有4个副本和1个移动，而不是5个副本。std::forward确保我们这样做。

完整的代码，包括头文件和一些单元测试:

#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.");
}

小开

最简单的方法是使用std::array并编写一个函数模板，该函数模板将返回所需的std::array，其中所有元素都用传递的参数初始化，如下所示。

c++ 11版本

template<std::size_t N> std::array<int, N> make_array(int val)
{
std::array<int, N> tempArray{};
for(int &elem:tempArray)
{
elem = val;
}
return tempArray;
}
int main()
{
//---------------------V-------->number of elements
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
}
    

}

工作演示

c++ 17版本

在c++ 17中，你可以将constexpr添加到函数模板中，这样它就可以在constexpr上下文中使用:

//-----------------------------------------vvvvvvvvv--->added constexpr
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()
{
//--vvvvvvvvv------------------------------>constexpr added
constexpr auto arr  = make_array<8>(5);


for(const auto &elem: arr)
{
std::cout << elem << std::endl;
}
    

}

工作演示