Ідіоматичний спосіб відрізнити два конструктори з нульовим аргументом

У мене такий клас:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Зазвичай я хочу, щоб за замовчуванням (нуль) ініціалізувати countsмасив, як показано.

Однак у вибраних місцях, визначених шляхом профілювання, я хотів би придушити ініціалізацію масиву, оскільки я знаю, що масив збирається перезаписати, але компілятор недостатньо розумний, щоб це зрозуміти.

Який ідіоматичний та ефективний спосіб створити такий "вторинний" конструктор з нульовим аргументом?

В даний час я використовую клас тегів, uninit_tagякий передається як фіктивний аргумент, наприклад:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Тоді я називаю конструктор no-init, як event_counts c(uninit_tag{});коли я хочу придушити будівництво.

Я відкритий до рішень, які не передбачають створення фіктивного класу, або якісь ефективніші, тощо.

Рішення, яке ви вже маєте, є правильним, і саме те, що я хотів би побачити, переглядаючи ваш код. Він максимально ефективний, чіткий і стислий.

Якщо корпус конструктора порожній, його можна опустити або дефолтувати:

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

Тоді ініціалізація за замовчуванням event_counts counts; залишиться counts.countsнеініціалізованою (ініціалізація за замовчуванням тут не працює), а ініціалізація event_counts counts{}; значень буде ініціалізувати значення counts.counts, ефективно заповнюючи її нулями.

Мені подобається ваше рішення. Можливо, ви також розглядали вкладені структурну та статичну змінну. Наприклад:

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

};

За допомогою статичної змінної неініціалізований виклик конструктора може здатися більш зручним:

event_counts e(event_counts::uninit);

Звичайно, ви можете ввести макрос для збереження набору тексту та зробити його більш систематичним

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

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Я думаю, що перелік є кращим вибором, ніж клас тегів чи бул. Вам не потрібно передавати екземпляр структури, і від абонента зрозуміло, який варіант ви отримуєте.

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

Тоді створення екземплярів виглядає приблизно так:

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

Або, щоб він більше нагадував підхід до класу тегів, замість класу тегів використовуйте enum значення:

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

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

Тоді є лише два способи створення екземпляра:

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

Ви можете розглянути питання про двофазну ініціалізацію для свого класу:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

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

Конструктор вище не ініціалізує масив до нуля. Щоб встановити елементи масиву на нуль, set_zero()після побудови потрібно викликати функцію члена .

Я б це зробив так:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

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

Компілятор буде досить розумним, щоб пропустити весь код при використанні event_counts(false), і ви зможете точно сказати, що ви маєте на увазі, замість того, щоб зробити інтерфейс вашого класу таким дивним.

Я б використовував підклас лише для того, щоб трохи заощадити:

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

Ви можете позбутися класу манекенів, змінивши аргумент неініціалізуючого конструктора на boolабоint або що - то, так як він не повинен бути мнемонічними більше.

Ви також можете поміняти спадщину навколо та визначити events_count_no_initконструктор за замовчуванням, як Evg, запропонований у своїй відповіді, а потім events_countбуде підкласом:

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