Wann sollten Sie die constexpr-Funktion in C ++ 11 verwenden?

Es scheint mir, dass eine "Funktion, die immer 5 zurückgibt" die Bedeutung von "Aufrufen einer Funktion" bricht oder verwässert. Es muss einen Grund oder eine Notwendigkeit für diese Funktion geben, sonst wäre es nicht in C ++ 11. Warum ist es dort?

// preprocessor.
#define MEANING_OF_LIFE 42

// constants:
const int MeaningOfLife = 42;

// constexpr-function:
constexpr int MeaningOfLife () { return 42; }

Es scheint mir, dass wenn ich eine Funktion schreibe, die einen Literalwert zurückgibt, und ich zu einer Codeüberprüfung komme, mir jemand sagt, ich sollte dann einen konstanten Wert deklarieren, anstatt return 5 zu schreiben.

Angenommen, es macht etwas etwas komplizierter.

constexpr int MeaningOfLife ( int a, int b ) { return a * b; }

const int meaningOfLife = MeaningOfLife( 6, 7 );

Jetzt haben Sie etwas, das bis auf eine Konstante ausgewertet werden kann, während die Lesbarkeit erhalten bleibt und eine etwas komplexere Verarbeitung möglich ist, als nur eine Konstante auf eine Zahl zu setzen.

Grundsätzlich bietet es eine gute Hilfe für die Wartbarkeit, da klarer wird, was Sie tun. Nehmen Sie max( a, b )zum Beispiel:

template< typename Type > constexpr Type max( Type a, Type b ) { return a < b ? b : a; }

Dort ist es eine ziemlich einfache Wahl, aber es bedeutet, dass wenn Sie maxmit konstanten Werten aufrufen , diese explizit zur Kompilierungszeit und nicht zur Laufzeit berechnet wird.

Ein weiteres gutes Beispiel wäre eine DegreesToRadiansFunktion. Jeder findet Abschlüsse leichter zu lesen als Bogenmaß. Während Sie vielleicht wissen, dass 180 Grad im Bogenmaß sind, ist es viel klarer wie folgt geschrieben:

const float oneeighty = DegreesToRadians( 180.0f );

Viele gute Infos hier:

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

Einführung

constexprwurde nicht eingeführt, um der Implementierung mitzuteilen, dass etwas in einem Kontext bewertet werden kann, der einen konstanten Ausdruck erfordert ; Konforme Implementierungen konnten dies vor C ++ 11 beweisen.

Was eine Implementierung nicht beweisen kann, ist die Absicht eines bestimmten Codes:

• Was möchte der Entwickler mit dieser Entität ausdrücken?
• Sollten wir blind zulassen, dass Code in einem konstanten Ausdruck verwendet wird , nur weil er zufällig funktioniert?

Was wäre die Welt ohne constexpr?

Angenommen, Sie entwickeln eine Bibliothek und stellen fest, dass Sie die Summe jeder Ganzzahl im Intervall berechnen möchten (0,N].

int f (int n) {
  return n > 0 ? n + f (n-1) : n;
}

Der Mangel an Absicht

Ein Compiler kann leicht beweisen, dass die obige Funktion in einem Konstantenausdruck aufrufbar ist, wenn das übergebene Argument während der Übersetzung bekannt ist. Aber Sie haben dies nicht als Absicht deklariert - es war einfach so.

Jetzt kommt jemand anderes, liest Ihre Funktion und führt die gleiche Analyse durch wie der Compiler. " Oh, diese Funktion kann in einem konstanten Ausdruck verwendet werden!" und schreibt den folgenden Code.

T arr[f(10)]; // freakin' magic

Die Optimierung

Sie als "großartiger" Bibliotheksentwickler entscheiden, dass fdas Ergebnis beim Aufrufen zwischengespeichert werden soll. Wer möchte immer wieder die gleichen Werte berechnen?

