Idiomatyczny sposób rozróżnienia dwóch konstruktorów zero-arg

Mam taką klasę:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    // more stuff

};

Zwykle chcę domyślnie (zero) zainicjować countstablicę, jak pokazano.

Jednak w wybranych lokalizacjach zidentyfikowanych przez profilowanie chciałbym powstrzymać inicjalizację tablicy, ponieważ wiem, że tablica wkrótce zostanie zastąpiona, ale kompilator nie jest wystarczająco inteligentny, aby to rozgryźć.

Jaki jest idiomatyczny i skuteczny sposób stworzenia takiego „wtórnego” konstruktora zero-arg?

Obecnie używam klasy znaczników, uninit_tagktóra jest przekazywana jako fikcyjny argument, na przykład:

struct uninit_tag{};

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

    event_counts(uninit_tag) {}

    // more stuff

};

Następnie wywołuję konstruktor bez inicjacji, tak jak event_counts c(uninit_tag{});gdy chcę wyłączyć konstrukcję.

Jestem otwarty na rozwiązania, które nie wymagają stworzenia sztucznej klasy lub są w jakiś sposób bardziej wydajne itp.

Rozwiązanie, które już masz, jest poprawne i jest dokładnie tym, co chciałbym zobaczyć, gdybym sprawdzał twój kod. Jest tak wydajny, jak to możliwe, jasny i zwięzły.

Jeśli treść konstruktora jest pusta, można ją pominąć lub ustawić domyślnie:

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

Wtedy domyślna inicjalizacja event_counts counts; pozostawi counts.countsniezainicjowaną (tutaj domyślna inicjalizacja nie jest możliwa ), a inicjalizacja event_counts counts{}; wartości spowoduje zainicjowanie wartości counts.counts, skutecznie wypełniając ją zerami.

Podoba mi się twoje rozwiązanie. Być może rozważałeś także zagnieżdżoną strukturę i zmienną statyczną. Na przykład:

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

};

W przypadku zmiennej statycznej wywołanie niezainicjowanego konstruktora może wydawać się wygodniejsze:

event_counts e(event_counts::uninit);

Możesz oczywiście wprowadzić makro, aby zapisać pisanie i uczynić go bardziej systematyczną funkcją

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

struct event_counts {
    UNINIT_TAG
}

struct other_counts {
    UNINIT_TAG
}

Myślę, że wyliczanie jest lepszym wyborem niż klasa tagów lub bool. Nie musisz przekazywać wystąpienia struktury i od osoby dzwoniącej jasno wynika, którą opcję otrzymujesz.

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

Następnie tworzenie instancji wygląda następująco:

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

Lub, aby uczynić to bardziej zbliżonym do klasy tagów, użyj wyliczenia pojedynczej wartości zamiast klasy tag:

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

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

Istnieją tylko dwa sposoby utworzenia instancji:

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

Możesz rozważyć inicjację dwufazową dla swojej klasy:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() = default;

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

Konstruktor powyżej nie inicjuje tablicy do zera. Aby ustawić elementy tablicy na zero, musisz wywołać funkcję elementu set_zero()po zakończeniu budowy.

Zrobiłbym to w ten sposób:

struct event_counts {
    uint64_t counts[MAX_COUNTERS];

    event_counts() : counts{} {}

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

Kompilator będzie wystarczająco inteligentny, aby pominąć cały kod, gdy go używasz event_counts(false), i możesz powiedzieć dokładnie, co masz na myśli, zamiast sprawić, że interfejs twojej klasy będzie tak dziwny.

Użyłbym podklasy, żeby zaoszczędzić trochę pisania:

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

Można pozbyć klasy manekina przez zmianę argument konstruktora nie do inicjalizacji boollub intczy coś, bo nie ma już być pamięciowy.

Możesz także zamienić dziedzictwo i zdefiniować events_count_no_initza pomocą domyślnego konstruktora, takiego jak sugerowany w odpowiedzi Evg, a następnie events_countbyć podklasą:

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