enum vs constexpr für die tatsächliche statische Konstanten innerhalb von Klassen

Lassen Sie mich beginnen mit der Feststellung, meine Absicht. In den alten (C++) Tage, wir hätten einen code wie:

class C
{
public:
  enum {SOME_VALUE=27};
};

Dann könnten wir SOME_VALUE überall in unserem code einen compile-Zeit-Konstante und überall dort, wo der compiler würde sehen C::SOME_VALUE, es wäre nur legen Sie die wörtliche 27.

Jetzt Tage, es scheint akzeptabler zu ändern, dass der code so etwas wie:

class C
{
public:
  static constexpr int SOME_VALUE=27;
};

Das sieht viel sauberer aus, gibt SOME_VALUE eine gut definierte Art zu sein scheint: der am günstigsten gelegene Ansatz von C++11. Die (vorhersehbare zumindest für mich) problem ist, dass dies verursacht auch Szenarien, in denen SOME_VALUE muss gemacht werden externe. Das heißt, in einigen cpp-Datei, die irgendwo, wir müssen hinzufügen:

constexpr int C::SOME_VALUE; //Now C::SOME_VALUE has external linkage

Den Fällen, die Ursache dafür zu sein scheinen, wenn const-Referenzen zu SOME_VALUE verwendet werden, das passiert sehr oft in der C++ Standard Library code (Siehe das Beispiel am Ende dieser Frage). Ich bin mit gcc 4.7.2, wie mein compiler durch die Art und Weise.

Durch dieses dilemma bin ich gezwungen, um wieder zurück zu definieren SOME_VALUE als enum (D. H., old school), um zu vermeiden, dass Sie eine definition an, die eine cpp-Datei, die für einige, aber nicht alle meine static constexpr-member-Variablen. Gibt es nicht ein Weg, zu sagen, der compiler, dass constexpr int SOME_VALUE=27 bedeutet, dass SOME_VALUE behandelt werden sollte nur als eine compile-Zeit-Konstante und niemals ein Objekt mit externer Bindung? Wenn Sie sehen, eine const-Referenz, die Sie mit ihm, erstellen Sie eine temporäre. Wenn Sie sehen, Ihr Adresse genommen, erzeugen einen compile-Zeit-Fehler, wenn das, was gebraucht wird, weil es einen compile-Zeit-Konstanten, und nichts mehr.

Hier einige scheinbar harmloses Beispiel-code, der bewirkt, dass wir brauchen, um hinzuzufügen, die definition für SOME_VALUE in einer cpp-Datei (erneut getestet mit gcc 4.7.2):

#include <vector>

class C
{
public:
  static constexpr int SOME_VALUE=5;
};

int main()
{
  std::vector<int> iv;

  iv.push_back(C::SOME_VALUE); //Will cause an undefined reference error
                               //at link time, because the compiler isn't smart
                               //enough to treat C::SOME_VALUE as the literal 5
                               //even though it's obvious at compile time
}

Fügen Sie folgende Zeile in den code-Datei Umfang wird den Fehler beheben:

constexpr int C::SOME_VALUE;
  • Ich bin wirklich verwirrt ", wenn die Adresse von SOME_VALUE genommen, ... bin ich gezwungen, um wieder zurück zu definieren SOME_VALUE als enum". Enumeratoren sind prvalues, können Sie nicht nehmen Sie Ihre Adressen entweder.
  • Ich habe geändert, die Frage nur eine const-Referenzen auf den Wert, so dass unter einer Adresse ist nicht "erforderlich" (d.h., einem temporären erstellt werden können).
  • Sie dürfen static constexpr int SOME_VALUE() { return 5; }...
  • BTW, man kann jetzt geben Enumeratoren einen gut definierten Typ: enum : int { SOME_VALUE = 5 };
  • Aber, Enumeratoren beschränken uns auf Integrale Werte - ein weiterer Nachteil der Verwendung von Ihnen.
  • Ich glaube nicht, dass static constexpr int&& SOME_VALUE=27; ist erlaubt? Wahrscheinlich nicht... "So ein Objekt haben soll-literal type"
  • Ich denke, diese ganze Frage läuft darauf hinaus, "Warum constexpr erstellen Sie ein lvalue?"
  • Oder vielleicht, warum constexpr erstellen Sie ein lvalue, wenn es die Adresse ist nie ergriffen (oder nicht ergriffen werden müssen, wie es der Fall mit const & und seine Fähigkeit, Provisorien).
  • Ähnliche Fragen und Antworten wie [1], [2], [3], die ich gesammelt haben, hier eine Reihe von Problemumgehungen. Das prägnanteste ist die Verwendung +SOME_VALUE um ein temporäres.
  • ist ein interessanter workaround, aber wieder nur für numerische Typen, und diejenigen, für die ein unärer plus-operator definiert ist. Natürlich Enumerationen erlauben nur Integrale Typen als gut.
  • Sie definieren Ihre eigene Identität-Funktion, die zwingen würde, einen Wert einer temporären: template<typename T> constexpr T noref( T t ) { return t; }. Dies könnte angewendet werden, indem Sie mit noref(SOME_VALUE) wohin mit SOME_VALUE endet, wobei eine Referenz. (Dies würde nur Arbeit für die wörtliche beweglichen oder kopierbar Typen, aber das ist allgemeiner als die + die arbeiten für numerische Typen, die wörtliche kopierbar-Typen.)
  • Das zugrunde liegende problem ist, dass die übergabe per Referenz (potentiell) benötigt eine Adresse. Es gibt keine Adresse für etwas, das nicht definiert. So erstellen Sie ein Objekt schließlich an eine Adresse. Das ist, warum viele Lösungen hier mit Provisorien. Ein weiterer Weg, um eine zu erstellen ist die Verwendung einer wrapper mit einem constexpr conversion operator. Ich denke, es sollte in Ordnung, wenn es keine Vorlage geben Abzug beteiligt.
  • Alle diese workarounds zeigen mir, dass mit einem enum für die integralen Konstanten ist besser als ein static constexpr. Es gibt weniger überraschungen (zumindest sowieso). Bonus für die Arbeit mit älteren C++ und C, zu.
  • Wenn Sie erwägen, +SOME_VALUE, können Sie auch verwenden, SOME_VALUE(), und definieren Sie es als nur static constexpr int SOME_VALUE() { return 5; }. Diese ist ebenso allgemein wie noref Vorlage, und braucht weniger boilerplate. Sie bekommen bonus von SOME_VALUE mit wesentlich anderen Typ als SOME_VALUE(), so dass Sie nie vergessen hinzufügen ().
  • Für das Protokoll, Clang kompiliert auch der OP-code, ohne die out-of-class-definition.

InformationsquelleAutor Michael Goldshteyn | 2014-04-04
  1. 8

    Für die Aufzeichnung, die static constexpr version funktionieren wird, wie Sie erwartet hatte, das in C++17. Von N4618 Anhang D. 1 [depr.static_constexpr]:

    D. 1 nochmaliges deklarieren einer von static constexpr Mitglieder-Daten [depr.static_constexpr]

    Für Abwärtskompatibilität mit früheren C++ Internationaler Standards, eine constexpr statische Daten-member werden kann Redundant erneut deklariert, die außerhalb der Klasse ohne Initialisierung. Diese Syntax ist veraltet. [Beispiel:

    struct A {
 static constexpr int n = 5; //definition (declaration in C++ 2014)
};

constexpr int A::n; //redundant declaration (definition in C++ 2014)

    —Ende Beispiel]

    Den jeweiligen standard-text, der dies ermöglicht, ist N4618 9.2.3 [class.statisch.Daten]/3:

    [...] Ein inline-statischen Daten-member definiert werden kann in der definition der Klasse und können einen Klammer-oder-gleich-Initialisierer. Wenn das Mitglied erklärt, mit der constexpr Planer, kann es sein, erneut deklariert im namespace-Gültigkeitsbereich ohne Initialisierer (diese Syntax ist veraltet; siehe D. 1). [...]

    Diese kommt mit den gleichen Maschinen eingeführt, die nicht-constexpr version von der gleichen Sache, inline-statischen Daten-member.

    struct A {
 static inline int n = 5; //definition (illegal in C++ 2014)
}; 

