Unterschied zwischen " constexpr` und `const`

Grundlegenden Bedeutung und der syntax

Beide keywords verwendet werden können, die in der Erklärung der Objekte als auch Funktionen. Der grundlegende Unterschied ist der, wenn angewandt, um Objekte ist diese:

• const deklariert ein Objekt als Konstante. Dies bedeutet eine Garantie, dass, sobald Sie initialisiert wurde, wird der Wert des Objekts nicht ändern, und der compiler kann nutzen diese Tatsache für Optimierungen. Es hilft auch verhindern, dass die Programmierer schreiben code, der modifiziert Objekte, die nicht dazu bestimmt sind, geändert werden nach der Initialisierung.

• constexpr deklariert ein Objekt als fit für den Einsatz in dem, was der Standard fordert Konstante Ausdrücke. Aber beachten Sie, dass constexpr ist nicht der einzige Weg, dies zu tun.

Wenn Funktionen der grundlegende Unterschied ist dieser:

• const können nur verwendet werden für nicht-statische member-Funktionen, keine Funktionen im Allgemeinen. Es gibt eine Garantie, dass die member-Funktion nicht ändern, die nicht-statischen Daten-member.

• constexpr kann verwendet werden mit beiden member und nicht-member-Funktionen sowie Konstruktoren. Es erklärt die Funktion fit für den Einsatz in Konstante Ausdrücke. Der compiler wird nur akzeptieren, wenn die Funktion die bestimmte Kriterien erfüllt (7.1.5/3,4), am wichtigsten ist ^(†):

  • Den Rumpf der Funktion müssen nicht-virtuelle und extrem einfach: Abgesehen von Typdefinitionen und statische behauptet, nur eine einzige return - Anweisung erlaubt ist. Bei einem Konstruktor nur eine Initialisierungs-Liste, typedefs und statische geltend machen dürfen. (= default und = delete sind erlaubt, auch, obwohl.)
  • Als von C++14, die Regeln sind lockerer, was erlaubt ist, da dann innerhalb einer constexpr Funktion: asm Erklärung, eine goto - Anweisung wird eine Anweisung mit einem label andere als case und default, try-block, der die definition einer Variablen von nicht-wörtliche Art, die definition einer Variablen von statischen oder thread Lagerung Dauer, die definition einer Variablen, für die keine Initialisierung durchgeführt wird.
  • Der Argumente und der return-Typ muss literal-Typen (d.h., im Allgemeinen, sehr einfachen Typen, in der Regel Skalare oder Aggregate)

Konstante Ausdrücke

Wie gesagt, constexpr erklärt sowohl Objekte als auch Funktionen als fit für den Einsatz in Konstanten-Ausdrücke. Ein konstanter Ausdruck ist mehr als nur Konstante:

• Kann an Orten eingesetzt werden, erfordern, dass der compile-Zeit-Auswertung, zum Beispiel, template-Parameter und der array-Größe-Bezeichner:

  template<int N>
  class fixed_size_list
  { /*...*/ };
  
  fixed_size_list<X> mylist;  //X must be an integer constant expression
  
  int numbers[X];  //X must be an integer constant expression

• Aber Achtung:

  • Deklarieren etwas als constexpr nicht unbedingt garantieren, dass Sie zur Kompilierzeit ausgewertet. Es verwendet werden kann für solche, aber es kann verwendet werden, in anderen Orten, die zur Laufzeit ausgewertet, wie gut.

  • Einem Objekt kann fit sein für den Einsatz in Konstanten-Ausdrücke ohne erklärt wird constexpr. Beispiel:

    int main()
    {
      const int N = 3;
      int numbers[N] = {1, 2, 3};  //N is constant expression
    }

  Dies ist möglich, weil N, Konstante und initialisiert werden bei der Deklaration mit einem literal, erfüllt die Kriterien für die ein konstanter Ausdruck sein, auch wenn es nicht deklariert constexpr.

Also, wenn ich tatsächlich verwenden constexpr?

• Einer Objekt wie N oben kann verwendet werden, als Konstanten Ausdruck ohne erklärt wird constexpr. Dies gilt für alle Objekte:

  • const
  • von integralen oder Aufzählungstyp und
  • initialisiert werden bei der Deklaration mit einem Ausdruck, der sich ein konstanter Ausdruck sein

  _{[Dies ist aufgrund von §5.19/2: Eine Konstante Ausdruck muß nicht auch ein Teilausdrücke, die sich um "eine lvalue-rvalue-Modifikation, es sei denn, [ ... ] eine glvalue von integralen oder Aufzählungstyp [...]" Dank an Richard Smith für die Korrektur meiner früheren Behauptung, dass dies gilt für alle literal-Typen.]}