int func (int n) { 
  static std::map<int, int> _cached;

  if (_cached.find (n) == _cached.end ()) 
    _cached[n] = n > 0 ? n + func (n-1) : n;

  return _cached[n];
}

Das Ergebnis

Durch die Einführung Ihrer albernen Optimierung haben Sie einfach jede Verwendung Ihrer Funktion unterbrochen, die sich zufällig in einem Kontext befand, in dem ein konstanter Ausdruck erforderlich war.

Sie haben nie versprochen, dass die Funktion in einem konstanten Ausdruck verwendet werden kann , und ohne sie constexprgäbe es keine Möglichkeit, ein solches Versprechen abzugeben.

Also, warum brauchen wir constexpr?

Die Hauptverwendung von constexpr besteht darin, die Absicht zu erklären .

Wenn eine Entität nicht als gekennzeichnet ist, sollte constexprsie niemals in einem konstanten Ausdruck verwendet werden . und selbst wenn dies der Fall ist, verlassen wir uns darauf, dass der Compiler einen solchen Kontext diagnostiziert (weil er unsere Absicht missachtet).

Nehmen Sie std::numeric_limits<T>::max(): aus welchem ​​Grund auch immer, dies ist eine Methode. constexprwäre hier von Vorteil.

Ein weiteres Beispiel: Sie möchten ein C-Array (oder a std::array) deklarieren , das so groß ist wie ein anderes Array. Der Weg, dies im Moment zu tun, ist wie folgt:

int x[10];
int y[sizeof x / sizeof x[0]];

Aber wäre es nicht besser schreiben zu können:

int y[size_of(x)];

Dank constexprkönnen Sie:

template <typename T, size_t N>
constexpr size_t size_of(T (&)[N]) {
    return N;
}

constexprFunktionen sind wirklich nett und eine großartige Ergänzung zu C ++. Sie haben jedoch Recht, dass die meisten Probleme, die es löst, unelegant mit Makros umgangen werden können.

Eine der Verwendungen von constexprhat jedoch keine C ++ 03-äquivalenten typisierten Konstanten.

// This is bad for obvious reasons.
#define ONE 1;

// This works most of the time but isn't fully typed.
enum { TWO = 2 };

// This doesn't compile
enum { pi = 3.1415f };

// This is a file local lvalue masquerading as a global
// rvalue.  It works most of the time.  But May subtly break
// with static initialization order issues, eg pi = 0 for some files.
static const float pi = 3.1415f;

// This is a true constant rvalue
constexpr float pi = 3.1415f;

// Haven't you always wanted to do this?
// constexpr std::string awesome = "oh yeah!!!";
// UPDATE: sadly std::string lacks a constexpr ctor

struct A
{
   static const int four = 4;
   static const int five = 5;
   constexpr int six = 6;
};

int main()
{
   &A::four; // linker error
   &A::six; // compiler error

   // EXTREMELY subtle linker error
   int i = rand()? A::four: A::five;
   // It not safe use static const class variables with the ternary operator!
}

//Adding this to any cpp file would fix the linker error.
//int A::four;
//int A::six;

Nach dem, was ich gelesen habe, ergibt sich die Notwendigkeit von constexpr aus einem Problem bei der Metaprogrammierung. Für Merkmalsklassen können Konstanten als Funktionen dargestellt werden. Denken Sie daran: numeric_limits :: max (). Mit constexpr können diese Arten von Funktionen in der Metaprogrammierung oder als Array-Grenzen usw. usw. verwendet werden.

Ein weiteres Beispiel wäre, dass Sie für Klassenschnittstellen möglicherweise möchten, dass abgeleitete Typen für einige Operationen ihre eigenen Konstanten definieren.

Bearbeiten:

Nach Stossen auf SO herum, sieht es aus wie andere kommen mit haben einige Beispiele von dem, was mit constexprs möglich sein könnte.

Aus Stroustrups Rede bei "Going Native 2012":

