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

C ++注意：数组初始化在数组初始化方面有一个不错的清单。我有一个

int array[100] = {-1};

期望它充满-1，但不是，只有第一个值是，其余为0和随机值的混合。

代码

int array[100] = {0};

可以正常工作并将每个元素设置为0。

我在这里想念的是什么。如果值不为零，无法初始化吗？

和2：默认初始化（如上所述）是否比遍历整个数组并分配值的常规循环更快？

使用您使用的语法，

int array[100] = {-1};

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

在C ++中，要将它们全部设置为-1，可以使用std::fill_n（from <algorithm>）之类的东西：

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

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

gcc编译器有一个扩展，它允许使用以下语法：

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

这会将所有元素设置为-1。

这称为“指定的初始化程序”，请参见此处以获取更多信息。

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

您链接到的页面已经给出了第一部分的答案：

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

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

至于哪个更快，通常的规则适用：“赋予编译器最大自由度的方法可能更快”。

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。您什么也没有说要按什么顺序完成。

C ++ 11还有另一个（不完善的）选项：

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

使用{}，您可以在声明元素时分配它们；其余的初始化为0。

如果没有= {}要初始化的内容，则内容是不确定的。

您链接的页面状态

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

速度问题：对于这么小的阵列，任何差异都可以忽略不计。如果使用大型数组，并且速度比大小重要得多，则可以使用默认值的const数组（在编译时进行初始化），然后memcpy将其更改为可修改的数组。

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

#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的参数中启用宏替换

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

这里有一个例子在这里。

使用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>自己构造自己，因为这是一个冗长的构造。真正的工作是由前两个功能之一完成的。

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

第二次过载有点棘手。它沿着作为源获得的值进行转发，并且还构造的实例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

这将通过复制传入的值来构造第一个大小-1个参数。在这里，我们使用可变参数包索引来扩展内容。该数据包中有大小-1个条目（如我们在的构造中所指定make_index_sequence），并且它们的值分别为0、1、2、3，...，大小-2。但是，我们并不关心这些值（因此我们将其强制转换为void，以使所有编译器警告均无效）。参数包扩展将我们的代码扩展为如下所示（假设大小== 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结果，然后返回值，将其复制到数组中。

最后一个参数，我们呼吁的std::forward是一个次要的优化。如果有人传入一个临时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.");
}

1）使用初始化程序时，对于类似的结构或数组，未指定的值实质上是默认构造的。对于像int这样的基本类型，这意味着它们将被清零。请注意，这是递归应用的：您可以有一个包含数组的结构数组，并且如果仅指定第一个结构的第一个字段，则所有其余结构将使用零和默认构造函数初始化。

2）编译器可能会生成初始化代码，该代码至少与您手工完成的代码一样好。如果可能的话，我倾向于让编译器为我进行初始化。

在C ++中，也可以使用元编程和可变参数模板。以下文章展示了如何做到这一点：在C ++中，在编译时以编程方式创建静态数组。

在C ++编程语言V4中，Stroustrup建议在内置数组上使用向量或valarray。使用valarrary，在创建它们时，可以将它们初始化为特定值，例如：

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

要初始化一个数组，其长度为7个成员，名称为“ 7777777”。

这是一种使用C ++数据结构而不是“普通C语言”数组来实现答案的C ++方法。

我改用valarray作为代码尝试使用C ++'isms v。C'isms...。

应该是标准功能，但是由于某种原因它没有包含在标准C或C ++中...

#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; ++i) {
        printf("arr[%u] = %u.\n", i, arr[i]);
    }
}

在Fortran中，您可以执行以下操作：

program main
    implicit none

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

    do i = 0, 100
        print *, a(i)
    end do
end

但它没有无符号数字...

为什么C / C ++不能仅仅实现它。真的那么难吗？必须手动编写以达到相同结果真是太愚蠢了...

#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 i;

    for(i = 0; i < 100; ++i) {
        printf("arr[%u] = %u.\n", i, arr[i]);
    }
}

如果它是一个1,000,00字节的数组怎么办？我需要编写一个脚本来为我编写脚本，或者使用Assembly / etc进行破解。这是无稽之谈。

它完全可移植，没有理由不使用该语言。

只需像这样入侵即可：

#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; ++i) {
        printf("twos[%u] = %u.\n", i, twos[i]);
    }

    return 0;
}

破解它的一种方法是通过预处理...（下面的代码没有涵盖极端情况，但是编写该代码是为了快速演示可以做什么。）

#!/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+):(\d+)})/) {
        printf ("$1, $2, $3");        
        my $lnew = "{" . "$3, "x($2 - 1) . $3 . "}";
        $line =~ s/{(\d+:\d+)}/$lnew/;
        printf $ouf $line;
    } else {
        printf $ouf $line;
    }
}

close($ouf);
close($inf);