C++: Teilweise spezialisiert Vorlage des Typ-Parameter als ein anderes Mitglied-Typ der Template-Klasse

Question

Ich habe eine Vorlage struct SFoo, die ein Mitglied struct enthält SZug:

template <typename tTYPE> 
struct SFoo 
    { 
    struct SZug {}; 
    }; 

ich eine andere Struktur haben SBar, die einen Typ Parameter nimmt:

template <typename tTYPE> 
struct SBar 
    { /* stuff */ }; 

ich möchte SBar mit SZug für den Typ-Parameter spezialisieren, etwa so:

template <typename tTYPE> 
struct SBar<typename SFoo<tTYPE>::SZug> 
    { /* different stuff */ }; 

Dies lässt sich nicht kompilieren - LLVM Ausgänge:

nicht ableitbar Template-Parameter 'TTYPE'

Während ein Compiler dies leicht, wenn es gewünscht ableiten könnte, ich vermute, es ist nur dass die C++ - Spezifikation diesen Fall spezifisch abdecken müsste.

Gibt es eine Möglichkeit, dies zu erreichen?
. (Anmerkung: Im Moment arbeite ich um es von SZug außerhalb von SFoo bewegt und eine using Meldung ab, aber es ist hässlich)

Answer 1

Ich bin nicht sicher, ob ich voll und ganz verstanden, was Sie tun wollen, aber Sie könnten versuchen, das folgende (es erfordert nur ein bestimmtes Attribut zu SZug Zugabe:

template <typename tTYPE> 
struct SFoo { 
    struct SZug { 
     // Add this to be able to obtain SFoo<T> from SFoo<T>::SZug 
     using type = tTYPE; 
    }; 
}; 

Dann eine kleine Vorlage, wenn ein Typ zu überprüfen ist ein SFoo<T>::SZug:

template <typename tTYPE, typename Enabler = void> 
struct is_SZug: public std::false_type { }; 

template <typename tTYPE> 
struct is_SZug<tTYPE, typename std::enable_if< 
    std::is_same<tTYPE, typename SFoo<typename tTYPE::type>::SZug>{} 
>::type>: public std::true_type { }; 

Und eine leichte Modifikation der SBar Vorlage, um die „Spezialisierung“ zu aktivieren, wenn der Typ ein SZug ist:

template <typename tTYPE, typename Enabler = void> 
struct SBar 
    { static void g(); }; 

template <typename tTYPE> 
struct SBar<tTYPE, typename std::enable_if<is_SZug<tTYPE>{}>::type> 
    { static void f(); }; 

Ein wenig Kontrolle:

void f() { 
    SBar<int>::g(); 
    SBar<SFoo<int>::SZug>::f(); 
} 

Hinweis: Sie können auch festlegen direkt SFoo<T> als type Attribut in SFoo<T>::SZug, würden Sie einfach das zweite Argument von std::is_same etwas ändern müssen.

Answer 2

können Sie erhalten die Effekt, für die Sie die folgende gesuchte durch (die ausdruckt 0 1, BTW):

#include <type_traits> 
#include <iostream> 

namespace detail 
{ 
    struct SZugBase{}; 
} 

template <typename tTYPE> 
struct SFoo                                 
{ 
    struct SZug : public detail::SZugBase {}; 
}; 

template<typename tType, bool IsFoo> 
struct SBarBase 
{ 
    int value = 0; 
}; 

template<typename tType> 
struct SBarBase<tType, true> 
{ 
    int value = 1; 
}; 

template <typename tTYPE> 
struct SBar : public SBarBase<tTYPE, std::is_convertible<tTYPE, detail::SZugBase>::value> 
{ /* stuff */ }; 

int main() 
{ 
    SBar<int> b0; 
    SBar<SFoo<int>::SZug> b1; 

    std::cout << b0.value << " " << b1.value << std::endl; 
} 

Erklärung

Zuerst wir SZug geben eine reguläre Klasse b ase:

namespace detail 
{ 
    struct SZugBase{}; 
} 

template <typename tTYPE> 
struct SFoo            
{ 
    struct SZug : public detail::SZugBase {}; 
}; 

Beachten Sie Folgendes:

1. SZugBase ist durch nichts parametriert, so ist es leicht, sich darauf zu beziehen, unabhängig von der Parameter von SFoo

2. SZugBase ist in ein detail Namespace, also sagen Sie nach gängigen C++ - Konventionen, dass Clients Ihren Code ignorieren.

Jetzt geben wir SBar zwei Basisklassen, spezialisiert auf, ob etwas umwandelbar in die Nicht-Template Basis von SZug:

template<typename tType, bool IsFoo> 
struct SBarBase 
{ 
    int value = 0; 
}; 

template<typename tType> 
struct SBarBase<tType, true> 
{ 
    int value = 1; 
}; 

Schließlich brauchen wir nur SBar eine Unterklasse dieser Basen zu machen (abhängig von der Spezialisierung):

template <typename tTYPE> 
struct SBar : public SBarBase<tTYPE, std::is_convertible<tTYPE, detail::SZugBase>::value> 
{ /* stuff */ }; 

Beachten Sie, dass Sie nicht SBar Sie spezialisieren sich ihr E, spezialisieren Sie eher die Basisklassen. Dies hat jedoch den gleichen Effekt.