Inisialisasi semua elemen array ke satu nilai default di C ++?

C ++ Catatan: Array Inisialisasi memiliki daftar yang bagus atas inisialisasi array. Saya punya

int array[100] = {-1};

mengharapkannya menjadi penuh dengan -1 tetapi tidak, hanya nilai pertama dan sisanya adalah 0 dicampur dengan nilai acak.

Kode

int array[100] = {0};

berfungsi dengan baik dan menetapkan setiap elemen ke 0.

Apa yang saya lewatkan di sini .. Tidak bisakah seseorang menginisialisasi jika nilainya tidak nol?

Dan 2: Apakah inisialisasi default (seperti di atas) lebih cepat daripada loop biasa melalui seluruh array dan menetapkan nilai atau apakah itu melakukan hal yang sama?

Menggunakan sintaks yang Anda gunakan,

int array[100] = {-1};

mengatakan "atur elemen pertama ke -1dan sisanya ke 0" karena semua elemen yang dihilangkan diatur ke 0.

Di C ++, untuk mengatur semuanya -1, Anda dapat menggunakan sesuatu seperti std::fill_n(dari <algorithm>):

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

Di C portabel, Anda harus memutar loop Anda sendiri. Ada ekstensi kompiler atau Anda dapat bergantung pada perilaku yang ditentukan implementasi sebagai pintasan jika itu dapat diterima.

Ada ekstensi ke kompiler gcc yang memungkinkan sintaks:

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

Ini akan mengatur semua elemen ke -1.

Ini dikenal sebagai "Inisialisasi yang Ditunjuk" lihat di sini untuk informasi lebih lanjut.

Catatan ini tidak diterapkan untuk kompiler gcc c ++.

Halaman yang Anda tautkan sudah memberi jawaban ke bagian pertama:

Jika ukuran array eksplisit ditentukan, tetapi daftar initiliaisasi yang lebih pendek ditentukan, elemen yang tidak ditentukan diatur ke nol.

Tidak ada cara bawaan untuk menginisialisasi seluruh array ke beberapa nilai non-nol.

Adapun yang lebih cepat, aturan yang biasa berlaku: "Metode yang memberikan kebebasan paling kompiler mungkin lebih cepat".

int array[100] = {0};

hanya memberitahu kompiler "atur 100 ints ini ke nol", yang dapat dioptimalkan kompiler secara bebas.

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

jauh lebih spesifik. Ini memberitahu kompiler untuk membuat variabel iterasi i, memberi tahu urutan di mana elemen harus diinisialisasi, dan sebagainya. Tentu saja, kompiler cenderung untuk mengoptimalkan itu, tetapi intinya adalah di sini Anda terlalu menentukan masalah, memaksa kompiler bekerja lebih keras untuk mendapatkan hasil yang sama.

Akhirnya, jika Anda ingin mengatur array ke nilai bukan nol, Anda harus (dalam C ++, setidaknya) menggunakan std::fill:

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

Sekali lagi, Anda bisa melakukan hal yang sama dengan array, tetapi ini lebih ringkas, dan memberi kompilator lebih banyak kebebasan. Anda hanya mengatakan bahwa Anda ingin seluruh array diisi dengan nilai 42. Anda tidak mengatakan apa-apa tentang urutan yang harus dilakukan, atau apa pun.

C ++ 11 memiliki opsi lain (tidak sempurna):

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

Dengan {} Anda menetapkan elemen sebagaimana dinyatakan; sisanya diinisialisasi dengan 0.

Jika tidak ada = {}untuk memulai, konten tidak terdefinisi.

Halaman yang Anda tautkan menyatakan

Jika ukuran array eksplisit ditentukan, tetapi daftar initiliaisasi yang lebih pendek ditentukan, elemen yang tidak ditentukan diatur ke nol.

Masalah kecepatan: Perbedaan apa pun akan diabaikan untuk array sekecil ini. Jika Anda bekerja dengan array besar dan kecepatan jauh lebih penting daripada ukuran, Anda dapat memiliki array const dari nilai default (diinisialisasi pada waktu kompilasi) dan kemudian memcpyke array yang dapat dimodifikasi.

Cara lain menginisialisasi array ke nilai umum, adalah dengan benar-benar menghasilkan daftar elemen dalam serangkaian definisi:

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

Menginisialisasi array ke nilai umum dapat dengan mudah dilakukan:

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

Catatan: DUPx diperkenalkan untuk mengaktifkan substitusi makro dalam parameter ke DUP

Untuk kasus array elemen bita tunggal, Anda dapat menggunakan memset untuk mengatur semua elemen ke nilai yang sama.

Ada contoh di sini .

Dengan menggunakan std::array, kita bisa melakukan ini dengan cara yang cukup mudah di C ++ 14. Dimungkinkan untuk melakukannya hanya di C ++ 11, tetapi sedikit lebih rumit.

Antarmuka kami adalah ukuran waktu kompilasi dan nilai default.

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