template<int M, int K, int S> struct Unit { // a unit in the MKS system
       enum { m=M, kg=K, s=S };
};

template<typename Unit> // a magnitude with a unit 
struct Value {
       double val;   // the magnitude 
       explicit Value(double d) : val(d) {} // construct a Value from a double 
};

using Speed = Value<Unit<1,0,-1>>;  // meters/second type
using Acceleration = Value<Unit<1,0,-2>>;  // meters/second/second type
using Second = Unit<0,0,1>;  // unit: sec
using Second2 = Unit<0,0,2>; // unit: second*second 

constexpr Value<Second> operator"" s(long double d)
   // a f-p literal suffixed by ‘s’
{
  return Value<Second> (d);  
}   

constexpr Value<Second2> operator"" s2(long double d)
  // a f-p literal  suffixed by ‘s2’ 
{
  return Value<Second2> (d); 
}

Speed sp1 = 100m/9.8s; // very fast for a human 
Speed sp2 = 100m/9.8s2; // error (m/s2 is acceleration)  
Speed sp3 = 100/9.8s; // error (speed is m/s and 100 has no unit) 
Acceleration acc = sp1/0.5s; // too fast for a human

Eine andere Verwendung (noch nicht erwähnt) sind constexprKonstruktoren. Auf diese Weise können Konstanten für die Kompilierungszeit erstellt werden, die zur Laufzeit nicht initialisiert werden müssen.

const std::complex<double> meaning_of_imagination(0, 42); 

Wenn Sie dies mit benutzerdefinierten Literalen kombinieren, haben Sie volle Unterstützung für benutzerdefinierte Literalklassen.

3.14D + 42_i;

Früher gab es ein Muster mit Metaprogrammierung:

template<unsigned T>
struct Fact {
    enum Enum {
        VALUE = Fact<T-1>*T;
    };
};

template<>
struct Fact<1u> {
    enum Enum {
        VALUE = 1;
    };
};

// Fact<10>::VALUE is known be a compile-time constant

Ich glaube, es constexprwurde eingeführt, damit Sie solche Konstrukte schreiben können, ohne Vorlagen und seltsame Konstrukte mit Spezialisierung, SFINAE und anderen Dingen zu benötigen - aber genau so, als würden Sie eine Laufzeitfunktion schreiben, aber mit der Garantie, dass das Ergebnis beim Kompilieren ermittelt wird -Zeit.

Beachten Sie jedoch Folgendes:

int fact(unsigned n) {
    if (n==1) return 1;
    return fact(n-1)*n;
}

int main() {
    return fact(10);
}

Kompilieren Sie dies mit g++ -O3und Sie werden sehen, dass dies fact(10)tatsächlich zur Kompilierungszeit ausgewertet wird!

Ein VLA-fähiger Compiler (also ein C-Compiler im C99-Modus oder ein C ++ - Compiler mit C99-Erweiterungen) kann Ihnen sogar Folgendes ermöglichen:

int main() {
    int tab[fact(10)];
    int tab2[std::max(20,30)];
}

Aber dass es sich im Moment nicht um Standard-C ++ handelt, constexprscheint eine Möglichkeit zu sein, dies zu bekämpfen (im obigen Fall auch ohne VLA). Und es gibt immer noch das Problem, dass "formale" konstante Ausdrücke als Vorlagenargumente erforderlich sind.

Ich habe gerade angefangen, ein Projekt auf c ++ 11 umzustellen, und bin auf eine vollkommen gute Situation für constexpr gestoßen, die alternative Methoden zur Ausführung derselben Operation bereinigt. Der entscheidende Punkt hierbei ist, dass Sie die Funktion nur dann in die Arraygrößendeklaration einfügen können, wenn sie als constexpr deklariert ist. Es gibt eine Reihe von Situationen, in denen ich sehe, dass dies in Bezug auf den Codebereich, an dem ich beteiligt bin, sehr nützlich ist.