• Für eine Funktion fit zu sein für den Einsatz in Konstanten-Ausdrücke, es muss explizit deklariert werden constexpr; es genügt nicht, dass es nur um die Kriterien für die constant-expression-Funktionen. Beispiel:

  template<int N>
  class list
  { };
  
  constexpr int sqr1(int arg)
  { return arg * arg; }
  
  int sqr2(int arg)
  { return arg * arg; }
  
  int main()
  {
    const int X = 2;
    list<sqr1(X)> mylist1;  //OK: sqr1 is constexpr
    list<sqr2(X)> mylist2;  //wrong: sqr2 is not constexpr
  }

Wann kann ich /sollte ich beide verwenden, const und constexpr zusammen?

A. Im Objekt-Deklarationen. Dies ist nie nötig, wenn beide Wörter beziehen sich auf das gleiche Objekt deklariert werden. constexpr impliziert const.

constexpr const int N = 5;

ist das gleiche wie

constexpr int N = 5;

Beachten Sie jedoch, dass es möglicherweise Situationen, wenn die Schlüsselwörter beziehen sich jeweils auf die verschiedenen Teile der Erklärung:

static constexpr int N = 3;

int main()
{
  constexpr const int *NP = &N;
}

Hier NP ist deklariert als eine Adresse konstanter-Ausdruck, d.h. ein Zeiger ist, dass sich ein konstanter Ausdruck. (Dies ist möglich, wenn die Adresse, die erzeugt wird durch anwenden der Adress-operator auf eine statische/Globale Konstanten Ausdruck.) Hier sind sowohl constexpr und const sind erforderlich: constexpr bezieht sich immer auf den Ausdruck erklärt wird (hier NP), während const bezieht sich auf int (es deklariert einen Zeiger-auf-const). Entfernen der const machen würde der Ausdruck illegale (weil (a) ein Zeiger auf non-const-Objekt kann nicht ein konstanter Ausdruck sein, und (b) &N ist in der Tat eine Zeiger-Konstante).

B. In den Funktionsdeklarationen. In C++11, constexpr impliziert const, während in C++14 und C++17, dass ist nicht der Fall. Eine member-Funktion deklariert in C++11 als

constexpr void f();

deklariert werden muss, wie

constexpr void f() const;

unter C++14, um noch nutzbar als const Funktion.

InformationsquelleAutor jogojapan

Übersicht

• const garantiert, dass ein Programm nicht ändert ein Objekt den Wert. Allerdings const garantiert nicht die Art der Initialisierung des Objekts erfährt.

  Betrachten:

  const int mx = numeric_limits<int>::max();  //OK: runtime initialization

  Die Funktion max() bloß gibt einen Literalwert. Da jedoch der Initialisierung wird eine Funktion aufgerufen, die mx erfährt runtime-Initialisierung. Daher können Sie nicht verwenden Sie es als eine konstanter Ausdruck:

  int arr[mx];  //error: “constant expression required”

• constexpr ist eine neue C++11 Schlüsselwort, das befreit Sie von der Notwendigkeit, um Makros zu erstellen und hardcoded Literale. Es garantiert auch, unter bestimmten Bedingungen, Objekte Durchlaufen statische Initialisierung. Sie kontrolliert die Bewertung der Zeit eines Ausdrucks. Mit der Durchsetzung compile-time-Auswertung der seinen Ausdruck, constexpr können Sie definieren, true Konstante Ausdrücke , sind entscheidend für Zeitkritische Anwendungen, system-Programmierung, Vorlagen und generell in jedem code, der setzt auf die compile-Zeit-Konstanten.

Constant-expression-Funktionen

Einen constant-expression-Funktion ist eine Funktion deklariert constexpr. Ihr Körper muss nicht virtuell und bestehen aus einer einzigen return-Anweisung nur, abgesehen von Typdefinitionen und statisch behauptet. Seine Argumente und Rückgabewert müssen literal-Typen. Es kann verwendet werden, mit nicht-Konstanten-Ausdruck-Argumente, aber wenn das geschehen ist, das Resultat ist nicht ein konstanter Ausdruck.

Einem Konstanten-Ausdruck-Funktion ist dazu gedacht zu ersetzen Makros und hardcoded Literale ohne Einbußen bei Leistung oder Sicherheit geben.

constexpr int max() { return INT_MAX; }           //OK
constexpr long long_max() { return 2147483647; }  //OK
constexpr bool get_val()
{
    bool res = false;
    return res;
}  //error: body is not just a return statement

