Manera idiomática de distinguir dos constructores de cero arg

Tengo una clase como esta:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Por lo general, quiero predeterminar (cero) inicializar la countsmatriz como se muestra.

Sin embargo, en las ubicaciones seleccionadas identificadas por la creación de perfiles, me gustaría suprimir la inicialización de la matriz, porque sé que la matriz está a punto de sobrescribirse, pero el compilador no es lo suficientemente inteligente como para descubrirlo.

¿Cuál es una forma idiomática y eficiente de crear un constructor de "cero argumentos" secundario?

Actualmente, estoy usando una clase de etiqueta uninit_tagque se pasa como un argumento ficticio, así:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Luego llamo al constructor no-init como event_counts c(uninit_tag{});cuando quiero suprimir la construcción.

Estoy abierto a soluciones que no implican la creación de una clase ficticia, o que son más eficientes de alguna manera, etc.

La solución que ya tiene es correcta, y es exactamente lo que me gustaría ver si estuviera revisando su código. Es lo más eficiente posible, claro y conciso.

Si el cuerpo del constructor está vacío, se puede omitir o omitir:

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

Luego, la inicialización predeterminada event_counts counts; dejará sin counts.countsinicializar (la inicialización predeterminada no es operativa aquí), y la inicialización de event_counts counts{}; valor valorará la inicialización counts.counts, llenándola efectivamente con ceros.

Me gusta tu solución También podría haber considerado la estructura anidada y la variable estática. Por ejemplo:

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

};

Con la variable estática, la llamada del constructor no inicializado puede parecer más conveniente:

event_counts e(event_counts::uninit);

Por supuesto, puede introducir una macro para guardar la escritura y convertirla en una característica más sistemática

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

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Creo que una enumeración es una mejor opción que una clase de etiqueta o un bool. No necesita pasar una instancia de una estructura y la persona que llama sabe claramente qué opción está obteniendo.

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

Luego, crear instancias se ve así:

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

O, para que se parezca más al enfoque de la clase de etiqueta, use una enumeración de un solo valor en lugar de la clase de etiqueta:

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

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

Entonces solo hay dos formas de crear una instancia:

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

Es posible que desee considerar una inicialización de dos fases para su clase:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

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

El constructor anterior no inicializa la matriz a cero. Para establecer los elementos de la matriz en cero, debe llamar a la función miembro set_zero()después de la construcción.

Lo haría así:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

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

El compilador será lo suficientemente inteligente como para omitir todo el código cuando lo use event_counts(false), y podrá decir exactamente lo que quiere decir en lugar de hacer que la interfaz de su clase sea tan extraña.

Usaría una subclase solo para ahorrar un poco de escritura:

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

Usted puede deshacerse de la clase simulado por el cambio del argumento del constructor no inicializar a boolo into algo así, ya que no tiene por qué ser mnemotécnica más.

También podría intercambiar la herencia y definirla events_count_no_initcon un constructor predeterminado como sugirió Evg en su respuesta, y luego events_countser la subclase:

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