Quand devez-vous utiliser la capacité constexpr en C ++ 11?

Il me semble qu'avoir une "fonction qui renvoie toujours 5" brise ou dilue le sens de "appeler une fonction". Il doit y avoir une raison, ou un besoin pour cette capacité, sinon ce ne serait pas en C ++ 11. Pourquoi est-il 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 retourne une valeur littérale et que j'arrivais à une révision de code, quelqu'un me dirait, je devrais alors, déclarer une valeur constante au lieu d'écrire return 5.

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é à une constante tout en conservant une bonne lisibilité et en permettant un traitement légèrement plus complexe que de simplement définir une constante sur un nombre.

Il fournit essentiellement une bonne aide à la maintenabilité car il devient plus évident de savoir ce que vous faites. Prenons 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 maxavec 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 une DegreesToRadiansfonction. Tout le monde trouve les degrés plus faciles à lire que les radians. Bien que vous sachiez que 180 degrés sont en radians, il est beaucoup plus clair comme suit:

const float oneeighty = DegreesToRadians( 180.0f );

Beaucoup de bonnes informations ici:

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

introduction

constexprn'a pas été présenté comme un moyen de dire à l'implémentation que quelque chose peut être évalué dans un contexte qui nécessite une expression constante ; les implémentations conformes ont pu le prouver avant C ++ 11.

Quelque chose qu'une implémentation ne peut pas prouver, c'est l' intention d'un certain morceau de code:

• Qu'est-ce que le développeur veut exprimer avec cette entité?
• Faut-il autoriser aveuglément le code à être utilisé dans une expression constante , simplement parce que cela fonctionne?

De quoi le monde serait-il privé constexpr?

Disons que vous développez une bibliothèque et réalisez que vous voulez pouvoir calculer la somme de chaque entier de l'intervalle (0,N].

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

Le manque d'intention

Un compilateur peut facilement prouver que la fonction ci-dessus peut être appelée dans une expression constante si l'argument passé est connu pendant la traduction; mais vous n'avez pas déclaré cela comme une intention - il se trouve que c'est le cas.

Maintenant, quelqu'un d'autre arrive, lit votre fonction, fait la même analyse que le compilateur; " Oh, cette fonction est utilisable dans une expression constante!" et écrit le code suivant.

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

L'optimisation

En tant que développeur de bibliothèque "génial" , vous décidez que fle résultat devrait être mis en cache lors de son appel; qui voudrait calculer le même ensemble de valeurs encore et encore?

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];
}

Le résultat

En introduisant votre optimisation idiote, vous venez de rompre chaque utilisation de votre fonction qui se trouvait dans un contexte où une expression constante était requise.

Vous n'avez jamais promis que la fonction était utilisable dans une expression constante , et sans quoi constexpril n'y aurait aucun moyen de fournir une telle promesse.

Alors, pourquoi avons-nous besoin constexpr?

L'utilisation principale de constexpr est de déclarer l' intention .

Si une entité n'est pas marquée comme constexpr- elle n'a jamais été destinée à être utilisée dans une expression constante ; et même si c'est le cas, nous comptons sur le compilateur pour diagnostiquer un tel contexte (car il ne tient pas compte de notre intention).

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

Un autre exemple: vous voulez déclarer un C-array (ou a std::array) qui est aussi grand qu'un autre tableau. La façon de procéder pour le moment est la suivante:

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

Mais ne serait-il pas préférable de pouvoir écrire:

int y[size_of(x)];

Grâce à constexpr, vous pouvez:

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

constexprles fonctions sont vraiment sympa et un excellent ajout à c ++. Cependant, vous avez raison en ce que la plupart des problèmes qu'il résout peuvent être contournés de manière non élégante avec les macros.

Cependant, l'une des utilisations de constexprn'a pas de constantes typées C ++ 03 équivalentes.

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

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 comme des fonctions, pensez: numeric_limits :: max (). Avec constexpr, ces types de fonctions peuvent être utilisés dans la métaprogrammation, ou comme limites de tableau, etc., etc.

Un autre exemple hors de ma tête serait que pour les interfaces de classe, vous voudrez peut-être que les types dérivés définissent leurs propres constantes pour certaines opérations.

Éditer:

Après farfouillé sur le SO, il semble que d' autres sont venus avec quelques exemples de ce qui pourrait être possible avec constexprs.

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

Une autre utilisation (non encore mentionnée) est celle des constexprconstructeurs. Cela permet de créer des constantes de temps de compilation qui n'ont pas besoin d'être initialisées pendant l'exécution.

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

Associez cela à des littéraux définis par l'utilisateur et vous avez une prise en charge complète des classes définies par l'utilisateur littérales.

3.14D + 42_i;

Il y avait un schéma avec la métaprogrammation:

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

Je crois qu'il a constexprété introduit pour vous permettre d'écrire de telles constructions sans avoir besoin de modèles et de constructions étranges avec spécialisation, SFINAE et d'autres choses - mais exactement comme vous écririez une fonction d'exécution, mais avec la garantie que le résultat sera déterminé lors de la compilation -temps.

Cependant, notez que:

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

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

Compilez ceci avec g++ -O3et vous verrez que cela fact(10)est en effet évalué au moment de la compilation!

Un compilateur compatible VLA (donc un compilateur C en mode C99 ou un compilateur C ++ avec des extensions C99) peut même vous permettre de faire:

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

Mais que ce soit du C ++ non standard pour le moment - constexprressemble à un moyen de lutter contre cela (même sans VLA, dans le cas ci-dessus). Et il y a toujours le problème de la nécessité d'avoir des expressions constantes "formelles" comme arguments de modèle.

Je viens de commencer à basculer un projet vers c ++ 11 et j'ai trouvé une situation parfaitement bonne pour constexpr qui nettoie les méthodes alternatives pour effectuer la même opération. Le point clé ici est que vous ne pouvez placer la fonction dans la déclaration de taille de tableau que lorsqu'elle est déclarée constexpr. Il y a un certain nombre de situations où je peux voir que cela est très utile pour aller de l'avant avec le domaine du code dans lequel je suis impliqué.

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

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

Toutes les autres réponses sont excellentes, je veux juste donner un exemple sympa d'une chose que vous pouvez faire avec constexpr qui est incroyable. See-Phit ( https://github.com/rep-movsd/see-phit/blob/master/seephit.h ) est un analyseur HTML et un moteur de modèle au moment de la compilation. Cela signifie que vous pouvez mettre du HTML et en sortir un arbre qui peut être manipulé. Faire l'analyse syntaxique au moment de la compilation peut vous donner un peu de performances supplémentaires.

À partir de l'exemple de page github:

#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;
}

Votre exemple de base sert le même argument que celui des constantes elles-mêmes. Pourquoi utiliser

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

plus de

int arr[5];

Parce que c'est beaucoup plus maintenable. L'utilisation de constexpr est beaucoup, beaucoup plus rapide à écrire et à lire que les techniques de métaprogrammation existantes.

Il peut permettre de nouvelles optimisations. constest traditionnellement un indice pour le système de type, et ne peut pas être utilisé pour l'optimisation (par exemple, une constfonction membre peut const_castet modifie l'objet de toute façon, légalement, donc constne peut pas faire confiance pour l'optimisation).

constexprsignifie que l'expression est vraiment constante, à condition que les entrées de la fonction soient const. Considérer:

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

Si cela est exposé dans un autre module, le compilateur ne peut pas faire confiance qui GetNumber()ne renverra pas de valeurs différentes à chaque appel - même consécutivement sans appels non const entre - parce queconst aurait pu être rejeté dans l'implémentation. (Évidemment, tout programmeur qui a fait cela devrait être abattu, mais le langage le permet, donc le compilateur doit respecter les règles.)

Ajout constexpr:

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

Le compilateur peut désormais appliquer une optimisation dans laquelle la valeur de retour de GetNumber()est mise en cache et éliminer les appels supplémentaires à GetNumber(), car constexprc'est une garantie plus forte que la valeur de retour ne changera pas.

Quand utiliser constexpr:

1. chaque fois qu'il y a une constante de temps de compilation.

C'est utile pour quelque chose comme

// constants:
const int MeaningOfLife = 42;

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

int some_arr[MeaningOfLife()];

Liez-le avec une classe de traits ou similaire et cela devient très utile.