inline int A::n; //illegal
    • Ich werde aktualisieren mit diesem mich, aber da hast du dir ja die Arbeit gemacht, habe ich beschlossen, nehmen Sie einfach Ihre Antwort zu helfen, jemand anderes suchen, in dieser Ausgabe.
    InformationsquelleAutor TBBle
  2. 9

    Haben Sie drei Möglichkeiten:

    1. Wenn Ihre Klasse mit einer Vorlage, dann setzen Sie die definition der statischen member im header selbst. Compiler ist erforderlich, um zu identifizieren es als eine definition, die nur über mehrere übersetzungseinheiten (siehe [basic.def.OS -]/5)

    2. Wenn Ihre Klasse nicht-Vorlage können Sie leicht steckte es in source-Datei

    3. Alternativ erklären constexpr statische member-Funktion getSomeValue():

      class C
{
public:
    static constexpr int getSomeValue() { return 27; }
};
    InformationsquelleAutor apoorvkul
  3. 2

    Dann würde ich mit der enum-Klasse:

    http://en.cppreference.com/w/cpp/language/enum

    http://www.stroustrup.com/C++11FAQ.html#enum

    Vom ersten link:

    enum class Color { RED, GREEN=20, BLUE};
Color r = Color::BLUE;
switch(r) {
    case Color::RED : std::cout << "red\n"; break;
    case Color::GREEN : std::cout << "green\n"; break;
    case Color::BLUE : std::cout << "blue\n"; break;
}
//int n = r; //error: no scoped enum to int conversion
int n = static_cast<int>(r); //OK, n = 21
    • Dies gibt die enum ein Typ wie erwähnt im Vorbeigehen durch die OP aber nicht Ihre primäre Frage, die war ob es möglich ist, vermeiden externe Bindung bei der Verwendung von static const[expr]' statt enum.
    InformationsquelleAutor Fernando A. Gómez F.
  4. 1

    Heute der bevorzugte Weg ist:

    enum class : int C { SOME_VALUE = 5 };
    • Aber jetzt musst du explizit casten, wenn müssen Sie den int-Wert.
    • Dies gibt die enum ein Typ wie erwähnt im Vorbeigehen durch die OP aber nicht Ihre primäre Frage, die war ob es möglich ist, vermeiden externe Bindung bei der Verwendung von static const[expr]' statt enum.
    • Warum würden Sie zwingen, einen Namen und eine Klasse, die auf den enum? Die zugrunde liegenden Art kann ich verstehen, aber warum der rest?
    InformationsquelleAutor edwinc
  5. 1

    Aus der C++ - standard N3797 S3.5/2-3

    Einen Namen, so wird gesagt, Gestänge, wenn es vielleicht bezeichnen das gleiche Objekt, Referenz, Funktion, Typ, template namespace oder den Wert als name eingeführt, die von einer Erklärung in einem anderen Bereich:

    — Wenn Sie einen Namen hat externe Bindung , die die Entität bezeichnet werden können, bezeichnet durch Namen aus dem Bereiche der anderen übersetzungseinheiten oder aus anderen Bereichen der gleichen übersetzungseinheit.

    — Wenn ein name und hat interne Bindung , die die Entität bezeichnet werden können, bezeichnet durch Namen aus anderen Bereichen in der gleichen übersetzungseinheit.

    — Wenn ein name und hat keine Verknüpfung , die Entität, die es bezeichnet nicht bezeichnet werden durch Namen aus anderen Bereichen.

    Einen Namen mit namespace-Gültigkeitsbereich (3.3.6) hat interne Bindung, wenn er den Namen

    — eine variable, Funktion oder function template explizit als static deklariert; oder,

    — a non-volatile-variable explizit deklariert werden constexpr const oder und weder explizit deklariert werden extern noch zuvor erklärt haben externe Bindung; oder

    — ein Datenelement von einem anonymen union.

    Meine Lesung ist, dass in den folgenden code:

    public:
  static constexpr int SOME_VALUE=5;
  constexpr int SOME_VALUE=5;
};
static constexpr int SOME_VALUE=5;
constexpr int SOME_VALUE=5;

    Alle 4 Instanzen SOME_VALUE haben interne linkage. Sollten Sie den link mit einem Verweis auf SOME_VALUE in der gleichen übersetzungseinheit und nicht sichtbar anderswo.

    Offensichtlich ist die erste ist eine Erklärung und keine definition. Es braucht eine definition, die innerhalb derselben übersetzungseinheit. Wenn GCC sagt so und MSVC nicht, dann MSVC ist falsch.

    Für die Zwecke der Ersatz einer enum Nummer 2 sollte gut funktionieren. Es hat immer noch interne Verlinkung, ohne die static Stichwort.

    [Editiert Antwort zu Kommentar]

    • Danke! War ein spät in die Nacht. Sehen Sie auf Bearbeiten.
    • Der code, den Sie zeigen, ist nicht genug, um zu bestimmen, ob die Kopplung extern sein oder nicht. Sie brauchen, um passieren, dass der Wert durch einen Verweis auf eine Funktion wie in meinem Beispiel, für die Verlinkung zu externen.
    • AUA! Der zweite Satz war OK. Behoben.
    • Ich glaube nicht, dass Verknüpfung ist eigentlich ein problem hier. Verknüpfung ist eine Eigenschaft eines namens. Wie gesagt, verbindliche einige statische Daten-member SOME_VALUE dass nicht eine definition an, einen Verweis gegen die Online-Streitbeilegung, die nicht ist eine Verknüpfung Problem. Kann man sehr gut mit Namen, die keine Verknüpfung (wie automatische Variablen) oder die interne Verlinkung (wie statische Globale Variablen) als Argumente für push_back zum Beispiel.
    • "das ist nicht eine Verknüpfung Problem" <- das kann ein bisschen verwirrend sein, weil linker kann nicht finden, eine definition für die variable in den OP. Was ich meine, hier ist Verknüpfung, wie die Sichtbarkeit eines namens, als in der Norm definiert.
    InformationsquelleAutor david.pfx
  6. -1

    können Sie dies tun,

    class C
{
public:
  static const int SOME_VALUE=5;
};

