Les fonctions membres sont-elles disponibles pendant la compilation en C ++?

https://godbolt.org/z/P2fcfK

main:
        mov     eax, 110
        ret

/ edit C'est le code que vous avez posté ....

#include <iostream>

struct Dave 
{
  const int a;

  constexpr Dave(const int b) : a(b) {}

  constexpr int var() const {
    return 5 * a;
  }
};

int main()
{
    constexpr int c = Dave(22).var();
    return c;
}

\ edit2 C'est l'expression la plus simple possible qui peut être évaluée au moment de la compilation:

constexpr int var(const int a) {
  return 5 * a;
}

constexpr int foo = var(22); //< will be evaluated at compile time. 

C'est une expression légèrement plus intéressante

constexpr int var(const int a) {
  constexpr int id = 5 * a; //< invalid! a is not constexpr!
  return id;
}

Dans ce cas, l'expression peut être évaluée au moment de la compilation. Voici un exemple de quelque chose qui ne peut être évalué au moment de la compilation:

int var(int a) {
  constexpr int id = 5 * a; //< invalid! a is not constexpr!
  return id;
}

getId () ne peut pas être constexpr ici, car nous devons le déclarer comme constexpr, cependant une approche naïve échouera:

constexpr int id = 5 * 5 + 22 / 11 - 9 * 65;

Elle échoue car nous utilisons la variable 'a' dans une seconde expression. Cependant, cela fonctionnera (nous avons supprimé la deuxième expression et l'avons repliée en une seule expression)

constexpr int id = 5;

Nous pouvons maintenant le faire avec des variables membres et un ctor, mais nous devons nous assurer que le ctor est constexpr. Par exemple:

#include <iostream>

class test{
 public:
 int getId(){ //< this method is NOT constexpr
   constexpr int id = 5; //< id is constexpr, and it's the only constexpr here.
   return id;
 }
};

int main(){
 test t; //< this cannot be constexpr because it's a variable
         //< (which means it is NOT an expression!)
 std::cout << t.getId() << std::endl;
 return 0;
}

Regardons maintenant godbolt: https: //godbolt.org/z/4naDY3 Nous pouvons voir que le code pour main se résume à:

#include <iostream>

class test{
 public:
 constexpr int getId(){
   constexpr int id = 5;
   return id;
 }
};

int main()
{
    constexpr int G = test().getId();
    std::cout << G << std::endl;
    return 0;
}

Il a donc évalué au moment de la compilation 5 * 22, soit 110. Vous n'aimerez peut-être pas la façon dont constexpr les règles fonctionnent (elles sont un peu maladroites), mais constexpr fonctionne.

La source de votre confusion est probablement de penser à " constexpr " comme "évalué à la compilation". Bien qu'il y ait du vrai dans cette idée, elle est imprécise. Je vous invite à abandonner votre compréhension actuelle de " constexpr ". À la place, commencez à considérer " constexpr " comme " autorisé dans expressions constantes ". Le langage fournit une définition précise de «expression constante»; pour les besoins actuels, il peut suffire de considérer une expression constante comme une expression dont la valeur peut être calculée par le compilateur. (Si le compilateur calcule cette valeur, il devra évaluer quelque chose au moment de la compilation. Cela conduit à cette notion imprécise de constexpr.)

En adaptant votre réflexion à cette nouvelle vue, concentrez-vous sur le mot «autorisé». Une personne titulaire d'un permis de conduire est autorisée à conduire une voiture, mais il n'est pas interdit de faire du vélo. Une variable avec le spécificateur constexpr est autorisée dans les expressions constantes mais n'est pas interdite à partir d'autres expressions.

<₹Avertissement : Lorsqu'il s'agit spécifiquement de variables entières, le spécificateur constexpr syntaxiquement ne signifie pas beaucoup plus que const . Si une variable entière est à la fois déclarée const et initialisée par une expression constante, alors cette variable reçoit le même privilège qu'une constexpr - elle est autorisée dans les expressions constantes. Il s'agit d'un cas spécial limité qui prend en charge le code pré-C ++ 11. Pour exprimer clairement l'intention (sémantique) dans un nouveau code, toute variable utilisée dans une expression constante doit être constexpr même si la syntaxe du langage lui permet d'être simplement const .

Pendant la compilation, test n'existe pas encore, cependant, le code ci-dessus se compile très bien.

Oui, le code sans erreur de syntaxe a tendance à se compiler très bien. ;)

