Idiomatische Methode zur Unterscheidung von zwei Null-Arg-Konstruktoren

Ich habe eine Klasse wie diese:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Normalerweise möchte ich das countsArray standardmäßig (Null) wie gezeigt initialisieren .

An ausgewählten Stellen, die durch Profilerstellung identifiziert wurden, möchte ich jedoch die Array-Initialisierung unterdrücken, da ich weiß, dass das Array bald überschrieben wird, der Compiler jedoch nicht intelligent genug ist, um dies herauszufinden.

Was ist eine idiomatische und effiziente Methode, um einen solchen "sekundären" Null-Arg-Konstruktor zu erstellen?

Derzeit verwende ich eine Tag-Klasse, uninit_tagdie wie folgt als Dummy-Argument übergeben wird:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Dann rufe ich den No-Init-Konstruktor auf, wie event_counts c(uninit_tag{});wenn ich die Konstruktion unterdrücken möchte.

Ich bin offen für Lösungen, bei denen keine Dummy-Klasse erstellt wird oder die in irgendeiner Weise effizienter sind usw.

Die Lösung, die Sie bereits haben, ist korrekt und genau das, was ich sehen möchte, wenn ich Ihren Code überprüfe. Es ist so effizient wie möglich, klar und prägnant.

Wenn der Konstruktorkörper leer ist, kann er weggelassen oder voreingestellt werden:

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

Dann Standardinitialisierung event_counts counts; wird verlassen counts.countsnicht initialisierte (Standard Initialisierung ist ein No-op hier) und Wert Initialisierung event_counts counts{}; initialize Wert wird counts.counts, effektiv mit Nullen gefüllt wird .

Ich mag deine Lösung. Möglicherweise haben Sie auch verschachtelte Strukturen und statische Variablen berücksichtigt. Zum Beispiel:

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

};

Mit statischen Variablen scheint ein nicht initialisierter Konstruktoraufruf bequemer zu sein:

event_counts e(event_counts::uninit);

Sie können natürlich ein Makro einführen, um die Eingabe zu speichern und es systematischer zu gestalten

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

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Ich denke, eine Aufzählung ist eine bessere Wahl als eine Tag-Klasse oder ein Bool. Sie müssen keine Instanz einer Struktur übergeben, und dem Aufrufer ist klar, welche Option Sie erhalten.

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

Das Erstellen von Instanzen sieht dann folgendermaßen aus:

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

Oder verwenden Sie anstelle der Tag-Klasse eine einwertige Aufzählung, um den Tag-Klassen-Ansatz zu verbessern:

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

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

Dann gibt es nur zwei Möglichkeiten, eine Instanz zu erstellen:

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

Möglicherweise möchten Sie eine zweiphasige Initialisierung für Ihre Klasse in Betracht ziehen :

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

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

Der obige Konstruktor initialisiert das Array nicht auf Null. Um die Elemente des Arrays auf Null zu setzen, müssen Sie die Elementfunktion set_zero()nach der Erstellung aufrufen .

Ich würde es so machen:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

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

Der Compiler ist intelligent genug, um den gesamten Code zu überspringen, wenn Sie ihn verwenden event_counts(false), und Sie können genau sagen, was Sie meinen, anstatt die Benutzeroberfläche Ihrer Klasse so seltsam zu machen.

Ich würde eine Unterklasse verwenden, um ein bisschen Tipparbeit zu sparen:

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

Sie können die Dummy-Klasse entfernen, indem Sie das Argument des nicht initialisierenden Konstruktors in booloder intoder so ändern , da es nicht mehr mnemonisch sein muss.

Sie können die Vererbung auch vertauschen und events_count_no_initmit einem Standardkonstruktor definieren, wie er in der Antwort von Evg vorgeschlagen wurde, und dann events_countdie Unterklasse sein:

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