Modo idiomatico per distinguere due costruttori zero-arg

Ho una lezione come questa:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Di solito, per impostazione predefinita, voglio inizializzare (zero) l' countsarray come mostrato.

In posizioni selezionate identificate dalla profilazione, tuttavia, vorrei sopprimere l'inizializzazione dell'array, perché so che l'array sta per essere sovrascritto, ma il compilatore non è abbastanza intelligente da capirlo.

Qual è un modo idiomatico ed efficiente per creare un costruttore "secondario" a zero-arg?

Attualmente sto usando una classe di tag uninit_tagche viene passata come argomento fittizio, in questo modo:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Quindi chiamo il costruttore no-init come event_counts c(uninit_tag{});quando voglio sopprimere la costruzione.

Sono aperto a soluzioni che non comportano la creazione di una classe fittizia o che sono più efficienti in qualche modo, ecc.

La soluzione che hai già è corretta, ed è esattamente quello che vorrei vedere se stavo rivedendo il tuo codice. È il più efficiente possibile, chiaro e conciso.

Se il corpo del costruttore è vuoto, può essere omesso o predefinito:

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

Quindi l' inizializzazione predefinita event_counts counts; rimarrà counts.countsnon inizializzata (l'inizializzazione predefinita è una no-op qui) e l' inizializzazione del event_counts counts{}; valore valuterà l'inizializzazione counts.counts, riempiendola efficacemente di zeri.

Mi piace la tua soluzione. Potresti anche aver considerato la struttura nidificata e la variabile statica. Per esempio:

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 variabile statica la chiamata del costruttore non inizializzata può sembrare più conveniente:

event_counts e(event_counts::uninit);

Ovviamente puoi introdurre una macro per salvare la digitazione e renderla più una caratteristica sistematica

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

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Penso che un enum sia una scelta migliore di una tag class o di un bool. Non è necessario passare un'istanza di una struttura ed è chiaro al chiamante quale opzione si sta ottenendo.

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

Quindi la creazione di istanze è simile alla seguente:

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

Oppure, per renderlo più simile all'approccio della classe tag, utilizzare un enum a valore singolo anziché la classe tag:

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

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

Quindi ci sono solo due modi per creare un'istanza:

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

Puoi prendere in considerazione un'inizializzazione in due fasi per la tua classe:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

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

Il costruttore sopra non inizializza l'array a zero. Per azzerare gli elementi dell'array, è necessario chiamare la funzione membro set_zero()dopo la costruzione.

Lo farei così:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

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

Il compilatore sarà abbastanza intelligente da saltare tutto il codice quando lo usi event_counts(false)e puoi dire esattamente cosa intendi invece di rendere l'interfaccia della tua classe così strana.

Userei una sottoclasse solo per risparmiare un po 'di battitura:

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

Si può sbarazzarsi della classe fittizia dal cambiando l'argomento del costruttore, non l'inizializzazione di boolo into qualcosa, in quanto non deve essere più mnemonico.

Puoi anche scambiare l'eredità e definirla events_count_no_initcon un costruttore predefinito come Evg ha suggerito nella loro risposta, e quindi avere events_countla sottoclasse:

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