Fungsi ketiga terutama untuk kenyamanan, sehingga pengguna tidak harus membangun std::integral_constant<std::size_t, size>sendiri, karena itu adalah konstruksi yang cukup bertele-tele. Pekerjaan nyata dilakukan oleh salah satu dari dua fungsi pertama.

Kelebihan pertama cukup mudah: Ini membangun std::arrayukuran 0. Tidak perlu menyalin, kami hanya membangunnya.

Kelebihan kedua agak rumit. Ini meneruskan sepanjang nilai yang didapatnya sebagai sumber, dan juga membangun sebuah instance make_index_sequencedan hanya memanggil beberapa fungsi implementasi lainnya. Seperti apa fungsi itu?

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

Ini mengkonstruksi argumen ukuran - 1 pertama dengan menyalin nilai yang kami berikan. Di sini, kami menggunakan indeks paket parameter variad kami hanya sebagai sesuatu untuk diperluas. Ada entri ukuran - 1 dalam paket itu (seperti yang kami tentukan dalam konstruksi make_index_sequence), dan mereka memiliki nilai 0, 1, 2, 3, ..., ukuran - 2. Namun, kami tidak peduli dengan nilai-nilai tersebut ( jadi kami membatalkannya, untuk membungkam setiap peringatan kompiler). Ekspansi paket parameter memperluas kode kami ke sesuatu seperti ini (dengan asumsi ukuran == 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) };

Kami menggunakan tanda kurung itu untuk memastikan bahwa ekspansi paket variadic ...memperluas apa yang kami inginkan, dan juga untuk memastikan kami menggunakan operator koma. Tanpa tanda kurung, akan terlihat seperti kami melewati banyak argumen untuk inisialisasi array kami, tapi sungguh, kami mengevaluasi indeks, membuangnya untuk membatalkan, mengabaikan hasil yang batal, dan kemudian mengembalikan nilai, yang kemudian disalin ke dalam array .

Argumen terakhir, yang kami panggil std::forward, adalah optimasi kecil. Jika seseorang lewat di std :: string sementara dan mengatakan "buat 5 array ini", kami ingin memiliki 4 salinan dan 1 langkah, bukannya 5 salinan. The std::forwardmemastikan bahwa kami melakukan ini.

Kode lengkap, termasuk tajuk dan beberapa tes unit:

#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) Ketika Anda menggunakan penginisialisasi, untuk struct atau array seperti itu, nilai yang tidak ditentukan pada dasarnya dibangun secara default. Dalam kasus tipe primitif seperti int, itu berarti mereka akan memusatkan perhatian. Perhatikan bahwa ini berlaku secara rekursif: Anda bisa memiliki array struct yang berisi array dan jika Anda menentukan hanya bidang pertama dari struct pertama, maka semua sisanya akan diinisialisasi dengan nol dan konstruktor default.

2) Compiler mungkin akan menghasilkan kode initializer yang setidaknya sebagus yang Anda bisa lakukan dengan tangan Saya cenderung lebih suka membiarkan kompiler melakukan inisialisasi untuk saya, bila memungkinkan.

Di C ++, juga dimungkinkan untuk menggunakan pemrograman meta dan templat variadic. Posting berikut menunjukkan cara melakukannya: Secara terprogram membuat array statis pada waktu kompilasi dalam C ++ .

Dalam bahasa pemrograman C ++ V4, Stroustrup merekomendasikan penggunaan vektor atau valarrays pada array bawaan. Dengan valarrary's, saat Anda membuatnya, Anda dapat memasukkannya ke nilai tertentu seperti:

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

Untuk menginisialisasi susunan 7 anggota dengan "7777777".

Ini adalah cara C ++ untuk mengimplementasikan jawaban menggunakan struktur data C ++ alih-alih susunan "biasa C lama".

Saya beralih menggunakan valarray sebagai upaya dalam kode saya untuk mencoba menggunakan C ++ 'isms v. C'isms ....

Seharusnya fitur standar tetapi karena alasan tertentu itu tidak termasuk dalam standar C atau 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]);
    }
}

Di Fortran Anda bisa melakukan:

program main
    implicit none

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

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

tetapi tidak memiliki nomor yang tidak ditandatangani ...

Mengapa C / C ++ tidak bisa hanya mengimplementasikannya. Apakah ini sangat sulit? Sangat konyol harus menulis ini secara manual untuk mencapai hasil yang sama ...

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

Bagaimana jika itu adalah array 1.000,00 byte? Saya perlu menulis skrip untuk menulisnya untuk saya, atau menggunakan hacks dengan assembly / etc. Ini tidak masuk akal.

Ini sangat portabel, tidak ada alasan untuk itu tidak ada dalam bahasa.

Cukup retas seperti:

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

Salah satu cara untuk meretasnya adalah melalui preprocessing ... (Kode di bawah ini tidak mencakup kasus tepi, tetapi ditulis untuk dengan cepat menunjukkan apa yang bisa dilakukan.)

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