Initialisierung aller Elemente eines Arrays auf einen Standardwert in C ++?

C ++ Hinweise: Die Array-Initialisierung hat eine schöne Liste über die Initialisierung von Arrays. Ich habe ein

int array[100] = {-1};

Erwarten Sie, dass es voll mit -1 ist, aber es ist nicht so, nur der erste Wert ist und der Rest sind 0 mit zufälligen Werten gemischt.

Der Code

int array[100] = {0};

funktioniert einwandfrei und setzt jedes Element auf 0.

Was fehlt mir hier? Kann man es nicht initialisieren, wenn der Wert nicht Null ist?

Und 2: Ist die Standardinitialisierung (wie oben) schneller als die übliche Schleife durch das gesamte Array und weist einen Wert zu oder macht sie dasselbe?

Verwenden Sie die von Ihnen verwendete Syntax.

int array[100] = {-1};

sagt "setze das erste Element auf -1und den Rest auf 0", da alle ausgelassenen Elemente auf gesetzt sind 0.

In C ++ können Sie zum Festlegen aller -1Optionen Folgendes verwenden : std::fill_n(from <algorithm>):

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

In tragbarem C müssen Sie Ihre eigene Schleife rollen. Es gibt Compiler-Erweiterungen oder Sie können sich auf das implementierungsdefinierte Verhalten als Verknüpfung verlassen, wenn dies akzeptabel ist.

Es gibt eine Erweiterung des gcc-Compilers, die die Syntax zulässt:

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

Dies würde alle Elemente auf -1 setzen.

Dies ist bekannt als „Designated Initializers“ sieht hier für weitere Informationen.

Beachten Sie, dass dies für den gcc c ++ - Compiler nicht implementiert ist.

Die Seite, auf die Sie verlinkt haben, gab bereits die Antwort auf den ersten Teil:

Wenn eine explizite Arraygröße angegeben wird, aber eine kürzere Initilierungsliste angegeben wird, werden die nicht angegebenen Elemente auf Null gesetzt.

Es gibt keine integrierte Möglichkeit, das gesamte Array auf einen Wert ungleich Null zu initialisieren.

Was schneller ist, gilt die übliche Regel: "Die Methode, die dem Compiler die größte Freiheit gibt, ist wahrscheinlich schneller."

int array[100] = {0};

sagt dem Compiler einfach "setze diese 100 Ints auf Null", was der Compiler frei optimieren kann.

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

ist viel spezifischer. Es weist den Compiler an, eine Iterationsvariable zu erstellen i, gibt die Reihenfolge an, in der die Elemente initialisiert werden sollen, und so weiter. Natürlich wird der Compiler dies wahrscheinlich optimieren, aber der Punkt ist, dass Sie hier das Problem überbestimmen und den Compiler dazu zwingen, härter zu arbeiten, um zum gleichen Ergebnis zu gelangen.

Wenn Sie das Array auf einen Wert ungleich Null setzen möchten, sollten Sie (zumindest in C ++) Folgendes verwenden std::fill:

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

Auch hier können Sie dasselbe mit einem Array tun, dies ist jedoch präziser und gibt dem Compiler mehr Freiheit. Sie sagen nur, dass Sie möchten, dass das gesamte Array mit dem Wert 42 gefüllt wird. Sie sagen nichts darüber, in welcher Reihenfolge es ausgeführt werden soll oder sonst etwas.

C ++ 11 hat eine andere (unvollständige) Option:

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

Mit {} weisen Sie die Elemente so zu, wie sie deklariert sind. Der Rest wird mit 0 initialisiert.

Wenn es keine = {}Initialisierung gibt, ist der Inhalt undefiniert.

Die Seite, die Sie verlinkt haben, gibt an

Wenn eine explizite Arraygröße angegeben wird, aber eine kürzere Initilierungsliste angegeben wird, werden die nicht angegebenen Elemente auf Null gesetzt.

Geschwindigkeitsproblem: Bei so kleinen Arrays wären Unterschiede vernachlässigbar. Wenn Sie mit großen Arrays arbeiten und die Geschwindigkeit viel wichtiger als die Größe ist, können Sie ein const-Array mit den Standardwerten (zur Kompilierungszeit initialisiert) und diese dann memcpyin das modifizierbare Array einfügen.

Eine andere Möglichkeit, das Array auf einen gemeinsamen Wert zu initialisieren, besteht darin, die Liste der Elemente in einer Reihe von Definitionen zu generieren:

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

Das Initialisieren eines Arrays auf einen gemeinsamen Wert ist einfach:

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

Hinweis: DUPx wurde eingeführt, um die Makrosubstitution in Parametern für DUP zu ermöglichen

Für den Fall eines Arrays von Einzelbyte-Elementen können Sie memset verwenden, um alle Elemente auf denselben Wert zu setzen.

Es ist ein Beispiel hier .

Mit std::arraykönnen wir dies in C ++ 14 auf ziemlich einfache Weise tun. Dies ist nur in C ++ 11 möglich, jedoch etwas komplizierter.

Unsere Schnittstelle hat eine Größe zur Kompilierungszeit und einen Standardwert.

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

