Wie initialisiert man alle Mitglieder eines Arrays auf denselben Wert?

Question

Ich habe ein großes Array in C (nicht C++ falls das einen Unterschied macht). Ich möchte alle Mitglieder mit demselben Wert initialisieren.

Ich könnte schwören, dass ich einmal eine einfache Möglichkeit kannte, dies zu tun. Ich könnte verwenden memset() in meinem Fall, aber gibt es nicht eine Möglichkeit, dies zu tun, die direkt in die C-Syntax eingebaut ist?

Answer 1

int i;
for (i = 0; i < ARRAY_SIZE; ++i)
{
  myArray[i] = VALUE;
}

Ich denke, das ist besser als

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5...

falls sich die Größe des Arrays ändert.

Answer 2

Sie können die ganze statische Initialisierer Sache wie oben beschrieben tun, aber es kann ein echter Knaller sein, wenn Ihr Array Größe ändert (wenn Ihr Array embiggens, wenn Sie nicht die entsprechenden zusätzlichen Initialisierer hinzufügen Sie Müll erhalten).

memset gibt Ihnen eine Laufzeit Hit für die Arbeit zu tun, aber kein Code Größe Hit richtig gemacht ist immun gegen Array Größe Änderungen. Ich würde diese Lösung in fast allen Fällen verwenden, wenn das Array größer als, sagen wir, ein paar Dutzend Elemente war.

Wenn es wirklich wichtig wäre, dass das Array statisch deklariert ist, würde ich ein Programm schreiben, das das Programm für mich schreibt, und es zum Bestandteil des Build-Prozesses machen.

Answer 3

Ich weiß, die ursprüngliche Frage ausdrücklich erwähnt C und nicht C++, aber wenn Sie (wie ich) kam hier auf der Suche nach einer Lösung für C++-Arrays, hier ist ein netter Trick:

Wenn Ihr Compiler Folgendes unterstützt Faltausdrücke können Sie Vorlagenmagie verwenden und std::index_sequence um eine Initialisierungsliste mit dem gewünschten Wert zu erstellen. Und Sie können sogar constexpr und sich wie ein Chef fühlen:

#include <array>

/// [3]
/// This functions's only purpose is to ignore the index given as the second
/// template argument and to always produce the value passed in.
template<class T, size_t /*ignored*/>
constexpr T identity_func(const T& value) {
    return value;
}

/// [2]
/// At this point, we have a list of indices that we can unfold
/// into an initializer list using the `identity_func` above.
template<class T, size_t... Indices>
constexpr std::array<T, sizeof...(Indices)>
make_array_of_impl(const T& value, std::index_sequence<Indices...>) {
    return {identity_func<T, Indices>(value)...};
}

/// [1]
/// This is the user-facing function.
/// The template arguments are swapped compared to the order used
/// for std::array, this way we can let the compiler infer the type
/// from the given value but still define it explicitly if we want to.
template<size_t Size, class T>
constexpr std::array<T, Size> 
make_array_of(const T& value) {
    using Indices = std::make_index_sequence<Size>;
    return make_array_of_impl(value, Indices{});
}

// std::array<int, 4>{42, 42, 42, 42}
constexpr auto test_array = make_array_of<4/*, int*/>(42);
static_assert(test_array[0] == 42);
static_assert(test_array[1] == 42);
static_assert(test_array[2] == 42);
static_assert(test_array[3] == 42);
// static_assert(test_array[4] == 42); out of bounds

Sie können einen Blick auf die Code bei der Arbeit (bei Wandbox)

Answer 4

Hier ist ein anderer Weg:

static void
unhandled_interrupt(struct trap_frame *frame, int irq, void *arg)
{
    //this code intentionally left blank
}

static struct irqtbl_s vector_tbl[XCHAL_NUM_INTERRUPTS] = {
    [0 ... XCHAL_NUM_INTERRUPTS-1] {unhandled_interrupt, NULL},
};

Siehe:

C-Erweiterungen

Ausgewiesene Einrichtungen

Dann stellen Sie die Frage: Wann kann man C-Erweiterungen verwenden?

Das obige Codebeispiel befindet sich in einem eingebetteten System und wird nie das Licht eines anderen Compilers erblicken.

Answer 5

Eine leicht augenzwinkernde Antwort; schreiben Sie die Aussage

array = initial_value

in Ihrer bevorzugten Array-fähigen Sprache (meine ist Fortran, aber es gibt viele andere), und verknüpfen Sie sie mit Ihrem C-Code. Wahrscheinlich wollen Sie es als externe Funktion einpacken.