constexpr int square(int x)
{ return x * x; }  //OK: compile-time evaluation only if x is a constant expression
const int res = square(5);  //OK: compile-time evaluation of square(5)
int y = getval();
int n = square(y);          //OK: runtime evaluation of square(y)

Constant-expression-Objekte

Einen constant-expression-Objekt wird ein Objekt deklariert constexpr. Es muss initialisiert werden, mit einem Konstanten Ausdruck, oder ein rvalue konstruiert, indem ein konstanter Ausdruck Konstruktor mit constant-expression Argumente.

Einen constant-expression-Objekt verhält sich so, als wenn es wurde erklärt const, außer dass es erfordert die Initialisierung vor der Verwendung und seine Initialisierung muss ein konstanter Ausdruck sein. Folglich ein konstanter Ausdruck ein Objekt kann immer verwendet werden, als Teil einer anderen Konstanten Ausdruck.

struct S
{
    constexpr int two();      //constant-expression function
private:
    static constexpr int sz;  //constant-expression object
};
constexpr int S::sz = 256;
enum DataPacket
{
    Small = S::two(),  //error: S::two() called before it was defined
    Big = 1024
};
constexpr int S::two() { return sz*2; }
constexpr S s;
int arr[s.two()];  //OK: s.two() called after its definition

Constant-expression Konstruktoren

Einen Konstanten-Ausdruck Konstruktor ist ein Konstruktor deklariert constexpr. Es kann eine member-Initialisierungs-Liste, aber seinen Körper muss leer sein, abgesehen von Typdefinitionen und statisch behauptet. Seine Argumente müssen literal-Typen.

Einem Konstanten-Ausdruck Konstruktor kann der compiler initialisiert das Objekt zur compile-Zeit, vorausgesetzt, dass der Konstruktor die Argumente sind alle Konstanten-Ausdrücke.

struct complex
{
    //constant-expression constructor
    constexpr complex(double r, double i) : re(r), im(i) { }  //OK: empty body
    //constant-expression functions
    constexpr double real() { return re; }
    constexpr double imag() { return im; }
private:
    double re;
    double im;
};
constexpr complex COMP(0.0, 1.0);         //creates a literal complex
double x = 1.0;
constexpr complex cx1(x, 0);              //error: x is not a constant expression
const complex cx2(x, 1);                  //OK: runtime initialization
constexpr double xx = COMP.real();        //OK: compile-time initialization
constexpr double imaglval = COMP.imag();  //OK: compile-time initialization
complex cx3(2, 4.6);                      //OK: runtime initialization

Tipps aus dem Buch Effektives Modernes C++ von Scott Meyers über constexpr:

• constexpr Objekte sind const und initialisiert mit Werten, die während der Kompilierung bekannt;
• constexpr Funktionen erzeugen compile-Zeit ergibt beim Aufruf mit Argumenten, deren Werte bekannt sind, bei der Kompilierung;
• constexpr Objekte und Funktionen verwendet werden können, in einem breiteren Spektrum von Kontexten als nicht -constexpr - Objekte und-Funktionen;
• constexpr ist Teil eines Objekts oder einer Funktion der Schnittstelle.

Quelle:
Mit constexpr zur Verbesserung von Sicherheit, Leistung und Kapselung in C++.

InformationsquelleAutor zangw

Beide const und constexpr angewendet werden können, um Variablen und Funktionen. Obwohl Sie einander ähnlich, in der Tat, Sie sind sehr unterschiedliche Konzepte.

Beide const und constexpr bedeuten, dass Ihre Werte können nicht geändert werden, nach Ihrer Initialisierung. So zum Beispiel:

const int x1=10;
constexpr int x2=10;

x1=20; //ERROR. Variable 'x1' can't be changed.
x2=20; //ERROR. Variable 'x2' can't be changed.

Den prinzipiellen Unterschied zwischen const und constexpr ist die Zeit, wenn Ihre Initialisierung Werte bekannt sind (ausgewertet). Während die Werte der const Variablen ausgewertet werden können, sowohl auf compile-Zeit und Laufzeit constexpr sind immer zur Kompilierzeit ausgewertet. Zum Beispiel:

int temp=rand(); //temp is generated by the the random generator at runtime.

const int x1=10; //OK - known at compile time.
const int x2=temp; //OK - known only at runtime.
constexpr int x3=10; //OK - known at compile time.
constexpr int x4=temp; //ERROR. Compiler can't figure out the value of 'temp' variable at compile time so `constexpr` can't be applied here.