Die dritte Funktion dient hauptsächlich der Bequemlichkeit, so dass der Benutzer kein std::integral_constant<std::size_t, size>Selbst konstruieren muss, da dies eine ziemlich wortreiche Konstruktion ist. Die eigentliche Arbeit erledigt eine der ersten beiden Funktionen.

Die erste Überladung ist ziemlich einfach: Sie erstellt eine std::arrayGröße 0. Es ist kein Kopieren erforderlich, wir erstellen sie einfach.

Die zweite Überlastung ist etwas kniffliger. Es leitet den Wert weiter, den es als Quelle erhalten hat, und erstellt auch eine Instanz vonmake_index_sequence und ruft nur eine andere Implementierungsfunktion auf. Wie sieht diese Funktion aus?

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

Dadurch werden die ersten Argumente der Größe 1 erstellt, indem der übergebene Wert kopiert wird. Hier verwenden wir unsere variablen Parameterpaketindizes nur als Erweiterung. Es gibt Einträge der Größe 1 in diesem Paket (wie wir in der Konstruktion von angegeben habenmake_index_sequence ) und sie haben Werte von 0, 1, 2, 3, ..., Größe - 2. Die Werte sind uns jedoch egal ( Also haben wir es für ungültig erklärt, um alle Compiler-Warnungen zum Schweigen zu bringen. Die Erweiterung des Parameterpakets erweitert unseren Code auf etwa Folgendes (vorausgesetzt, Größe == 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) };

Wir verwenden diese Klammern, um sicherzustellen, dass die Erweiterung des Variadic Packs das ...erweitert, was wir wollen, und um sicherzustellen, dass wir den Komma-Operator verwenden. Ohne die Klammern würde es so aussehen, als würden wir eine Reihe von Argumenten an unsere Array-Initialisierung übergeben, aber tatsächlich bewerten wir den Index, wandeln ihn in void um, ignorieren dieses void-Ergebnis und geben dann den Wert zurück, der in das Array kopiert wird .

Das letzte Argument, auf das wir zurückgreifen std::forward, ist eine geringfügige Optimierung. Wenn jemand einen temporären std :: string übergibt und sagt "mache ein Array von 5 davon", möchten wir 4 Kopien und 1 Zug anstelle von 5 Kopien haben. Dasstd::forward stellt sicher, dass wir dies tun.

Der vollständige Code, einschließlich Header und einiger Komponententests:

#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) Wenn Sie einen Initialisierer für eine Struktur oder ein Array wie dieses verwenden, werden die nicht angegebenen Werte im Wesentlichen standardmäßig erstellt. Bei einem primitiven Typ wie Ints bedeutet dies, dass sie auf Null gesetzt werden. Beachten Sie, dass dies rekursiv gilt: Sie können ein Array von Strukturen haben, die Arrays enthalten. Wenn Sie nur das erste Feld der ersten Struktur angeben, wird der Rest mit Nullen und Standardkonstruktoren initialisiert.

2) Der Compiler generiert wahrscheinlich Initialisierungscode, der mindestens so gut ist, wie Sie es von Hand tun könnten. Ich ziehe es vor, den Compiler nach Möglichkeit die Initialisierung für mich durchführen zu lassen.

In C ++ ist es auch möglich, Metaprogrammierung und verschiedene Vorlagen zu verwenden. Der folgende Beitrag zeigt, wie es geht: Erstellen Sie programmgesteuert statische Arrays zur Kompilierungszeit in C ++ .

In der C ++ - Programmiersprache V4 empfiehlt Stroustrup die Verwendung von Vektoren oder Valarrays gegenüber integrierten Arrays. Wenn Sie Valarrarys erstellen, können Sie sie beim Erstellen auf einen bestimmten Wert wie folgt einleiten:

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

So initialisieren Sie ein 7 Mitglieder langes Array mit "7777777".

Dies ist eine C ++ - Methode zum Implementieren der Antwort mithilfe einer C ++ - Datenstruktur anstelle eines "einfachen alten C" -Arrays.

Ich habe den Valarray als Versuch in meinem Code verwendet, C ++ 'isms v. C'isms zu verwenden ....

Sollte eine Standardfunktion sein, ist aber aus irgendeinem Grund weder in Standard C noch in C ++ enthalten ...

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

In Fortran können Sie Folgendes tun:

program main
    implicit none

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

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

aber es hat keine vorzeichenlosen Nummern ...

Warum kann C / C ++ es nicht einfach implementieren? Ist es wirklich so schwer? Es ist so dumm, dies manuell schreiben zu müssen, um das gleiche Ergebnis zu erzielen ...

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

Was wäre, wenn es ein Array von 1.000,00 Bytes wäre? Ich müsste ein Skript schreiben, um es für mich zu schreiben, oder auf Hacks mit Assembly / etc. Zurückgreifen. Das ist schwachsinn.

Es ist perfekt portabel, es gibt keinen Grund dafür, nicht in der Sprache zu sein.

Hacken Sie es einfach wie folgt:

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

Eine Möglichkeit, es zu hacken, ist die Vorverarbeitung ... (Der folgende Code deckt keine Randfälle ab, sondern wurde geschrieben, um schnell zu demonstrieren, was getan werden kann.)

#!/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);