C++: Jak używać typu w funkcji szablonu do rozgałęzienia?

Question

Nie jestem biegły w szablonach. Jak napisać funkcję szablonu o nazwie get, która wybiera tablicę, z której korzysta na podstawie typu szablonu? Patrz poniższy przykład:

struct Foo 
{ 
    int iArr[10]; 
    char cArr[10]; 

    // How to pick array here based on template type? 
    template < typename T > 
    T get(int idx) 
    { 
     // This does NOT work! 
     switch (T) 
     { 
     case int: 
      return iArr[ idx ]; 
     case char: 
      return cArr[ idx ]; 
     } 
    } 
}; 

// Expected behaviour of get() 
Foo foo; 
int i = foo.get<int>(2); 
char c = foo.get<char>(4); 

Answer 1

trzeba by dodać strukturę wartości jakiegoś typu można wykorzystać w celu uzyskania wartości dla przełącznika-oświadczenie. Na przykład:

template<typename T> 
struct switch_value {}; 

template<> 
struct switch_value<int> 
{ 
    enum { value = 1 }; 
}; 

template<> 
struct switch_value<char> 
{ 
    enum { value = 2 }; 
}; 

//then inside you structure Foo 
template <typename T> 
T get(int idx) 
{ 
    switch (switch_value<T>::value) 
    { 
    case 1: 
     return iArr[ idx ]; 
    case 2: 
     return cArr[ idx ]; 
    } 
} 

Dobrą rzeczą jest to, co powinno rzucać błąd kompilatora, jeśli używasz typ, który nie ma prawidłową wartość, ponieważ domyślna wersja switch_value<T> nie definiuje element value, więc jeśli Haven 'wyspecjalizował strukturę dla określonego typu, wtedy taka instancja szablonu zakończy się niepowodzeniem.

Answer 2

Można specjalizować funkcji użytkownika:

struct foo 
{ 
    int iArr[10]; 
    char cArr[10]; 

    template<typename T> 
    T &get(int ipos) { assert(false && "Foo.get: Invalid type!"); return T(); } 

    template<> 
    int &get<int>(int ipos) { return iArr[ipos]; } 

    template<> 
    char &get<char>(int ipos) {return cArr[ipos]; } 

    // add more specialisations for any other types... 
}; 

Works with msvC++ 2010. nadzieję, że to pomaga.

Specjalizacja przełącznika zasugerowana przez Jasona powinna również działać poprawnie.

Answer 3

Choć rozwiązanie proponowane przez Jason działa, to daleko od idiomatyczne i jest trudniejsze do utrzymania, ponieważ wartości case w zestawieniu 1 switch) nie mają pozorny sens („Magic Numbers”) i 2) można łatwo wydostać się z zsynchronizować z wartościami w specjalizacjach switch_value<>. Chciałbym zaproponować to zamiast:

struct Foo { 
    Foo() : iArr(), cArr() { } 

    template<typename T> 
    T get(std::size_t const idx) const  { 
     return Foo::get_dispatcher<T>::impl(*this, idx); 
    } 

private: 
    int iArr[10]; 
    char cArr[10]; 

    template<typename T> 
    struct get_dispatcher; 
}; 

template<> 
struct Foo::get_dispatcher<int> { 
    static int impl(Foo const& foo, std::size_t const idx) { 
     return foo.iArr[idx]; 
    } 
}; 

template<> 
struct Foo::get_dispatcher<char> { 
    static char impl(Foo const& foo, std::size_t const idx) { 
     return foo.cArr[idx]; 
    } 
}; 

Wywoływanie Foo::get<> z innego typu niż int lub char przyniesie błąd kompilatora.

Answer 4

To chyba przesada za przykład, ale jeśli naprawdę tylko trzeba przechowywać jeden układ na raz, a następnie można użyć klasy boost :: wariantowej i odwiedzającego np

#include <boost/variant.hpp> 
#include <iostream> 

template< typename T > 
class GetVisitor : public boost::static_visitor<T> 
{ 
    public: 
    GetVisitor(int index) : index_(index) {}; 

    template <typename U > 
    T operator() (U const& vOperand) const 
    { 
     return vOperand[index_]; 
    } 

    private: 
    int index_; 
}; 


int main() 
{ 
    int iArr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
    char cArr[10] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' }; 

    boost::variant<int*, char*> intVariant(iArr); //- assign integer array to variant 
    boost::variant<int*, char*> charVariant(cArr); //- assign character array to another variant 

    int testInt = boost::apply_visitor(GetVisitor<int>(2), intVariant); 
    char testChar = boost::apply_visitor(GetVisitor<char>(9), charVariant); 

    std::cout << "returned integer is " << testInt << std::endl; 
    std::cout << "returned character is " << testChar << std::endl; 

    return 0; 
} 

output is: 
returned integer is 3 
returned character is j 

ograniczenie wariantu domniemanych przez klasę GetVisitor jest to, że wszyscy członkowie wariantu musi implementować:

T operator[](int) 

Więc można też dodać np std :: vector i std :: deque jako potencjalnych członków wariantu.

Answer 5

Wszystkie te odpowiedzi są przesadą.

template <typename T> 
T get(int idx) 
{ 
    if (boost::is_same<T, int>::value) 
     return *(T*)&iArr[ idx ]; 
    else 
     return *(T*)&cArr[ idx ]; 
} 

Answer 6

zakładam to, co chcesz po prostu koncentrując się obok funkcji szablonu:

w pliku .h

template < typename T > 
struct Foo 
{ 
    T arr[10]; 

    T get(int idx) 
    { 
     return arr[ idx ]; 
    } 
}; 

gdzieś go używać jak:

Foo<int> foo1; 
Foo<char> foo2; 
int i = foo1.get(2); 
char c = foo2.get(4);