const vs constexpr sur les variables

Est-il une différence entre les définitions suivantes?

const     double PI = 3.141592653589793;
constexpr double PI = 3.141592653589793;

Si non, le style est préféré à C++11?

Superset: stackoverflow.com/questions/14116003/...

InformationsquelleAutor fredoverflow | 2012-11-12

c++c++11 const constexpr variables

284

Je crois qu'il existe une différence. Nous allons renommer pour que nous puissions en parler plus facilement:
```
const     double PI1 = 3.141592653589793;
constexpr double PI2 = 3.141592653589793;
```
Les deux PI1 et PI2 sont constants, ce qui signifie que vous ne pouvez pas les modifier. Cependant seulement PI2 est une constante de compilation. Il est être initialisé au moment de la compilation. PI1 peut être initialisé au moment de la compilation ou de l'exécution. En outre, seulement PI2 peut être utilisé dans un contexte qui nécessite une constante de compilation. Par exemple:
```
constexpr double PI3 = PI1;  //error
```
mais:
```
constexpr double PI3 = PI2;  //ok
```
et:
```
static_assert(PI1 == 3.141592653589793, "");  //error
```
mais:
```
static_assert(PI2 == 3.141592653589793, "");  //ok
```
Que vous devez utiliser? Utilisez celui qui répond à vos besoins. Ne vous voulez vous assurer que vous avez un moment de la compilation constante qui peut être utilisé dans des contextes où une constante de compilation est nécessaire? Voulez-vous être en mesure de les initialiser avec un calcul fait au moment de l'exécution? Etc.
- Êtes-vous sûr? Parce que const int N = 10; char a[N]; œuvres, et les limites du tableau doivent être des constantes de compilation.
- J'en suis sûr, autant que les exemples que j'ai écrit go (testé chacun d'eux avant de poster). Cependant, mon compilateur ne permettez-moi de convertir PI1 à un moment de la compilation intégrale constante pour une utilisation dans un tableau, mais pas pour une utilisation en tant que non-type intégral paramètre du modèle. De sorte que le moment de la compilation de la convertibilité de PI1 à un type intégral semble un peu hit & miss pour moi.
- Les règles de lvalue-à-rvalue de conversion sont légèrement différents pour les intégrales et non intégrale types: (5.19(2)) a glvalue of integral or enumeration type that refers to a non-volatile const object with a preceding initialization, initialized with a constant expression vs a glvalue of literal type that refers to a non-volatile object defined with constexpr, or that refers to a sub-object of such an object. Ce n'est pas la même que la conversion implicite de int, qui a des règles différentes.
- Non-const tableau des indices ont "travaillé" pendant une dizaine d'années (il y a par exemple un g++ extension pour ça), mais cela ne signifie pas qu'il est strictement juridique C++ (même si certains plus récents en C ou C++ standard porté, j'ai oublié lequel). Comme pour les différences dans la compile-time constantes, paramètres du modèle et l'utiliser comme enum initialiseur sont les deux seules différences notables entre const et constexpr (et aucun ne fonctionne pour double de toute façon).
- Ils ne fonctionnent pas dans Clang bien. Cependant size_t const int N = 10; char a[N]; fonctionne en C++, mais pas dans C (où vous avez besoin de #define N 10).
- Le paragraphe 4 de l'5.19 expressions Constantes [expr.const] est aussi un (non normatif) à noter que le célèbre précise que l'application est autorisée à faire de l'arithmétique à virgule flottante différemment (par exemple, à l'égard de l'exactitude) au moment de la compilation que lors de l'exécution. Donc 1 / PI1 et 1 / PI2 peut donner des résultats différents. Je ne pense pas que cette technicité est tout aussi important que les conseils dans cette réponse, cependant.
- Mais il constexpr double PI3 = PI1; fonctionne correctement pour moi. (MSVS2013 CTP). Ce que je fais mal?
- Vous ne faites rien de mal. Sachez simplement que vous êtes en profitant d'un compilateur extension. Le code est sûr, mais pas portable. Sur le portage de toute différence sera trouvé au moment de la compilation, et non pas au moment de l'exécution.
- Va PI2 ont une mémoire d'exécution de l'adresse? Si oui, je me demande pourquoi, puisqu'en théorie, toutes les expressions constantes doivent être incorporé (pas besoin de garder une variable autour); surtout si cela est fait par le compilateur. L'objet final code ne devrait avoir aucune connaissance de cette variable.
- PI2 va avoir une liaison interne, signifie qu'elle va être locale à une unité de traduction. Il sera théoriquement disposer d'une adresse. Toutefois, si cette adresse n'est jamais utilisé, il ne doit pas exister. Si PI2 est jamais passé par référence, le compilateur besoin de le stocker quelque part pour la référence à consulter (à moins que cette fonction est incorporé et que le compilateur est capable d'optimiser loin de référence).
- Une note pour toute personne confondue par constexpr double PI3 = PI1; // error - L'erreur du compilateur est spécifique. Par exemple, certains compilateurs allez voir que PI1 lui-même est un littéral, et donc de résoudre ce qui est légal. D'autres, en raison de la nature de const, de ne pas effectuer cette vérification, car il peut ou peut ne pas être un littéral.
- je ne reçois pas toutes les erreurs sur constexpr double PI3 = PI1; une idée?
- Probablement juste un bug du compilateur. Ici est un bon endroit pour expérimenter avec différents compilateurs: melpon.org/wandbox/permlink/4blONXNuKtzFkpMO
- Je vous remercie pour votre réponse utile! Eu un problème avec static_assert, maintenant tout est clair pour moi. Je me demande pourquoi il est tapé avec erreur dans Straustup livre...(C++ 4e édition)
- J'ai peut-être tort, mais ne peut pas le compilateur de choisir pour faire une variable d'un constexpr sur son propre dans certains contextes? Ainsi, par exemple, lorsque vous avez un const littéral comme ça, il peut sans doute décider, il est sûr de faire un constexpr, par conséquent, vous permettant de l'utiliser pour la taille de la matrice, static_assert, constexpr PI3 = PI1;, les paramètres de modèle, etc...
- c'est peut-être évident: mais qu'en prenant les références de ces PIs (pun intended)? devrait être possible de PI1 impossible de PI2
InformationsquelleAutor Howard Hinnant
69

Pas de différence ici, mais il est important quand vous avez un type qui a un constructeur.
```
struct S {
    constexpr S(int);
};

const S s0(0);
constexpr S s1(1);
```
s0 est une constante, mais il ne promet pas d'être initialisé au moment de la compilation. s1 est marqué constexpr, donc c'est une constante, et, parce que Ss'constructeur est également marquée constexpr, il sera initialisé au moment de la compilation.

Surtout, ce qui importe lors de l'initialisation au moment de l'exécution prendrait du temps et que vous voulez pousser ce travail sur le compilateur, où il est aussi beaucoup de temps, mais ne ralentit pas le temps d'exécution du programme compilé
- Je suis d'accord: je suis arrivé à la conclusion était que constexpr conduirait à un diagnostic doit le compiler en temps de calcul de l'objet est impossible. Ce qui est moins clair, c'est de savoir si une fonction attendre un paramètre constant pourrait être exécuté au moment de la compilation si le paramètre être déclaré comme const et non pas comme constexpr: c'est à dire, serait constexpr int foo(S) être exécuté au moment de la compilation si je l'appelle foo(s0) ?
- Je doute que foo(s0) sera exécuté au moment de la compilation, mais on ne sait jamais: un compilateur est autorisé à faire de telles optimisations. Certes, ni la gcc 4.7.2 ni clang 3.2 permettez-moi de compiler constexpr a = foo(s0);
InformationsquelleAutor Pete Becker
37

constexpr indique une valeur constante et connue lors de la compilation.

const indique une valeur qui n'est constant; il n'est pas obligatoire de savoir lors de la compilation.
```
int sz;
constexpr auto arraySize1 = sz;    //error! sz's value unknown at compilation
std::array<int, sz> data1;         //error! same problem

constexpr auto arraySize2 = 10;    //fine, 10 is a compile-time constant
std::array<int, arraySize2> data2; //fine, arraySize2 is constexpr
```
Noter que const n'offre pas les mêmes garanties que constexpr, car const
les objets n'ont pas besoin d'être initialisé avec les valeurs connues lors de la compilation.
```
int sz;
const auto arraySize = sz;       //fine, arraySize is const copy of sz
std::array<int, arraySize> data; //error! arraySize's value unknown at compilation
```
Tous constexpr objets sont const, mais pas tous les objets const sont constexpr.

Si vous voulez compilateurs pour garantir qu'une variable a une valeur qui peut être
utilisé dans des contextes nécessitant des constantes de compilation, l'outil pour constexpr, non const.
- J'ai bien aimé ton explication beaucoup..pouvez-vous nous dire plus sur l'endroit Où sont les cas que nous avons peut-être besoin d'utiliser la compilation des constantes de temps dans des scénarios de vie réelle.
- Il suffit de Google C++ pourquoi constexpr, par exemple stackoverflow.com/questions/4748083/...
InformationsquelleAutor Ajay yadav
13

Un constexpr constante symbolique doit être donné une valeur qui est connu au moment de la compilation.
Par exemple:
```
constexpr int max = 100; 
void use(int n)
{
    constexpr int c1 = max+7; //OK: c1 is 107
    constexpr int c2 = n+7;   //Error: we don’t know the value of c2
    //...
}
```
Pour gérer les cas où la valeur d'une “variable” qui est initialisé avec une valeur qui n'est pas connu au moment de la compilation, mais ne change pas après l'initialisation,
C++ offre une seconde forme de constante (une const).
Par Exemple:
```
constexpr int max = 100; 
void use(int n)
{
    constexpr int c1 = max+7; //OK: c1 is 107
    const int c2 = n+7; //OK, but don’t try to change the value of c2
    //...
    c2 = 7; //error: c2 is a const
}
```
Ces “const variables” sont très courantes pour deux raisons:
1. C++98 n'ont pas constexpr, afin que les gens utilisés const.
2. Élément de la liste des “Variables” qui ne sont pas des expressions constantes (leur valeur n'est pas connue au moment de la compilation), mais ne modifiez pas les valeurs après
  l'initialisation sont en eux-mêmes largement utile.
La référence : "de la Programmation: Principes et Pratique avec C++" par Stroustrup
- Peut-être vous devriez avoir indiqué que le texte dans votre réponse est tiré mot à mot de "Programmation: Principes et Pratique avec C++" par Stroustrup
InformationsquelleAutor Jnana

Vous devez vous connecter pour publier un commentaire.