Bonsoir OC , d'avance merci de me parler correctement, car je rappelle que quand je publie une question, c'est après mûre réflexion :
J'ai réussi à installer Clang aujourd'hui sur codeblocks.
Je m'approche de clang car c'est un élément important en C++.
Pourquoi ?
Afin de compiler avec différents compilateurs, comme avec GNU GCC et avec MSYS2 LLCM Clang Compiler et tester le comportement du code sur plusieurs compilateurs différents.
Au début du conseil 4 page 30, paragraphe appelé "éditeurs de code", l'honorable Scott Meyers donne le morceau de code suivant :
const int theAnswer=42;
auto x=theAnswer;
auto y=&theAnswer;
Il dit que :
"Un éditeur de code indiquera probablement que le type déduit pour x est int, et que le type déduit pour y est const int* "
Voici mon raisonnement qui aboutit à une réponse différente pour y d'où les questions qui suivront :
theAnswer est une lvalue de type const int.
La déduction de type auto s'applique pour déterminer ce qu'est x :
avant tout , x est une lvalue.
De plus comme theAnswer est un const int, selon la page 19,
le compilateur fait comme s'il existait un template pour cette déclaration ainsi qu'un appel à ce template avec l'expression d'initialisation appropriée :
ici
template <typename int>
void func_for_x (const int param)
Or toujours d'après la page 19,
"lorsqu'une variable est déclarée avec auto, ce mot-clé tient le rôle de T dans le template, et le spécificateur de type de la variable , celui de paramType" :
Ainsi ici T = int.
OK pour moi
Maintenant pour y :
&theAnswer est formellement l'adresse d'un int const
On applique donc le troisième conceptuel de la page 19 , on devrait encore obtenir que T = int
Donc pourquoi dit-il que l'éditeur, dira que y est un const int* si l'on passe la souris dessus (De plus, j'ai testé vous MSVC , et effectivement, MSVC me donne const int*, mais pas clang sous codeblocks)
Je souhaite comprendre comment appliquer ce raisonnement formellement pour dire que y est de type const int*.
MERCI
"Programmez efficacement en C++, de Scott Meyers (Dunod). Copyright 2016 Dunod pour la version française 978-2-10-074391-9, et 2015 Scott Meyers pour la versio d'origine 978-1-491-90399-5"
- Edité par pseudo-simple 8 novembre 2018 à 3:09:06
Ok, j'ai bien réfléchi, et avec ton lien gbdivers, j'en déduis que lorsque l'on passe la souris au dessus d'une variable dans l'éditeur de code, cela donne non pas ce qui est contenu dans auto, mais ce qui est contenu dans le spécificateur de type de variable paramType (qui contient plus d'informations que le type contenu dans auto).
const int theAnswer=42;
auto x=theAnswer;
auto y=&theAnswer;
&theAnswer est formellement une référence rvalue
La où tu te trompes, &theAnwser n'est pas une référence mais l'adresse de la constante theAnswer. A partir de la, y est donc au minimum un pointeur vers un entier.
Quand a savoir si y est constant ou non, je laisse la main aux spécialistes.
auto seul ne déduit jamais la référence, ni la constante, ni volatile. Ce sont les mêmes règles que pour foo(T) avec T template: les qualificateurs et les références doivent être explicites. Et comme avec les template, auto&& est une forward reference.
decltype(auto) correspond au type exact de l'expression d'initialisation. Les règles sont similaires au passage de paramètre par référence universelle (ou auto&&) à la différence qu'une prvalue sera déduite comme un type plein (=sans référence).
Un truc que je ne comprends, c'est pourquoi vouloir des règles différentes avec un pointeur ? Un pointeur est un type, pourquoi disparaît-il mystérieusement dans l'équation ?
PS : pour dire que T est const int, je me réfère à la page 13, fin du cas 1
Je suis désolé de me répéter encore et encore, mais tu montres encore une fois que tu as lu sans comprendre. Dans cet exemple, c'est le cas 3 qui s'applique, pas le cas 1.
Je t'avais donné un lien sans te dire exactement ce qu'il fallait rechercher et tu disais y avoir réfléchi, mais je pense que tu n'as pas compris non plus. Le point important dans le lien, c'est la signature de l'opérateur address-of :
R* operator&(T a);
Est-ce que tu fais la différence entre l'operateur address-of et une référence d'ailleurs ?
Ce qui veut dire que le type de l'expression à droite de l'affectation est const int*. Et donc que tu confonds le cas 1 et 3 :
// cas 1
template<typename T>
void f(T* param);
int x = 27;
f(&x);
// cas 3
template<typename T>
void f(T param);
int x = 27;
f(&x);
Il est normal que tu comprennes pas, je te l'ai déjà dit que ce livre est trop dur pour toi. Tu es arrivé au conseil 3, mais tu n'as pas compris correctement le conseil 1.
Je te réponds par "non", parce qu'il n'est plus question que tu utilises le forum comme un cours, juste parce que tu ne veux pas admettre que le cours OC n'est pas correct. Prends un vrai cours.
Le forum n'est pas un cours pour moi. La preuve, j'ai acheté le livre de Scott Meyers, après avoir terminé le cours de OC de C++
Tes jugements superflues, qui sont à côté de la plaque, tu les gardes les pour toi. Arrête d'être agressif comme cela à chaque fois que tu viens en aide. ça commence à être angoissant. Je pose mes questions car j'ai besoin d'aide. Tu veux aider ? Tu aides. Tu ne veux pas aider ? Tu n'aides pas. Mais arrête de harceler avec cette négativité.
Que les choses soient bien claires gbdivers, je n'abandonnerai jamais. Donc arrête de me dénigrer et de revenir à chaque fois au cours de OC comme prétexte (c'est hors de propos, j'ai terminé avec ce cours et il m'a appris énormément de choses). Maintenant, je suis passé au niveau supérieur et je suis conscient des points que j'ai à combler.
Donc, de grâce, arrête de dénigrer, car tu tombes dans la harcèlement.
- Edité par pseudo-simple 8 novembre 2018 à 10:18:36
Effectivement, si je comprends bien ce qu'il se passe finalement T et paramType sont tous les deux : const int*
Démonstration :
Effectivement, c'est le cas 3
Voici ma compréhension pour prouver que j'ai compris :
le spécificateur de type de variable est : auto (dans le cas de y)
Il joue le rôle de paramType.
Ce n'est ni un pointeur, ni une référence.
Donc on est dans le cas 3.
Il est appelé à partir de expr qui est un const int* (en raison de l'opérateur adress-of) &theAnswwer.
Le type de expr n'est pas une référence, et il n'a pas de partie const à supprimer (puisque ce sont les bits composant le pointeur qui sont passés par valeur et pas le const int lui-même).
Donc T = const int* et paramType = T = const int*
- Edité par pseudo-simple 8 novembre 2018 à 11:25:44
Tu te poses beaucoup de questions sur des détails haut niveau assez sordides, alors que l'on doute sérieusement de ton niveau actuel.
Franchement, ce genre de détail, ok, je sais que ca existe (même si je n'en ai pas compris toute l'essence), en ai-je besoin tous les jours ? Non. Je me pencherai dessus quand le cas se présentera.
Je t'invite à faire pareil, car ce n'est pas en avalant tous des bouquins top lvl que tu progressera, la pratique et l'expérience sont de bien meilleur formateurs.
Conseil 4, déduction du type avec éditeur de code
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Discord NaN. Mon site.
Discord NaN. Mon site.
Discord NaN. Mon site.
Discord NaN. Mon site.
Discord NaN. Mon site.