Quand un constexpr fonction évaluée au moment de la compilation?

Car il est possible qu'une fonction déclarée comme constexpr peut être appelé au cours de l'exécution, en vertu de laquelle les critères retenus par le compilateur décider de le calculer au moment de la compilation ou au cours de l'exécution? 

template<typename base_t, typename expo_t>
constexpr base_t POW(base_t base, expo_t expo)
{
    return (expo != 0 )? base * POW(base, expo -1) : 1;
}

int main(int argc, char** argv)
{
    int i = 0;
    std::cin >> i;

    std::cout << POW(i, 2) << std::endl;
    return 0;
}

Dans ce cas, je n'est pas connu au moment de la compilation, ce qui est probablement la raison pour laquelle le compilateur traite POW() comme une fonction qui est appelée lors de l'exécution. Cette dynamique cependant, comme pratique, comme cela peut apparaître à, a quelques pas pratique implications. Par exemple, pourrait-il y avoir un cas où je voudrais le compilateur pour calculer une constexpr fonction lors de la compilation, le compilateur décide de la traiter comme une fonction normale au lieu de cela, quand il aurait travaillé au cours de la compilation-temps ainsi? Sont-ils connus et les pièges les plus courants?

  • Autant que je sache, lorsque tous les arguments sont des expressions constantes.
  • Et si j'écris POW((unsigned __int64)2, 63). Serait-ce encore le comte comme une expression constante?
  • En fait, c'est plus complexe que ça je pense. Je pense que constexpr ne doit être évaluée lorsque son résultat est utilisé comme un paramètre du modèle, tableau lié, ou d'autres partie intégrante de la constante. Tout autre temps est une optimisation. En fait, même quand l'expression constante arguments, il peut être nécessaire d'exécuter au moment de l'exécution. constexpr int func(int p) { return !p ? 1 : throw std::exception("HI");} doit être évalué au moment de l'exécution lorsque la non-zéro.
  • Les initialiseurs qui sont des expressions constantes font partie de la statique de la phase d'initialisation, par exemple constexpr int a = POW(5, 4);. C'est essentiellement calculée au moment de la compilation. Mais bien sûr, vous pouvez toujours utiliser POW dans d'autres endroits.
  • À moins que le résultat de la fonction est utilisée dans votre susmentionnés constante de l'expression "requirerers", alors il va donner une erreur de compilation à cause de l'exception.
  • J'ai couru hors de l'espace de commentaire, mais oui 😀
  • connexes: stackoverflow.com/questions/14294271/...