int main()
{
  std::vector<int> iv;
  iv.push_back(C::SOME_VALUE); 
}

    Ist dies auch nicht C++11, nur C++98

    • Natürlich kann man, und es wird nicht kompiliert, aus genau dem gleichen Grund, aus dem OP-code.
    • Es kompiliert und funktioniert, VS 2012, wie es immer (ich habe mit dieser seit Jahren). Siehe hier stackoverflow.com/questions/2605520/... auch hier publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/... und hier devx.com/tips/Tip/5602
    • Im Allgemeinen, in C++98 statische Klassenkonstanten definiert werden müssen, in einer übersetzung Einheit, es sei denn, Sie sind const
    • Gut, du hast Recht, es scheint, dass es wirklich sollte zu arbeiten. Aber in gcc (getestet in 4.8.2) ist es nicht. Ich bekomme test.cpp:(.text+0x1a): undefined reference to C::SOME_VALUE", während die Verknüpfung, wie OP. Scheint der gcc-Fehler.
    • Die Tatsache, dass diese Werke in VS2012, macht es nicht kompatibel mit allen anderen Compilern (z.B. gcc). Im Allgemeinen hat Microsoft eher lax, was es compiler als Fehler (d.h., eine accomodative Haltung mit Respekt an die Entwickler, anstatt strict standard compliance). Zusätzlich, wenn ein durch die value-version von push_back ist in std::vector, die eine Spezialisierung für die Integrale und/oder klein-POD-Typen, die linker-Fehler beseitigt werden können. Ob solch eine Umsetzung würde gegen die Norm können unterschiedlich interpretiert werden.
    • Michael, es ist die andere Weise herum, in dieser Angelegenheit VS folgt dem standard, während gcc nicht. Ich fand diese in der standard-9.4.2/4 - Wenn Sie eine statische Daten-member ist, der integral const oder const Typ "enumeration", dessen Deklaration in der Klassendefinition angeben können, eine Konstante Initialisierer, das wird ein integraler konstanter Ausdruck (5.19). In diesem Fall kann das Mitglied erscheint in der integralen Konstanten-Ausdrücke. Das Mitglied muss noch definiert werden namespace-Gültigkeitsbereich, wenn es verwendet wird, in das Programm und die namespace-Gültigkeitsbereich Begriffsbestimmung nicht enthalten eine Initialisierung.
    • Die Problemumgehung für gcc in diesem Fall wäre die separate Deklaration und Initialisierung. Innerhalb der Klasse wäre static const int SOME_VALUE; und externen wäre es const int C::SOME_VALUE = 5; aber das ist nicht viel von einer Verbesserung.
    • Ich persönlich noch verwenden Enumerationen und wenn ich jemals als etwas anderes, wäre es, explizit den Typ angeben, die C++11 erlaubt. Der Grund, warum, würde ich immer diese bevorzugen, ist, dass ich immer darauf bestehen, mit einer festen ABI (ich habe immer verlangen, dass alles zugänglich und prüfbar aus C)
    • was hat das damit zu tun, ob es extern ist oder nicht?

    InformationsquelleAutor Ophir Gvirtzer
Schreibe einen Kommentar