template <typename T>
void f(const T& param){
    std::cout<< typeid(T).name()<<'\n';
    std::cout<<typeid(param).name()<<'\n';
    }


    std::vector<Widget> createVec();

    const auto vw = createVect();
 
  
    if(!vw.empty())
    {

    f(&vw[0]);
 
    }

-
Edité par pseudo-simple 10 novembre 2018 à 22:44:08

Tu as un erreur de base qui fausse ton raisonnement:

YES, man a écrit:

  - notamment &vw[0] est un pointeur sur un élément de type Widget*

tel que tu as écrit, ça revient a dire que vw est un tableau de la forme

std::vector<Widget*> vw;

or ce n'est pas le cas: &vw[0] est un l'addresse d'un élèment de type Widget (et non Widget*) dit autrement, &vw[0] est de type Widget*

Partant de là, T est de type Widget* donc param est de type const Widget* & (ou Widget* const & pour pas t'embrouiller)

(sinon à un moment tu parles de "expr", perso je en vois pas de quoi il s'agit)

-
Edité par eugchriss 10 novembre 2018 à 21:20:36

Oui, sur ce passage, je me suis un peu emmêlé les pinceaux. Je corrige maintenant.

POur l'instant, je te suis.

Par contre, c'est après que ça me pose problème.

Ici, expr, c'est &vw[0] justement.

J'espère que çe peut t'aider à en déduire le const Widget * const &

> , j'aurais envie de dire que formellement const Widget * = const T& donc T = Widget*& > De plus avec un tel T , on obtient paramType = const Widget *&&

La conclusion est mauvaise, on obtient const Widget *& & (l'espace est important) ce qui donne une référence. Remplace les symboles par des mots et ajoute des parenthèses, tu y verras plus clair.

> notamment &vw[0] est l'adresse d' un élément de type const Widget, soit un const widget*.

vw n'est pas constant, alors l'élément ne l'est pas non plus.

-
Edité par jo_link_noir 10 novembre 2018 à 21:54:29

 @joe_link_noir : avec cette ligne :

const auto vw = createVect();

si vw n'est pas const, comment peut-il être déclaré const alors ?

Apparemment, vw prend le résultat d'une rvalue ( l'objet temporaire createVect() ). L'objet createVect() est détruit  lors du passage à l'intruction suivante ? N'est-ce pas ?

-
Edité par pseudo-simple 10 novembre 2018 à 22:11:24

je parle de la ligne 9, j'ai même pas fait gaffe à la 7.

> L'objet createVect() est détruit lors du passage à l'intruction suivante ? N'est-ce pas ?

Oui et alors ? Après il y a des optimisations derrière qui font qu'il n'y a pas de temporaire dans cette expression (obligatoire en c++17).

J'ai réagencé un peu le code :

donc avec la ligne 10, vw est un const std::vector<Widget> ?

Si oui, je reprends proprement mon raisonnement  formellement :

&vw[0] est l'adresse d'un élément de type const Widget, donc c'est const Widget*.

Maintenant, ce "expr" pour remployer la terminologie de Scott Meyers est transmis à la fonction template f.

Il faut déterminer T et paramType. Et on est dans le cas 1 :

&vw[0] n'étant pas une référence, on doit identifier les motifs  const T& =const Widget*

Si je "simplifie", il reste : T& = Widget*

Donc T = Widget* "divisé par" &  (ça d'ailleurs, je ne sais pas comment l'exprimer formellement sans garder le "divisé par")

Donc paramType = const Widget*

Ce qui n'est pas le const Widget * const& attendu

-
Edité par pseudo-simple 10 novembre 2018 à 23:08:00

https://zestedesavoir.com/forums/sujet/3216/c-auto-et-decltype/?page=2#p140845