Pour les variables, la seule limitation imposée par constexpr qui n'est pas imposée par const est que l'initialisation de la variable doit être une expression constante (c'est-à-dire que la valeur doit être quelque chose compilateur peut calculer). Vous l'avez satisfait en initialisant id à 5 plutôt qu'à une valeur déterminée au moment de l'exécution. Votre utilisation de id après l'initialisation est cohérente avec l'utilisation d'un const int , de sorte que l'utilisation est valide pour un constexpr int .

Si test n’existe pas encore, comment getId peut-il exister pendant la compilation?

Je suppose que cela dépend de ce que vous entendez par "exister". Dans un sens, une fonction existe à partir du moment où le compilateur génère son code objet. Ce code est incorporé dans l'exécutable final. Le code objet n'a pas besoin d'être construit pendant l'exécution (uniquement chargé à partir du disque), on pourrait donc dire que la fonction a commencé à exister avant l'exécution du programme. Il y a des mises en garde, mais l'idée générale est valable.

De la même manière, on pourrait dire que la classe test existe lors de la compilation, mais je suppose que vous vouliez dire que les instanciations (objets) de test n'existent pas encore .

Si vous aviez en tête une autre signification pour "exister", alors votre affirmation selon laquelle getId existe pendant la compilation est peut-être fausse. (En particulier, getId n'est pas exécuté lors de la compilation.)

[D'après un commentaire:] Que signifie le fait de dire que id est évalué au moment de la compilation?

Correction: id peut être évalué au moment de la compilation. Il peut également être évalué au moment de l'exécution. Ce qui se passe réellement dépend de la manière dont id est utilisé. Si vous ne donnez pas au compilateur de raison d'évaluer id , il n'est pas obligé de le faire.

[À partir d'un commentaire:] comment peut-il évaluer id pendant la compilation si getId (le parent) n'est évalué que pendant l'exécution .

Le seul endroit où id est utilisé dans votre code est dans une instruction return . Le compilateur est libre de remplacer return id; par return 5; lorsqu'il génère le code objet pour getId . (Ce n'est pas un exemple particulièrement intéressant, mais techniquement une évaluation de id au moment de la compilation. Un exemple plus intéressant utiliserait id dans un contexte qui nécessite une expression constante.)

Pendant la compilation, le test n'existe pas encore, cependant, le code ci-dessus se compile très bien. Si le test n'existe pas encore, comment getId peut-il exister pendant la compilation?

Et si je vous disais que ce code pourrait fonctionner même si l'objet test n'existait pas en temps réel? Je parie que ce programme vous imprimera 5:

 int getId(){
   enum { id = 5 };
   return id;
 }

 int getId(){
   #define id 5
   return id;
 }

Bien sûr, vous ne devriez jamais écrire de code comme celui-ci, mais cela peut vous aider à comprendre de ce qu'est réellement la fonction membre.

Vous pouvez considérer une fonction membre comme une fonction régulière avec un état d'objet (variables membres) qui lui est passé.

constexpr int id = 5;

Voir, un état d'objet n'est pas utilisé dans la fonction getId () . Donc, vous n'avez pas du tout besoin d'une instance d'objet test pour exécuter getId () .

En parlant de constexpr

class test{
 public:
};

int getId(test* obj){
  constexpr int id = 5;
  return id;
}

Ceci est juste une manière moderne d'écrire nommée constante ... Vous pouvez utiliser macro ou enum pour obtenir le même résultat, et vous n'avez pas besoin de C ++ 11 ou même C ++ (C suffit).

int main(){
 test* t = nullptr;
 std::cout << t->getId() << std::endl;
 return 0;
}

Donc, du point de vue du compilateur, getID () est juste une fonction qui renvoie 5 Cela signifie qu'il peut être remplacé par une constante entière équivalente 5. Donc, il insérera en fait 5 au lieu de l'appel getId () .