Is const een verwijzing naar een wereldwijde constante goede praktijk?

 C Programming >> C Programmeren >  >> C
Is const een verwijzing naar een wereldwijde constante goede praktijk?

Oplossing voor Is const verwijzing naar een wereldwijde constante goede praktijk?
wordt hieronder gegeven:

Proberen erachter te komen hoe u efficiënt en veilig kunt verwijzen naar globale aangepaste typeconstanten die tijdens het compileren worden geïnitialiseerd. Ik wil het kopiëren van Foo vermijden, omdat ik veel Bar-instanties zal maken en Foo een beetje ingewikkelder is dan hier wordt getoond. Het houden van een const-referentie van Bar naar Foo lijkt veilig (of is het?) Maar tegelijkertijd weet ik niet hoe ik het gebruik van "badBar" indien mogelijk kan voorkomen. Suggesties?

class Foo
{
    int a_, b_;
public:
    constexpr Foo(int a, int b) : a_(a), b_(b) {}
};

inline constexpr Foo kFoo{1, 2};

class Bar
{
    const Foo& foo_;
public:
    Bar(const Foo& foo) : foo_(foo) {}
    const Foo& foo() { return foo_; }
};

int main() {
    Bar goodBar(kFoo);
    Bar badBar(Foo(3, 4)); // ouch
    return 0;
}

Ja, het behouden van een verwijzing naar een globaal gedefinieerde constante variabele is veilig omdat deze altijd geldig zal zijn.

Je kunt het lid gewoon direct initialiseren:

class Foo
{
    int a_, b_;
public:
    constexpr Foo(int a, int b) : a_(a), b_(b) {}
};

inline constexpr Foo kFoo{1, 2};

class Bar
{
    const Foo& foo_=kFoo;
};

De rest van de wereld hoeft niet te weten dat het bestaat en maakt de ctor van Bar eenvoudiger.

Hoewel het enigszins overbodig aanvoelt, kun je overal foo_ . schrijven , je kunt ook kFoo . schrijven . Misschien begrijp ik je vraag niet goed?

U kunt een rvalue-constructor toevoegen om rvalue-argumenten te negeren.

class Bar
{
    const Foo& foo_;
public:
    Bar(const Foo& foo) : foo_(foo) {}
    Bar(Foo &&) = delete; // <-- rvalue constructor
    const Foo& foo() { return foo_; }
};