Quand faut-il utiliser la capacité constexpr en C++11 ?

Question

Il me semble que le fait d'avoir une "fonction qui renvoie toujours 5" rompt ou dilue le sens de l'expression "appeler une fonction". Il doit y avoir une raison, ou un besoin pour cette capacité, sinon elle ne serait pas dans C++11. Pourquoi est-elle là ?

// preprocessor.
#define MEANING_OF_LIFE 42

// constants:
const int MeaningOfLife = 42;

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

Il me semble que si j'écrivais une fonction qui renvoie une valeur littérale, et que je me présentais à une revue de code, quelqu'un me dirait que je devrais alors déclarer une valeur constante au lieu d'écrire return 5.

Answer 1

Supposons qu'il fasse quelque chose d'un peu plus compliqué.

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

const int meaningOfLife = MeaningOfLife( 6, 7 );

Vous avez maintenant quelque chose qui peut être évalué jusqu'à une constante tout en conservant une bonne lisibilité et en permettant un traitement légèrement plus complexe que la simple définition d'une constante à un nombre.

Il s'agit essentiellement d'une bonne aide à la maintenabilité, car ce que vous faites devient plus évident. Prenez max( a, b ) par exemple :

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

C'est un choix assez simple, mais cela signifie que si vous appelez max avec des valeurs constantes, il est explicitement calculé au moment de la compilation et non au moment de l'exécution.

Un autre bon exemple serait un DegreesToRadians fonction. Tout le monde trouve les degrés plus faciles à lire que les radians. Même si vous savez que 180 degrés correspondent à 3,14159265 (Pi) en radians, il est beaucoup plus clair de l'écrire comme suit :

const float oneeighty = DegreesToRadians( 180.0f );

Beaucoup de bonnes informations ici :

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

Answer 2

Prenez std::numeric_limits<T>::max() pour une raison quelconque, c'est une méthode. constexpr serait bénéfique ici.

Un autre exemple : vous voulez déclarer un tableau C (ou un fichier std::array ) qui est aussi grand qu'un autre tableau. Pour l'instant, la façon de procéder est la suivante :

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

Mais ne serait-ce pas mieux d'être capable d'écrire :

int y[size_of(x)];

Merci à constexpr vous pouvez :

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

Answer 3

constexpr Les fonctions sont vraiment intéressantes et constituent un excellent complément au C++. Cependant, vous avez raison de dire que la plupart des problèmes qu'elles résolvent peuvent être contournés de manière inélégante avec des macros.

Cependant, l'une des utilisations de constexpr n'a pas d'équivalent C++03, des constantes typées.

// 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;

Answer 4

D'après ce que j'ai lu, le besoin de constexpr provient d'un problème de métaprogrammation. Les classes de traits peuvent avoir des constantes représentées sous forme de fonctions, par exemple : numeric_limits::max(). Avec constexpr, ces types de fonctions peuvent être utilisés dans la métaprogrammation, ou comme limites de tableaux, etc. etc.

Un autre exemple qui me vient à l'esprit est que pour les interfaces de classe, vous pouvez souhaiter que les types dérivés définissent leurs propres constantes pour certaines opérations.

Edit :

Après avoir farfouillé sur SO, il semble que d'autres personnes aient proposé un peu de exemples de ce qui pourrait être possible avec constexprs.

Answer 5

Extrait du discours de Stroustrup à "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