Идиоматический способ различения двух нулевых конструкторов

У меня есть такой класс:

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

};

Затем я вызываю конструктор без инициализации, например, 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
}

Я думаю, что enum - лучший выбор, чем класс tag или bool. Вам не нужно передавать экземпляр структуры, и из вызывающей стороны ясно, какой вариант вы получаете.

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

Или, чтобы сделать его более похожим на подход класса тегов, используйте перечисление с одним значением вместо класса тега:

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