template member specialization of template class

Discussion in 'C++' started by toton, Feb 22, 2008.

  1. toton

    toton Guest

    Hi,
    How can I specialize a template member function for a template class.
    eg, I have a tuple like class
    enum dir_type{
    dir_x,dir_y
    };
    template< typename C>
    class pair_type{
    typedef C value_type;
    typedef pair_type<C> self_type;
    private:
    value_type x_;
    value_type y_;
    public:
    pair_type(const value_type& x,const value_type& y) : x_(x),y_(y){}
    template<dir_type d>
    value_type& get();

    };

    and want to call like
    typedef pair_type<int> PT;
    PT p(10,12);
    int x = p.get<dir_x>();

    now I want to specialize template<dir_type d> value_type& get() for
    dir_x and dir_y, without specializing class pair_type for C.
    1) is it possible ? if, then what is the syntax ?
    2) if possible, can I write such specializations in the header file
    directly ?
    3) if not possible, in which way I can do this (like the way boost
    tuple returns, only instead of get<1> etc, I want to have the enums as
    the name i.e get<dir_x>()

    any help is appreciated.
    thanks
    abir
     
    toton, Feb 22, 2008
    #1
    1. Advertising

  2. toton

    Ondra Holub Guest

    On 22 Ún, 08:10, toton <> wrote:
    > Hi,
    > How can I specialize a template member function for a template class.
    > eg, I have a tuple like class
    > enum dir_type{
    > dir_x,dir_y};
    >
    > template< typename C>
    > class pair_type{
    > typedef C value_type;
    > typedef pair_type<C> self_type;
    > private:
    > value_type x_;
    > value_type y_;
    > public:
    > pair_type(const value_type& x,const value_type& y) : x_(x),y_(y){}
    > template<dir_type d>
    > value_type& get();
    >
    > };
    >
    > and want to call like
    > typedef pair_type<int> PT;
    > PT p(10,12);
    > int x = p.get<dir_x>();
    >
    > now I want to specialize template<dir_type d> value_type& get() for
    > dir_x and dir_y, without specializing class pair_type for C.
    > 1) is it possible ? if, then what is the syntax ?
    > 2) if possible, can I write such specializations in the header file
    > directly ?
    > 3) if not possible, in which way I can do this (like the way boost
    > tuple returns, only instead of get<1> etc, I want to have the enums as
    > the name i.e get<dir_x>()
    >
    > any help is appreciated.
    > thanks
    > abir


    Hi.

    It would be something like

    template<typename C>
    template<>
    pair_type<C>::value_type& get<dir_x>()
    {
    }

    However I think it is not possible. As workaround you can create some
    structure containing static method providing required functionality. I
    think example is better:

    enum dir_type
    {
    dir_x,dir_y
    };

    template< typename C>
    class pair_type;

    template<typename C, dir_type d>
    struct GetImplementation
    {
    static inline typename pair_type<C>::value_type& get()
    {
    // Default implementation
    }
    };

    template<typename C>
    struct GetImplementation<C, dir_x>
    {
    static inline typename pair_type<C>::value_type& get()
    {
    // Specialized implementation
    }
    };

    template< typename C>
    class pair_type
    {
    public:
    typedef C value_type;
    typedef pair_type<C> self_type;
    private:
    value_type x_;
    value_type y_;
    public:
    pair_type(const value_type& x,const value_type& y) : x_(x),y_(y){}

    template<dir_type d>
    value_type& get()
    {
    return GetImplementation<C, d>::get();
    }

    };
     
    Ondra Holub, Feb 22, 2008
    #2
    1. Advertising

  3. toton

    toton Guest

    On Feb 22, 12:41 pm, Ondra Holub <> wrote:
    > On 22 Ún, 08:10, toton <> wrote:
    >
    >
    >
    > > Hi,
    > > How can I specialize a template member function for a template class.
    > > eg, I have a tuple like class
    > > enum dir_type{
    > > dir_x,dir_y};

    >
    > > template< typename C>
    > > class pair_type{
    > > typedef C value_type;
    > > typedef pair_type<C> self_type;
    > > private:
    > > value_type x_;
    > > value_type y_;
    > > public:
    > > pair_type(const value_type& x,const value_type& y) : x_(x),y_(y){}
    > > template<dir_type d>
    > > value_type& get();

    >
    > > };

    >
    > > and want to call like
    > > typedef pair_type<int> PT;
    > > PT p(10,12);
    > > int x = p.get<dir_x>();

    >
    > > now I want to specialize template<dir_type d> value_type& get() for
    > > dir_x and dir_y, without specializing class pair_type for C.
    > > 1) is it possible ? if, then what is the syntax ?
    > > 2) if possible, can I write such specializations in the header file
    > > directly ?
    > > 3) if not possible, in which way I can do this (like the way boost
    > > tuple returns, only instead of get<1> etc, I want to have the enums as
    > > the name i.e get<dir_x>()

    >
    > > any help is appreciated.
    > > thanks
    > > abir

    >
    > Hi.
    >
    > It would be something like
    >
    > template<typename C>
    > template<>
    > pair_type<C>::value_type& get<dir_x>()
    > {
    >
    > }
    >
    > However I think it is not possible. As workaround you can create some
    > structure containing static method providing required functionality. I
    > think example is better:
    >
    > enum dir_type
    > {
    > dir_x,dir_y
    >
    > };
    >
    > template< typename C>
    > class pair_type;
    >
    > template<typename C, dir_type d>
    > struct GetImplementation
    > {
    > static inline typename pair_type<C>::value_type& get()
    > {
    > // Default implementation
    > }
    >
    > };
    >
    > template<typename C>
    > struct GetImplementation<C, dir_x>
    > {
    > static inline typename pair_type<C>::value_type& get()
    > {
    > // Specialized implementation
    > }
    >
    > };
    >
    > template< typename C>
    > class pair_type
    > {
    > public:
    > typedef C value_type;
    > typedef pair_type<C> self_type;
    > private:
    > value_type x_;
    > value_type y_;
    > public:
    > pair_type(const value_type& x,const value_type& y) : x_(x),y_(y){}
    >
    > template<dir_type d>
    > value_type& get()
    > {
    > return GetImplementation<C, d>::get();
    > }
    >
    > };


    Hi thanks for the answer.
    However I am still confused how to use it .
    two problems i am facing in the implementation,
    1) GetImplementation is called on type , so how the get will return
    the value , i.e x_ (which is also private, need to use some friend
    access ? )
    2) I dont have a common implementation for template<typename C,
    dir_type d> struct GetImplementation
    so how to get rid of that & only have the partial specializations ?

    thanks
    abir
     
    toton, Feb 22, 2008
    #3
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Dave
    Replies:
    4
    Views:
    7,738
    pdixtl
    Jun 4, 2010
  2. Ruben Campos
    Replies:
    3
    Views:
    6,507
  3. BigMan
    Replies:
    1
    Views:
    533
  4. Joseph Turian
    Replies:
    4
    Views:
    612
    John Carson
    Mar 20, 2006
  5. Joseph Turian
    Replies:
    2
    Views:
    485
Loading...

Share This Page