szablon specjalizacji klasy szablonu

Question

chcę specjalizują następujących funkcji członka:

class foo { 
    template<typename T> 
    T get() const; 
}; 

Do drugiej klasy bar że zależy na szablonach, jak również.

Na przykład, chciałbym bar być std::pair z niektórych parametrów szablonu, coś takiego:

template<> 
std::pair<T1,T2> foo::get() const 
{ 
    T1 x=...; 
    T2 y=...; 
    return std::pair<T1,T2>(x,y); 
} 

Gdzie T1 i T2 są szablony, jak również. Jak to zrobić? O ile mi wiadomo, powinno być możliwe .

Więc teraz mogę zadzwonić:

some_foo.get<std::pair<int,double> >(); 

Pełne/odpowiedź ostateczna:

template<typename T> struct traits; 
class foo { 
    template<typename T> 
    T get() const 
    { 
     return traits<T>::get(*this); 
    } 
}; 

template<typename T> 
struct traits { 
    static T get(foo &f) 
    { 
     return f.get<T>(); 
    } 
}; 

template<typename T1,typename T2> 
struct traits<std::pair<T1,T2> > { 
     static std::pair<T1,T2> get(foo &f) 
     { 
       T1 x=...; 
       T2 y=...; 
       return std::make_pair(x,y); 
     } 
}; 

Answer 1

Nie można częściowo specjalizują się szablony funkcyjne, przepraszam, ale takie są zasady. Można zrobić coś takiego:

class foo { 
    ... 
}; 


template<typename T> 
struct getter { 
    static T get(const foo& some_foo); 
}; 

template<typename T1, typename T2> 
struct getter< std::pair<T1, T2> > { 
static std::pair<T1, T2> get(const foo& some_foo) { 
    T1 t1 = ...; 
    T2 t2 = ...; 
    return std::make_pair(t1, t2); 
}; 

a następnie nazwać jak

getter<std::pair<int, double> >::get(some_foo); 

chociaż. Być może będziesz musiał trochę pogubić się ze statkiem lub widocznością, jeśli get naprawdę potrzebuje być członkiem funkcji.

Wypracowanie na SBI jest sugestia:

class foo { 
    ... 
    template<typename T> 
    T get() const; 
}; 

template<typename T> 
T foo::get() const 
{ 
    return getter<T>::get(*this); 
    /*   ^-- specialization happens here */ 
} 

a teraz z powrotem do bycia w stanie powiedzieć

std::pair<int,double> p = some_foo.get<std::pair<int, double> >(); 

Answer 2

Musisz przeciążyć funkcję składową dla pary, jak w

template <T, V> std::pair<T, V> foo::get() 

W ogólnym przypadku będziesz musiał mieć możliwość rozróżnienia między różnymi przeciążeniami. W przypadku ujednolicenia jest to łatwe, ponieważ para jest szablonowana na 2 typy, podczas gdy oryginalny element był szablonem tylko na T.

Jeśli zamiast tego potrzebna jest specjalizacja dla np. Std :: vector, czyli dla kontenera z pojedynczym szablonem parametrów, musisz być ostrożny, ponieważ może to być mylące dla kompilatora, aby zrozumieć, jeśli chcesz instancję specjalizację szablonu, w którym szablon T jest std :: vector lub specjalizacji na przeciążenia,

template <T> std::<vector <T> foo::get() const 

składni proponowane nie może pracować, ponieważ jesteś całkowicie specjalizujący funkcję Członka,

template <>,

, ale pomijasz dwa nieokreślone typy, T1 i T2.