InformationsquelleAutor Byzantian | 2013-01-09
  1. 82

    constexpr fonctions sera être évaluée au moment de la compilation lorsque tous ses arguments sont des expressions constantes et le résultat est utilisé dans une expression constante ainsi. Une expression constante peut être un littéral (comme 42), un non-type de modèle argument (comme N dans template<class T, size_t N> class array;), un enum la déclaration de l'élément (comme Blue dans enum Color { Red, Blue, Green };, une autre variable déclarée constexpr, et ainsi de suite.

    Ils pourrait être évaluées lors de tous ses arguments sont des expressions constantes et le résultat est pas utilisé dans une expression constante, mais c'est jusqu'à la mise en œuvre.

    • Je suis en train de concevoir d'une manière générale, pour faire valoir le moment de la compilation de l'évaluation, de quelque chose comme STATIC_ASSERT_CONSTEXPR( pow(2,3) ), mais je ne suis pas avoir beaucoup de chance...
    • essayez d'utiliser le résultat comme un non-type de paramètre du modèle. cela devrait couvrir intégrale constexpr. pour float-vous besoin de quelque chose d'autre.
    • C'est le "autre chose" que je suis intrigué par...
    • "Un constexpr fonction est évaluée au moment de la compilation si tous ses arguments sont des expressions constantes" --Bjarne Stroustrup a dit on Jan 11, 2013 07:27 PM: isocpp.org/blog/2013/01/... ?
    • Où la Norme est-il une garantie que constexpr fonctions sont évaluées au moment de la compilation si tous les arguments sont des expressions constantes? Je crois que la seule chose que dit la Norme, c'est que constexpr fonctions peuvent être utilisées dans des contextes qui doivent être évalués au moment de la compilation, par exemple arguments de modèle. Autre chose est le compilateur de décider. C'est du moins ce que j'ai cru jusqu'à présent.
    • exactement ce que ma réponse dit. Vous pouvez vérifier l'ISO C++ le lien pour plus de débat sur le sujet.
    • Dire que j'ai un constexpr int f(); et de déclarer ensuite une expression constante constexpr int a = f();. Votre réponse suggère que a sera évaluée au moment de la compilation, car f est constexpr, tous ses arguments sont aussi, et le résultat est utilisé dans un constexpr. Mais je crois que c'est forcément true uniquement si a est utilisé dans un contexte qui exige au moment de la compilation d'évaluation, par exemple, un argument de modèle. Aussi, j'ai vu le lien, mais puisque c'est une SORTE de réponse, les faits pertinents, esp. Standard citations, faut le mettre ici.
    • Un constexpr variable est un expression constante, qui exige au moment de la compilation de l'évaluation. La norme citations sont non-normatif des notes; les exigences pour constexpr fonctions pour être évaluée au moment de la compilation sont implicitement tout au long de la norme à chaque fois que ça parle d'un expression constante.
    • Une expression constante ne nécessite pas de compilation de l'évaluation. 5.19/4: Remarque: Même si, dans certains contextes, des expressions constantes doivent être évalués lors de la traduction, d'autres peuvent être évalués au cours de l'exécution du programme
    • C'est une remarque, si ce n'est pas normatif... Revenir à votre exemple, a pourrait alors être utilisé comme un modèle d'argument ou d'un autre contexte qui exige au moment de la compilation de l'évaluation, qui je pense est implicite dans son évaluation afin d'être toujours effectué au moment de la compilation. Mais je comprends votre point, vous devriez demander à la ISO C++ post pour attirer l'attention de ceux qui sont impliqués dans la prise de cette fonctionnalité...
    • La note n'est pas normatif, mais si votre déclaration ci-dessus est vrai, la note serait carrément mal. En fait, Herb dit dans la norme ISO C++ post déjà que Bjarne doit ont dit: "Un constexpr la fonction peut être évaluée au moment de la compilation si tous ses arguments sont des expressions constantes". C'est un point très important. Le Standard laisse ouvert si la constante expression est évaluée au moment de la compilation. Et c'est pourquoi la question se pose: Que faire des compilateurs de faire réellement? Quel est le critère compilateurs utilisent réellement? J'aimerais savoir moi-même, trop...
    • Selon les deux Bjarne et d'Herbes de retour à la ISO C++ post, "La réponse correcte - comme l'a déclaré Herb - est que, selon la norme une constexpr fonction peut être évalué à compilateur temps ou de l'exécution, sauf s'il est utilisé comme une expression constante, auquel cas il doit être évalué au moment de la compilation.". Cela voudrait dire que a dans votre exemple, doit être évaluée au moment de la compilation, et de ne pas faire la remarque carrément mal. Je ne suis pas sûr que c'est effectivement garantie par la norme à ce point...
    • Franchement, ce que Bjarne dit dans cette déclaration n'est pas très utile. Il a implicitement introduit le nouveau concept de est utilisé comme expression constante (par opposition à: est une expression constante). Chaque expression marquée constexpr est une expression constante, mais c'est seulement garanti pour être évaluée au moment de la compilation si c'est utilisé en tant que une expression constante (par exemple, utilisé comme argument de modèle). Mais qu'est-ce que cela veut dire?
    • Je suis enclin à penser cela signifie que vous avez obtenu ce droit, et vous ne sont garantis au moment de la compilation de l'évaluation si l'expression constante est utilisée directement ou indirectement dans un contexte qui exige au moment de la compilation d'évaluation... Désolé je ne peux pas vous être d'une quelconque aide.
    • Pour votre "autre chose", pourquoi ne pas écrire un constexpr fonction qui accepte une valeur à virgule flottante (ou en fait n'importe quel type que vous voulez) et qui renvoie un entier, puis l'utiliser à l'intérieur d'un modèle non-type de paramètre. constexpr size_t check_nonintegral_constexpr(float v) { return sizeof v; } std::array<check_nonintegral_constexpr(pow(2.0, 4))> assertion;
    • "Et le résultat est utilisé dans une expression constante ainsi". J'ai eu du mal avec ça. Merci.

    InformationsquelleAutor K-ballo
  2. 19

    La fonction doit être évaluée au moment de la compilation quand une expression constante est nécessaire.

    La méthode la plus simple pour garantir cela est d'utiliser un constexpr valeur, ou std::integral_constant:

    constexpr auto result = POW(i, 2); //this should not compile since i is not a constant expression
std::cout << result << std::endl;

    ou:

    std::cout << std::integral_constant<int, POW(i, 2)>::value << std::endl;

    ou

    #define POW_C(base, power) (std::integral_constant<decltype(POW((base), (power)), POW((base), (power))>::value)

std::cout << POW_C(63, 2) << std::endl;

    ou

    template<int base, int power>
struct POW_C {
  static constexpr int value = POW(base, power);
};

std::cout << POW_C<2, 63>::value << std::endl;
    • Est-ce à dire que std::cout << POW(2, 63) << std::endl pourrait ne pas être évaluées lors de la compilation, depuis le cout ne nécessite pas une expression constante de la valeur?
    • Oui. En fait, vous devez supposer qu'il sera appelée au moment de l'exécution que c'est ce que les compilateurs semblent le faire.
    • Est-il un moyen de forcer le compilateur à évaluer lors de la compilation? De préférence dans une ligne. Un anonyme constexpr peut-être?
    • l'exemple de code que j'ai posté est ce qui fait que.
    • mais ensuite, j'ai fait des sacrifices de type indépendance
    • vous pouvez écrire une macro, je suppose. Bien que je préfère juste les deux de la ligne de constexpr auto méthode.
    • Et il n'y a vraiment pas d'un liner façon de faire cela? Comment sur l'imbrication de votre solution à l'intérieur d'un autre constexpr fonction? Je voudrais éviter les macros à chaque fois que possible.
    • Les arguments de constexpr fonctions ne sont pas des expressions constantes et donc ça ne l'aide pas.
    • Comment à ce sujet? Un anonyme lambda std::cout << *[](){static constexpr auto expr = POW(1.113, 11); return &expr;}() << std::endl;
    • Ne pas retourner un pointeur et au lieu de retourner une valeur. Cela devrait fonctionner.
    • Elle cesse d'être une expression constante elle-même de cette façon, si.
    • Pourquoi pas? Ne pas static fondamentalement signifie "l'endroit sur le segment de données"? Quel est le problème avec un pointeur car il ne peut pas disparaître? @GManNickG Mais la fonction sera évaluée au moment de la compilation dans tous les cas, correct?
    • À droite, juste le résultat de la lambda n'est pas une expression constante, donc il y a un "mur" il y en a de toutes sortes. Et retournant un pointeur, il n'a tout simplement pas de bon sens. Vous n'obtenez rien pour elle, sauf que maintenant vous avez à déréférencer tout le temps; il suffit de retourner la valeur directement.
    • Mais je suis un déréférencement juste avant l'lambda. *[]. J'ai fait cela pour s'assurer que l'instruction return n'est pas la copie de l'objet.
    • Vous devriez utiliser des références pour que. (Pas que de la copie d'un moment de la compilation de la valeur va coûter quoi que ce soit...)
    • Est-il un générique façon à envelopper un constexpr expressions de la force de la compilation. Par exemple. compile_time(POW(i,j))? J'aurais voulu que, pour être en temps de compilation, mais probablement oublié de déclarer i,j comme constexpr. Peut-on attraper ces erreurs au moment de la compilation ne pas avoir à écrire des wrappers pour chaque fonction?
    • Voici ce que j'ai trouvé, mais je ne suis pas sûr si c'est la meilleure solution possible. Je suis également pas sûr en cas de retour de référence rvalue effectivement travaille de cette façon. #define FORCE_CT_EVAL(func) [](){constexpr auto ___expr = func; return std::move(___expr);}()
    • qu'est ce qui empêche le compilateur à partir de l'appelant operator() de la lambda objet? C'est exactement ce que je vois avec gdb. Non seulement cela, operator() pourrait ne pas être constexpr lui-même et vous pourriez être en forçant au moment de l'exécution de l'évaluation.
    • Malheureusement, le modèle les bases de la syntaxe de trucs à vous montrer, ne pas travailler avec constexpr double fonctions. J'ai donc de définir un nom de constexr variable dans ce cas (votre première solution).

    InformationsquelleAutor Pubby