C++ Standard-Enumerationswert Nutzung

Question

Diese Diskussion geht es um einen Namen Standardwert: C#: Should the default value of an enum be None or Unknown?

jedoch große Menge von Menschen, die ich mit vor kurzem als Standard-ENUM-Werten schädlich, unnötig und potenziell führen zu einer schlechten Praxis gesprochen.

Als Beispiel ist folgendes zu beachten:

enum eJobStates 
{ 
    JOB_STATE_INITIALISING, 
    JOB_STATE_PROCESSING, 
    JOB_STATE_DONE 
}; 

es keinen Sinn für einen Job machen würde in etwa JOB_STATE_UNKNOWN zu sein, aber man kann sich vorstellen, dass jede Struktur, die für die Überwachung verwendet werden könnten, der Arbeitsplätze könnte Verwenden Sie einen solchen Wert.

Gibt es Best Practices/Faustregeln bezüglich der Erstellung eines Standardwerts beim Definieren einer Enumeration? Sollten sie wann immer möglich um jeden Preis vermieden werden?

Answer 1

Ein ungültiger Standardwert ist im Grunde eine Variante in Ihrem Design. Das Objekt ist nicht gültig, wenn es erstellt wird. Sie sollten das vermeiden, wenn es vernünftig ist. Auf keinen Fall sollten Sie es "um jeden Preis" vermeiden.

Bei einigen Problemen müssen Sie in einem Variantenzustand beginnen. In diesem Fall haben Sie , um diesen ungültigen Wert mental zu begründen. Wenn Sie es vermeiden, es zu benennen, machen Sie Ihren Code aktiv weniger ausdrucksvoll. Denken Sie darüber nach, was die Kommunikation zwischen Ihnen und der Person betrifft, die den Code später pflegen muss.

Der Umgang mit dem Wind ist ärgerlich. Sie beginnen in einem Variantenzustand, aber wenn es relevant ist, hoffen Sie, dass es keine Variante mehr ist. Die Strategie, die ich bevorzuge, ist es, Benutzern zu erlauben, den Variantenzustand zu ignorieren und einfach zu werfen, wenn ich einen Fehler gemacht habe.

Dies befreit Ihre Benutzer von der Notwendigkeit, über Ihre Varianz nachzudenken, für die es sich zu kämpfen lohnt.

Wenn Sie damit nicht durchkommen, bevorzuge ich es normalerweise, zu sicheren und unsicheren Schnittstellen zu degradieren.

struct Foo { 
    Foo() : val(FooType::INVALID) {} 
    bool get(FooType::EnumValue& val_) const { 
    if (val == FooType::INVALID) 
     return false; 
    val_ = val; 
    return true; 
    } 
    FooType::EnumValue get() const { 
    FooType::EnumValue val_; 
    if (!get(val_)) 
     throw std::logic_error("variant Foo state"); 
    return val_; 
    } 
    FooType::EnumValue get_or_default(FooType::EnumValue def) const { 
    FooType::EnumValue val_; 
    if (!get(val_)) 
     return def; 
    return val_; 
    } 
    FooType::EnumValue val; 
}; 

Diese Arten von Schnittstellen sind gut für Dinge wie Datenbanken, in denen Nullwerte erwartet werden können.