[C++] Partieele template specialisatie

[Mijzelf]

Ik ben aan het proberen een c++ wrapper rond gsl vectors te schrijven. Deze bibliotheek is in C geschreven, met een groot aantal verschillende vector functies, voor verschillende basis typen, zoals allocatie functies
gsl_vector *gsl_vector_alloc( size_t n ) voor doubles, en
gsl_vector_float *gsl_vector_float_alloc( size_t n ) voor floats.

Nu probeer ik dat met partial specialized templates te wrappen:

C++:

template<typename BASE> class Vector
{
public:
    class VECTOR_BASE;
    inline VECTOR_BASE *vector_alloc( size_t );
    inline vector_free( VECTOR_BASE * );
    
    Vector( size_t n )
    {
        m_pVector = vector_alloc( n );
    }
    ~Vector()
    {
        vector_free(  m_pVector );
    }
    
    VECTOR_BASE *m_pVector
};

template<> Vector<double>
{
public:
    typedef gsl_vector VECTOR_BASE;
    VECTOR_BASE *vector_alloc( size_t n ){ return gsl_vector_alloc( n ); }
    void vector_free( VECTOR_BASE *p ){ gsl_vector_free( p ); }
};

template<> Vector<float>
{
public:
    typedef gsl_vector_float VECTOR_BASE;
    VECTOR_BASE *vector_alloc( size_t n ){ return gsl_vector_float_alloc( n ); }
    void vector_free( VECTOR_BASE *p ){ gsl_vector_float_free( p ); }
};

Dit compileerd, en ik kan zo ook long double, int, ... toevoegen.

Maar de code is niet bruikbaar:

C++:

Vector<double> v(3);

geeft

code:

error C2440: 'initializing' : cannot convert from 'int' to 'Vector<double>'

C++:

Vector<double> v;
Vector<double>::VECTOR_BASE *pv = v.vector_alloc( 3 );

compileerd OK. (Niet dat ik de code zo wil gebruiken)

Het lijkt er dus op dat de gespecialiseerde templates niet de constructor van de generieke class gebruiken. Waarom niet?

[Zoijar]

Een specialisatie is een hele nieuwe class. Die herbruikt niets. Zo hoort het te werken.

[Mijzelf]

Echt? Hm. Dan moet ik het omdraaien, denk ik:

C++:

template<typename BASE> class GenericVector:
                  public Vector<BASE>
{
public:
          GenericVector(  size_t n );
};

[ Voor 3% gewijzigd door Mijzelf op 31-08-2012 14:40 ]

[.oisyn]

Dat kan, maar makkelijker is om gewoon de type-specifeke zaken buiten de class te implementeren.

C++:

template<class T> struct VectorTraits;

template<> struct VectorTraits<float>
{
    typedef gsl_vector_float element_type; 
    static element_type* alloc( size_t n ){ return gsl_vector_float_alloc( n ); } 
    static void free(element_type*p){ gsl_vector_float_free( p ); } 
};

template<typename BASE> class Vector 
{ 
public:
    typedef VectorTraits<BASE> traits;
    typedef typename traits::element_type element_type; 
     
    Vector( size_t n ) 
    { 
        m_pVector = traits::alloc( n ); 
    } 
    ~Vector() 
    { 
        traits::free(m_pVector); 
    } 
     
    element_type *m_pVector; 
}; 

Overigens is "partial specialization" wat anders dan "slechts een deel specializen". Wat hier gebruikt wordt is explicit specialization - alle template arguments staan vast. Partial specialization is als je slechts specialiseert op een deel van de template argumenten.

C++:

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

// partial specialization
template<class A> struct Foo<A, int> { };

// explicit specialization
template<> struct Foo<float, int> { };

[ Voor 28% gewijzigd door .oisyn op 31-08-2012 14:59 ]

[Mijzelf]

OK, bedankt, dat werkt.