Funktion Vorlage Überladungsauflösung mit einem Zeiger Argumente

Question

Der folgende Code zeigt den Kern eines C++ Metaprogrammierung Muster, das ich verwendet haben, um zu bestimmen, ob ein Typ T eine Instanz einer bestimmten Klasse Vorlage:

#include <iostream> 

template<class A, class B> 
struct S{}; 

template<class A, class B> 
constexpr bool isS(const S<A,B>*) {return true;} 

template<class T> 
constexpr bool isS(const T*) {return false;} 

int main() { 
    S<int,char> s; 
    std::cout<<isS(&s)<<std::endl; 
    return 0; 
} 

Es verfügt über zwei Überladungen einer constexpr Funktionsvorlage isS, und es gibt wie erwartet 1 aus. Wenn ich um den Zeiger von der zweiten isS entfernen, d.h. ersetzen sie durch

template<class T> 
constexpr bool isS(const T) {return false;} 

das Programm unerwartet 0 ausgibt. Wenn beide Versionen von isS bis zur Überladungsauflösungsphase der Kompilierung durchgehen, impliziert die Ausgabe, dass der Compiler die zweite Überladung auswählt. Ich habe dies unter GCC, Clang und VC++ mit den Online-Compiler here getestet, und sie alle produzieren das gleiche Ergebnis. Warum passiert das?

Ich habe Herb Sutter "Why Not Specialize Function Templates" Artikel mehrmals gelesen, und es scheint, dass beide isS Funktionen als Basisvorlagen betrachtet werden sollten. Wenn das so ist, dann ist es eine Frage, welche die am meisten spezialisierte ist. Geht man von Intuition und this answer, würde ich erwarten, dass die erste isS die am meisten spezialisierte sein, weil T jede Instantiierung von S<A,B>* übereinstimmen kann, und es gibt viele mögliche Instanziierungen von T, die S<A,B>* nicht übereinstimmen können. Ich möchte den Absatz in dem Arbeitsentwurf suchen, der dieses Verhalten definiert, aber ich bin nicht ganz sicher, welche Phase der Kompilierung das Problem verursacht. Hat es etwas damit zu tun? "14.8.2.4 Ableiten von Vorlagenargumenten bei teilweiser Bestellung"?

Dieses Problem wird besonders überraschend, da der folgende Code, in dem die erste isS einen Verweis auf const S<A,B> nimmt und die zweite nimmt einen const T, gibt den Erwartungswert 1:

#include <iostream> 

template<class A, class B> 
struct S{}; 

template<class A, class B> 
constexpr bool isS(const S<A,B>&) {return true;} 

template<class T> 
constexpr bool isS(const T) {return false;} 

int main() { 
    S<int,char> s; 
    std::cout<<isS(s)<<std::endl; 
    return 0; 
} 

So scheint das Problem zu etwas damit zu tun haben, wie Zeiger behandelt werden.

Answer 1

Da die zweite Überlast die oberste const innerhalb der const T ablegt, wird sie während der Argumentableitung auf T* aufgelöst. Die erste Überladung ist eine schlechtere Übereinstimmung, da sie in S<int, char> const* aufgelöst wird, was eine const-qualification-Konvertierung erfordert.

Sie müssen const vor Ihrer Variablen s hinzuzufügen, um für die speziellere Überlastung treten:

#include <iostream> 

template<class A, class B> 
struct S {}; 

template<class A, class B> 
constexpr bool isS(const S<A,B>*) {return true;} 

//template<class T> 
//constexpr bool isS(const T*) {return false;} 

template<class T> 
constexpr bool isS(const T) {return false;} 

int main() { 
    S<int,char> const s{}; // add const here 
    std::cout<<isS(&s)<<std::endl; 
    return 0; 
} 

Live Example

Ändern der ersten Überlastung zu einem const S<A,B>&, geben die richtige Ergebnis, weil eine Identitätskonvertierung anstelle einer Qualifikationsanpassung stattfindet.

13.3.3.1.4 Referenzbindung [over.ics.ref]

1 Wenn ein Parameter des Referenztyps direkt bindet (8.5.3) für einen Argumentausdruck ist die implizite Konvertierungssequenz die Identitätskonvertierung, es sei denn, der Argumentargument hat einen Typ, der eine abgeleitete Klasse des -Parametertyps ist. In diesem Fall ist die implizite Konvertierungssequenz ein abgeleitet von Basiskonversion (13.3.3.1).

Hinweis: wenn im Zweifel über solche Argument Abzug Spiele, ist es praktisch, die __PRETTY_FUNCTION__ Makro, das (auf gcc/Klirren) zu verwenden, finden Sie weitere Informationen zu den abgeleiteten Typen der ausgewählten Vorlage geben. Sie können bestimmte Übersteuerungen auskommentieren, um zu sehen, wie sich dies auf die Überladungsauflösung auswirkt. Siehe hierzu live example.

Answer 2

Ihre zweite Version gibt nicht die Antwort, die Sie erwarten, da die erste Version von isS eine implizite Konvertierung erfordert, während die zweite nicht.

template<class A, class B> 
constexpr bool isS(const S<A,B>*); 

template<class T> 
constexpr bool isS(const T); 

S<int,char> s; 
isS(&s); 

Beachten Sie, dass &s vom Typ S<int,char>*. Die erste isS sucht nach einer const S<int,char>*, so dass der Zeiger eine Konvertierung benötigt. Die zweite isS ist eine direkte Übereinstimmung.

---

Wenn Sie sich um dieses Muster oft finden, könnten Sie es verallgemeinern, etwa so:

template<template<typename...> class TT, typename T> 
struct is_specialization_of : std::false_type {}; 

template<template<typename...> class TT, typename... Ts> 
struct is_specialization_of<TT, TT<Ts...>> : std::true_type {}; 

Sie dann überprüfen, ob ein Typ eine Spezialisierung von S ist wie folgt:

is_specialization_of<S, decltype(s)>::value