การเริ่มต้นขององค์ประกอบทั้งหมดของอาร์เรย์ให้เป็นค่าเริ่มต้นหนึ่งใน 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(จาก<algorithm>):

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

ใน C แบบพกพาคุณต้องหมุนวนรอบของคุณเอง มีส่วนขยายคอมไพเลอร์หรือคุณสามารถพึ่งพาพฤติกรรมที่กำหนดโดยการนำไปใช้เป็นทางลัดหากยอมรับได้

มีส่วนขยายสำหรับคอมไพเลอร์ gcc ซึ่งอนุญาตให้ใช้ไวยากรณ์:

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

สิ่งนี้จะตั้งค่าองค์ประกอบทั้งหมดเป็น -1

สิ่งนี้เรียกว่า "Initialized Initialated" ดูที่นี่สำหรับข้อมูลเพิ่มเติม

หมายเหตุสิ่งนี้ไม่ได้ถูกนำไปใช้กับคอมไพเลอร์ gcc c ++

หน้าที่คุณเชื่อมโยงไปถึงได้ให้คำตอบในส่วนแรกแล้ว:

หากระบุขนาดอาเรย์ที่ชัดเจน แต่มีการระบุรายการเริ่มต้นที่สั้นกว่าองค์ประกอบที่ไม่ระบุจะถูกตั้งค่าเป็นศูนย์

ไม่มีวิธีที่มีอยู่แล้วภายในเพื่อเริ่มต้นอาร์เรย์ทั้งหมดเป็นค่าที่ไม่เป็นศูนย์

กฎที่ใช้กันทั่วไปคือ: "วิธีการที่ให้คอมไพเลอร์มีอิสระมากที่สุดน่าจะเร็วกว่า"

int array[100] = {0};

เพียงแค่บอกคอมไพเลอร์ "ตั้ง 100 ints เป็นศูนย์" ซึ่งคอมไพเลอร์สามารถเพิ่มประสิทธิภาพได้อย่างอิสระ

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

หากไม่มีการ= {}ทำให้มีชีวิตชีวาเนื้อหาจะไม่ได้กำหนด

หน้าเว็บที่คุณเชื่อมโยงรัฐ

หากระบุขนาดอาเรย์ที่ชัดเจน แต่มีการระบุรายการเริ่มต้นที่สั้นกว่าองค์ประกอบที่ไม่ระบุจะถูกตั้งค่าเป็นศูนย์

ปัญหาความเร็ว: ความแตกต่างใด ๆ จะเล็กน้อยสำหรับอาร์เรย์ขนาดเล็กนี้ หากคุณทำงานกับอาร์เรย์ขนาดใหญ่และความเร็วมีความสำคัญมากกว่าขนาดคุณสามารถมีอาร์เรย์ของค่าเริ่มต้น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 โดยไม่จำเป็นต้องคัดลอกเราเพิ่งสร้างมันขึ้นมา

การโอเวอร์โหลดครั้งที่สองนั้นยุ่งยากเล็กน้อย มันจะส่งต่อไปตามค่าที่ได้เป็นแหล่งที่มาและมันยังสร้างอินสแตนซ์ของ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 ข้อโต้แย้งโดยการคัดลอกค่าที่เราส่งผ่านที่นี่เราใช้ดัชนีชุดตัวแปร variadic ของเราเป็นสิ่งที่จะขยาย มีขนาด - 1 รายการในแพ็คนั้น (ตามที่เราระบุในการสร้างmake_index_sequence) และมีค่า 0, 1, 2, 3, ... , ขนาด - 2 อย่างไรก็ตามเราไม่สนใจค่า ( ดังนั้นเราจึงโยนมันให้เป็นโมฆะเพื่อปิดเสียงคำเตือนของคอมไพเลอร์) การขยายแพ็คของพารามิเตอร์จะขยายโค้ดของเราออกมาเป็นแบบนี้ (สมมุติว่าขนาด == 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) };

เราใช้วงเล็บเหล่านั้นเพื่อให้แน่ใจว่าการขยายแพ็ค Variadic ...จะขยายสิ่งที่เราต้องการและเพื่อให้แน่ใจว่าเรากำลังใช้โอเปอเรเตอร์คอมม่า หากไม่มีวงเล็บมันจะดูเหมือนว่าเรากำลังผ่านการโต้แย้งไปยังการเริ่มต้นอาร์เรย์ของเรา แต่จริงๆแล้วเรากำลังประเมินดัชนีชี้ขาดมันเป็นโมฆะโดยไม่สนใจผลลัพธ์ที่เป็นโมฆะและส่งคืนค่าซึ่งถูกคัดลอกลงในอาร์เรย์ .

อาร์กิวเมนต์สุดท้ายคือสิ่งที่เราเรียกว่า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) เมื่อคุณใช้ initializer สำหรับ struct หรืออาเรย์เช่นนั้นค่าที่ไม่ระบุจะถูกสร้างเป็นค่าเริ่มต้น ในกรณีที่เป็นชนิดดั้งเดิมเช่น ints ซึ่งหมายความว่าพวกเขาจะเป็นศูนย์ โปรดทราบว่าสิ่งนี้ใช้ซ้ำ: คุณสามารถมีอาร์เรย์ของ structs ที่มีอาร์เรย์และถ้าคุณระบุเพียงแค่สนามแรกของโครงสร้างแรกจากนั้นส่วนที่เหลือทั้งหมดจะเริ่มต้นได้ด้วยศูนย์และตัวสร้างเริ่มต้น

2) คอมไพเลอร์อาจสร้างโค้ดเริ่มต้นที่อย่างน้อยก็ดีเท่าที่คุณสามารถทำได้ด้วยมือ ฉันมักจะชอบให้คอมไพเลอร์ทำการเริ่มต้นสำหรับฉันเมื่อเป็นไปได้

ใน C ++ มันเป็นไปได้ที่จะใช้การเขียนโปรแกรมเมตาและเทมเพลตตัวแปร โพสต์ต่อไปนี้แสดงวิธีการทำ: โปรแกรมสร้างอาร์เรย์แบบคงที่รวบรวมเวลาใน C ++

ในภาษาโปรแกรม C ++ V4, Stroustrup แนะนำให้ใช้เวกเตอร์หรือวาลเลย์ย์เหนืออาร์เรย์ในตัว ด้วย valarrary's เมื่อคุณสร้างพวกเขาคุณสามารถเริ่มพวกเขาเป็นค่าเฉพาะเช่น:

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

ในการเริ่มต้นสมาชิกอาเรย์ 7 ที่ยาวด้วย "7777777"

นี่เป็นวิธีการ C ++ ในการนำคำตอบไปใช้โดยใช้โครงสร้างข้อมูล C ++ แทนอาร์เรย์ "plain old 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 ไบต์? ฉันจะต้องเขียนสคริปต์เพื่อเขียนให้ฉันหรือใช้วิธีแฮ็กกับแอสเซมบลี / 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);