Fonction Modèle de surcharge Résolution et Optimisations du compilateur

Question

Je regardais cette question trouve ici Template function overload for type containing a type

Lorsque l'OP user2079802 fourni ce code pour son/sa question:

Je suis en train de faire ce qui suit :

#include <iostream> 
#include <vector> 
#include <tuple> 

template <typename T> 
void f(T t) { 
    std::cout << "1" << std::endl; 
} 

template <typename T, typename V> 
void f(T<std::tuple<V>> t) { 
    std::cout << "2" << std::endl; 
} 

int main() { 
    f(std::list<double>{}); // should use first template 
    f(std::vector<std::tuple<int>>{}); // should use second template 
} 

Quelle est la manière la plus simple de faire cela en C++ 14? Je pensais que je pourrais trier des motifs de cette façon, mais le compilateur ne l'aura pas.

Et songyuanyao fourni cette réponse:

Le paramètre modèle T est utilisé comme modèle nom, il devrait donc être déclarée comme template template parameter. par exemple.

template <template <typename...> class T, typename V> 
//  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
void f(T<std::tuple<V>> t) { 
    std::cout << "2" << std::endl; 
} 

LIVE

---

La réponse qui a été fournie a effectivement corriger les erreurs de compilation et le code ne fonctionne correctement. Je pose une question sur cet extrait de code pour plus de clarté. L'OP essayait à l'origine de modéliser les types de gabarit mais avait une syntaxe incorrecte pour les paramètres de gabarit de gabarit. Quand je courais la réponse dans mon IDE, compilateur & Debugger {MSVS 2017 CE} en cours d'exécution sur un 64bit Intel machine Windows 7 J'arrive de remarquer que, dans la fonction de l'OP appelle dans leur fonction principale:

f(std::list<double>{}); 
f(std::vector<std::tuple<int>>{}); 

Que l'appel de la 2ème fonction appelle en fait le 1er modèle de fonction et non le 2ème. Cela soulève quelques questions:

• Est-ce que cela se produit en raison des optimisations du compilateur?
• Est-ce le résultat d'une résolution de surcharge?
• Que se passe-t-il réellement sous le capot du compilateur quand choisit d'utiliser le premier modèle de fonction sur le 2ème?
• Ou est-ce un bug avec le compilateur MSVC?

Answer 1

Ce n'est pas un bogue dans le compilateur MSVC. C'est vraiment le résultat d'une ambiguïté dans la norme concernant les paramètres de template par défaut.

Vous voyez, std::vector a en réalité 2 arguments de modèle: le type et un allocateur.

Si vous refactorisons la réponse de cette question pour tenir compte de l'allocateur

template <typename T> 
void f(T t) { 
    std::cout << "1" << std::endl; 
} 

template <template <typename...> class T, typename V> 
void f(T<std::tuple<V>, std::allocator<std::tuple<V>>> t) { 
    std::cout << "2" << std::endl; 
} 

Il fonctionnera correctement dans tous les compilateurs: msvc demo, gcc demo, clang demo.

Here's the original defect report (CWG 150)

P0522R0 a la dernière discussion de Novembre 2016, où ils proposent que le type de modèle partiel correspondant vous faites référence dans la réponse de songyuanyao sera correcte selon la norme.

Les changements proposés dans P0522R0 sont incorporés dans la norme C++ 17 (le projet N4296 était celui que j'ai vérifié). Jusqu'à ce que la norme soit finalisée et MSVC prétend avoir le support complet de C++ 17, je ne l'appellerais pas un bogue dans le compilateur. Pour l'instant, ils reconnaissent que cette proposition spécifique n'a pas encore été incorporée dans leur compilateur à partir de VS 2017.3 [P2] (source)