constexpr size_t GetMaxIPV4StringLength()
{
    return ( sizeof( "255.255.255.255" ) );
}

void SomeIPFunction()
{
    char szIPAddress[ GetMaxIPV4StringLength() ];
    SomeIPGetFunction( szIPAddress );
}

Alle anderen Antworten sind großartig. Ich möchte nur ein cooles Beispiel für eine Sache geben, die Sie mit constexpr machen können, die erstaunlich ist. See-Phit ( https://github.com/rep-movsd/see-phit/blob/master/seephit.h ) ist eine HTML -Parser- und Vorlagen-Engine zur Kompilierungszeit. Dies bedeutet, dass Sie HTML einfügen und einen Baum herausholen können, der bearbeitet werden kann. Wenn Sie das Parsen zur Kompilierungszeit durchführen, erhalten Sie zusätzliche Leistung.

Aus dem Beispiel der Github-Seite:

#include <iostream>
#include "seephit.h"
using namespace std;



int main()
{
  constexpr auto parser =
    R"*(
    <span >
    <p  color="red" height='10' >{{name}} is a {{profession}} in {{city}}</p  >
    </span>
    )*"_html;

  spt::tree spt_tree(parser);

  spt::template_dict dct;
  dct["name"] = "Mary";
  dct["profession"] = "doctor";
  dct["city"] = "London";

  spt_tree.root.render(cerr, dct);
  cerr << endl;

  dct["city"] = "New York";
  dct["name"] = "John";
  dct["profession"] = "janitor";

  spt_tree.root.render(cerr, dct);
  cerr << endl;
}

Ihr grundlegendes Beispiel dient demselben Argument wie das der Konstanten selbst. Warum verwenden

static const int x = 5;
int arr[x];

Über

int arr[5];

Weil es viel wartbarer ist. Die Verwendung von constexpr ist viel, viel schneller zu schreiben und zu lesen als die vorhandenen Metaprogrammiertechniken.

Es kann einige neue Optimierungen ermöglichen. constTraditionell ist ein Hinweis für das Typsystem, und nicht für die Optimierung verwendet werden kann (zB ein constMember - Funktion kann const_castund das Objekt ohnehin ändern, rechtlich, so constkann nicht für die Optimierung vertraut werden).

constexprbedeutet, dass der Ausdruck wirklich konstant ist, vorausgesetzt, die Eingaben für die Funktion sind const. Erwägen:

class MyInterface {
public:
    int GetNumber() const = 0;
};

Wenn dies in einem anderen Modul verfügbar gemacht wird, kann der Compiler nicht darauf vertrauen, dass GetNumber()bei jedem Aufruf keine anderen Werte zurückgegeben werden - auch nicht nacheinander ohne dazwischen liegende Nicht-Konstanten-Aufrufe -, da constdies in der Implementierung möglicherweise verworfen wurde. (Natürlich sollte jeder Programmierer, der dies getan hat, erschossen werden, aber die Sprache erlaubt es, daher muss der Compiler die Regeln einhalten.)

Hinzufügen constexpr:

class MyInterface {
public:
    constexpr int GetNumber() const = 0;
};

Der Compiler kann jetzt eine Optimierung anwenden, bei der der Rückgabewert von GetNumber()zwischengespeichert wird, und zusätzliche Aufrufe von eliminieren GetNumber(), da dies constexpreine stärkere Garantie dafür ist, dass sich der Rückgabewert nicht ändert.

Wann zu verwenden constexpr:

1. wann immer es eine Kompilierungszeitkonstante gibt.

Es ist nützlich für so etwas

// constants:
const int MeaningOfLife = 42;

// constexpr-function:
constexpr int MeaningOfLife () { return 42; }

int some_arr[MeaningOfLife()];

Binden Sie dies mit einer Merkmalsklasse oder ähnlichem zusammen und es wird ziemlich nützlich.