Cara idiomatik untuk membedakan dua konstruktor zero-arg

Saya memiliki kelas seperti ini:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Biasanya saya ingin default (nol) menginisialisasi countsarray seperti yang ditunjukkan.

Di lokasi tertentu yang diidentifikasi oleh profil, bagaimanapun, saya ingin menekan inisialisasi array, karena saya tahu array akan ditimpa, tetapi kompiler tidak cukup pintar untuk mengetahuinya.

Apa cara idiomatis dan efisien untuk membuat konstruktor zero-arg "sekunder" seperti itu?

Saat ini, saya menggunakan kelas tag uninit_tagyang dilewatkan sebagai argumen dummy, seperti:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Lalu saya memanggil konstruktor no-init seperti event_counts c(uninit_tag{});ketika saya ingin menekan konstruksi.

Saya terbuka untuk solusi yang tidak melibatkan pembuatan kelas dummy, atau lebih efisien dalam beberapa cara, dll.

Solusi yang sudah Anda miliki sudah benar, dan saya ingin melihat apakah saya sedang meninjau kode Anda. Ini seefisien mungkin, jelas dan ringkas.

Jika badan konstruktor kosong, itu dapat dihilangkan atau default:

struct event_counts {
    std::uint64_t counts[MAX_COUNTERS];
    event_counts() = default;
};

Kemudian inisialisasi default event_counts counts; akan meninggalkan inisialisasicounts.counts (inisialisasi default adalah no-op di sini), dan inisialisasi event_counts counts{}; nilai akan nilai inisialisasi counts.counts, secara efektif mengisinya dengan nol.

Saya suka solusi Anda. Anda mungkin juga mempertimbangkan bersarang struct dan variabel statis. Sebagai contoh:

struct event_counts {
    static constexpr struct uninit_tag {} uninit = uninit_tag();

    uint64_t counts[MAX_COUNTS];

    event_counts() : counts{} {}

    explicit event_counts(uninit_tag) {}

    // more stuff

};

Dengan variabel panggilan konstruktor tak diinisialisasi variabel statis mungkin tampak lebih nyaman:

event_counts e(event_counts::uninit);

Tentu saja Anda dapat memperkenalkan makro untuk menyimpan pengetikan dan menjadikannya lebih sebagai fitur yang sistematis

#define UNINIT_TAG static constexpr struct uninit_tag {} uninit = uninit_tag();

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Saya pikir enum adalah pilihan yang lebih baik daripada kelas tag atau bool. Anda tidak perlu melewati instance dari struct dan jelas dari pemanggil opsi mana yang Anda dapatkan.

struct event_counts {
    enum Init { INIT, NO_INIT };
    uint64_t counts[MAX_COUNTERS];

    event_counts(Init init = INIT) {
        if (init == INIT) {
            std::fill(counts, counts + MAX_COUNTERS, 0);
        }
    }
};

Kemudian membuat instance terlihat seperti ini:

event_counts e1{};
event_counts e2{event_counts::INIT};
event_counts e3{event_counts::NO_INIT};

Atau, untuk membuatnya lebih seperti pendekatan kelas tag, gunakan enum nilai tunggal alih-alih kelas tag:

struct event_counts {
    enum NoInit { NO_INIT };
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}
    explicit event_counts(NoInit) {}
};

Lalu hanya ada dua cara untuk membuat instance:

event_counts e1{};
event_counts e2{event_counts::NO_INIT};

Anda mungkin ingin mempertimbangkan inisialisasi dua fase untuk kelas Anda:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

    void set_zero() {
       std::fill(std::begin(counts), std::end(counts), 0u);
    }
};

Konstruktor di atas tidak menginisialisasi array ke nol. Untuk mengatur elemen array ke nol, Anda harus memanggil fungsi anggota set_zero()setelah konstruksi.

Saya akan melakukannya seperti ini:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(bool initCounts) {
        if (initCounts) {
            std::fill(counts, counts + MAX_COUNTERS, 0);
        }
    }
};

Kompiler akan cukup pintar untuk melewati semua kode saat Anda gunakan event_counts(false), dan Anda bisa mengatakan dengan tepat apa yang Anda maksud alih-alih membuat antarmuka kelas Anda jadi aneh.

Saya akan menggunakan subkelas hanya untuk menyimpan sedikit pengetikan:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}
    event_counts(uninit_tag) {}
};    

struct event_counts_no_init: event_counts {
    event_counts_no_init(): event_counts(uninit_tag{}) {}
};

Anda dapat menyingkirkan kelas dummy dengan mengubah argumen konstruktor yang tidak menginisialisasi boolatau intatau sesuatu, karena tidak harus mnemonik lagi.

Anda juga bisa menukar pewarisan sekitar dan mendefinisikan events_count_no_initdengan konstruktor default seperti yang disarankan Evg dalam jawaban mereka, dan kemudian events_countmenjadi subclass:

struct event_counts_no_init {
    uint64_t counts[MAX_COUNTERS];
    event_counts_no_init() = default;
};

struct event_counts: event_counts_no_init {
    event_counts(): event_counts_no_init{} {}
};