Maneira linguística de distinguir dois construtores de zero-arg

Eu tenho uma classe como esta:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Normalmente, eu quero padrão (zero) inicializar a countsmatriz como mostrado.

Em locais selecionados identificados por criação de perfil, no entanto, eu gostaria de suprimir a inicialização do array, porque sei que o array está prestes a ser substituído, mas o compilador não é inteligente o suficiente para descobrir isso.

O que é uma maneira idiomática e eficiente de criar um construtor zero-arg "secundário"?

Atualmente, estou usando uma classe de tag uninit_tagque é passada como argumento fictício, assim:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Então chamo o construtor no-init como event_counts c(uninit_tag{});quando quero suprimir a construção.

Estou aberto a soluções que não envolvam a criação de uma classe fictícia ou que são mais eficientes de alguma forma etc.

A solução que você já tem está correta e é exatamente o que eu gostaria de ver se estivesse revendo seu código. É o mais eficiente possível, claro e conciso.

Se o corpo do construtor estiver vazio, ele poderá ser omitido ou padronizado:

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

A inicialização padrão event_counts counts; deixará counts.countsnão inicializada (a inicialização padrão não é operacional aqui) e a inicialização do event_counts counts{}; valor valorizará a inicialização counts.counts, preenchendo-a efetivamente com zeros.

Eu gosto da sua solução. Você também pode ter considerado struct e variável estática aninhada. Por exemplo:

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

};

Com a variável estática, a chamada do construtor não inicializado pode parecer mais conveniente:

event_counts e(event_counts::uninit);

Obviamente, você pode introduzir uma macro para salvar a digitação e torná-la mais um recurso sistemático

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

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Eu acho que um enum é uma escolha melhor do que uma classe de tag ou um bool. Você não precisa passar uma instância de uma estrutura e fica claro pelo chamador qual opção você está recebendo.

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

Em seguida, a criação de instâncias fica assim:

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

Ou, para torná-lo mais parecido com a abordagem de classe de tag, use uma enumeração de valor único em vez da classe de tag:

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

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

Depois, existem apenas duas maneiras de criar uma instância:

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

Você pode considerar uma inicialização em duas fases para sua classe:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

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

O construtor acima não inicializa a matriz para zero. Para definir os elementos da matriz como zero, é necessário chamar a função de membro set_zero()após a construção.

Eu faria assim:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

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

O compilador será inteligente o suficiente para pular todo o código quando você usar event_counts(false), e você poderá dizer exatamente o que quer dizer, em vez de tornar a interface da sua classe tão estranha.

Eu usaria uma subclasse apenas para economizar um pouco de digitação:

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

Você pode se livrar da classe fictícia alterando o argumento do construtor não inicializado para boolou intou algo assim, pois ele não precisa mais ser mnemônico.

Você também pode trocar a herança e definir events_count_no_initcom um construtor padrão, como o Evg sugerido na resposta, e depois ter events_counta subclasse:

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