Den entscheidenden Vorteil zu wissen, ob der Wert bekannt ist, zur Kompilierungszeit oder Laufzeit, ist die Tatsache, dass die compile-Zeit-Konstanten können verwendet werden, wenn eine compile-Zeit-Konstanten erforderlich sind. Zum Beispiel, C++ kann man nicht mit angeben C-arrays mit der Länge variabel.

int temp=rand(); //temp is generated by the the random generator at runtime.

int array1[10]; //OK.
int array2[temp]; //ERROR.

So bedeutet es, dass:

const int size1=10; //OK - value known at compile time.
const int size2=temp; //OK - value known only at runtime.
constexpr int size3=10; //OK - value known at compile time.


int array3[size1]; //OK - size is known at compile time.
int array4[size2]; //ERROR - size is known only at runtime time.
int array5[size3]; //OK - size is known at compile time.

So const Variablen definieren können sowohl compile-Zeit-Konstanten wie size1 können verwendet werden, um anzugeben, array-Größen und Laufzeit-Konstanten wie size2 bekannt sind nur zur Laufzeit und kann nicht verwendet werden, um zu definieren, array-Größen. Auf der anderen Seite constexpr immer definieren compile-Zeit-Konstanten, die angeben können, die array-Größen.

Beide const und constexpr angewendet werden können, um Funktionen zu. Ein const Funktion muss eine member-Funktion (Methode, operator) wenn der Antrag von const keyword bedeutet, dass die Methode nicht ändern können Sie die Werte von Ihrem Mitglied (nicht-statischen) Felder. Zum Beispiel.

class test
{
   int x;

   void function1()
   {
      x=100; //OK.
   }

   void function2() const
   {
      x=100; //ERROR. The const methods can't change the values of object fields.
   }
};

Einen constexpr ist ein anderes Konzept. Es markiert eine Funktion (Mitglied oder nicht-Mitglied) als die Funktion, die ausgewertet werden können zur compile-Zeit wenn compile-Zeit-Konstanten übergeben werden, die als Ihre Argumente. Zum Beispiel können Sie schreiben diese.

constexpr int func_constexpr(int X, int Y)
{
    return(X*Y);
}

int func(int X, int Y)
{
    return(X*Y);
}

int array1[func_constexpr(10,20)]; //OK - func_constexpr() can be evaluated at compile time.
int array2[func(10,20)]; //ERROR - func() is not a constexpr function.

int array3[func_constexpr(10,rand())]; //ERROR - even though func_constexpr() is the 'constexpr' function, the expression 'constexpr(10,rand())' can't be evaluated at compile time.

Durch die Art und Weise der constexpr Funktionen sind das normale C++ - Funktionen, die aufgerufen werden können, auch wenn nicht-Konstante Argumente übergeben werden. Aber in diesem Fall, Sie werden immer das non-constexpr-Werte.

int value1=func_constexpr(10,rand()); //OK. value1 is non-constexpr value that is evaluated in runtime.
constexpr int value2=func_constexpr(10,rand()); //ERROR. value2 is constexpr and the expression func_constexpr(10,rand()) can't be evaluated at compile time.

Den constexpr kann auch angewendet werden, um die member-Funktionen (Methoden), die Betreiber und auch Konstruktoren. Zum Beispiel.

class test2
{
    static constexpr int function(int value)
    {
        return(value+1);
    }

    void f()
    {
        int x[function(10)];


    }
};

Mehr 'verrückt' sample.

class test3
{
    public:

    int value;

    //constexpr const method - can't chanage the values of object fields and can be evaluated at compile time.
    constexpr int getvalue() const
    {
        return(value);
    }

    constexpr test3(int Value)
        : value(Value)
    {
    }
};


constexpr test3 x(100); //OK. Constructor is constexpr.

int array[x.getvalue()]; //OK. x.getvalue() is constexpr and can be evaluated at compile time.

InformationsquelleAutor Timmy_A

Einen const int var kann dynamisch eingestellt auf einen Wert, der Laufzeit und einmal ist es auf den Wert gesetzt, kann es nicht mehr geändert werden.

Einen constexpr int var nicht dynamisch zur Laufzeit, sondern zur compile-Zeit. Und einmal ist es auf den Wert gesetzt, kann es nicht mehr geändert werden.

Hier ist ein solides Beispiel:

int main(int argc, char*argv[]) {
    const int p = argc; 
    //p = 69; //cannot change p because it is a const
    //constexpr int q = argc; //cannot be, bcoz argc cannot be computed at compile time 
    constexpr int r = 2^3; //this works!
    //r = 42; //same as const too, it cannot be changed
}

Dem snippet oben kompiliert in Ordnung und ich kommentiert haben, diejenigen, die ihn verursachen Fehler.

InformationsquelleAutor typelogic