explication de code

Salut,
je suis tomber sur un code et je n’arrive absolument pas à comprendre comment il fait ce qu’il fait. Une âme charitable pourrait-elle m’expliquer ?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <functional>
#include <string>
#include <iostream>


struct Polly
{
  template<typename T, typename U>

    auto operator()(T t, U u) const -> decltype(t + u)

    { return t + u; }

};


int main()
{

  auto polly = std::bind(Polly(), std::placeholders::_1, "confusing");

  std::cout << polly(4) << polly(std::string(" this is ")) << std::endl;

}

la sortie étant using this is confusing
Le truc c’est que poly(4) ressort using càd : confusing moins les 4 première lettre
Mais si on reconstruit la méthode en mettant les bons types on a T = int et U = char*[] ou std::string je ne sais pas trop.

Mais int + string ou même int + char*[] et il n’existe pas d’opérateur + pour ces types. Donc ce ne doit pas être les bons types

Mes questions sont donc, quels sont les types de T et U lors de l’appel polly(4)
et pourquoi on a un substring de "confusing" lors d’une addition.

PS: Si vous avez des codes un peu tordu dans le style pour voir comment fonctionne le C++ en détails , je suis preneur

Ça fait longtemps que j’ai pas fait de c++.

En tout cas typeid peut peut-être t’aider. Ce code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <functional>
#include <string>
#include <iostream>


struct Polly
{
    template<typename T, typename U>

    auto operator()(T t, U u) const -> decltype(t + u)
    {
        std::cout << "T t: " << typeid(t).name() << std::endl;
        std::cout << "U u: " << typeid(u).name() << std::endl;
        return t + u;
    }

};


int main()
{

    auto polly = std::bind(Polly(), std::placeholders::_1, "confusing");

    std::cout << polly(4) << polly(std::string(" this is ")) << std::endl;

}

Donne ça

1
2
3
4
5
6

$ ./a.out
T t: NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
U u: PKc
T t: i
U u: PKc
using this is confusing

Par contre c’est effectivement dérangeant, comment ça se fait qu’on obtient ça ?

Si, il est possible d’additionner un entier et un pointeur, c’est ce qui se passe ici.

"confusing" + 4 décale le début de la chaîne de 4 octets et devient donc équivalent à "using".

(et je dirais que dans le cas présent, "confusing" est reçu comme un const char*)

Lu’!

Mouais je suis pas convaincu de la pertinence d’étudier du code que personne ne veut écrire pour comprendre un langage.

Mais sinon, l’explication d’@entwanne est correcte. Ici, deux spécialisations de l’opérateur sont créées, une qui fait un décalage de pointeur (char const* + int) et c’est celle qui est appelée avec polly(4) (en deuxième donc dans l’exécution de @LudoBike). Et une avec la concaténation de chaînes (std::string + char const*), appelée en premier.

Ouais mais sans ce code je ne saurais toujours pas que "foo" est typé char const*, qu’on peut déplacer le pointeur avec un entier, c’est un moyen de voir de nouvelle chose. C’est plus intéressant que lire 100 pages d’un bouquin et de les oublier juste après. Avec un exemple comme la, je m’en souviens. Enfin c’est vrai que lire du code pourri ne donne pas des bonnes habitudes mais pour le moment, je trouve intéressant de faire comme ça.

En tout cas merci à tous pour vos réponses rapides et complètes

Une méthode alternative pourrait consister à t’arrêter tous les 10/15 pages d’un bon bouquin pour pratiquer et écrire des exemples de code tel que le bouquin conseille de le faire .