Partial specialization of class template.

I have a class template:

Code:

---

template<typename T1, typename T2>
class A
{
public:
  void f1();
  void f2();
  void f3();
  int f4();
};

---

The class is actually much longer.

Now, in case the second template parameter is float, f4 should return std::string instead of int.

Code:

---

template<typename T1>
class A<T1, float>
{
public:
  void f1();
  void f2();
  void f3();
  std::string f4();
};

---

Is there any way to accomplish this without specifying all of the other parts of the class again?

What I'm really trying to do is writing a concatenation_iterator that runs through two iterators in succession. If those iterators are of input iterator category, the postfix ++ operator should return a proxy object, for other categories it should return a copy of itself as is the normal behaviour of postfix ++.

You could try using a second template acting as a functor, specialise operator() and then use that as a public member. A bit "round the houses", but it might have potential for what you want to do;

Code:

---

#include <iostream>
#include <string>

template<typename T3>
struct f4_
{
        int operator()(){return 1;}
};

template<>
struct f4_<float>
{
        std::string operator()(){return "FOOBAR";}
};

template<typename T1, typename T2>
class A
{       
public:
          void f1();
          void f2();
          void f3();
          f4_<T2> f4;
};

 
int main()
{
        A<int,int> foo;
        A<int,float> bar;
       
        std::cout << "foo Answer = " << foo.f4() << std::endl;
        std::cout << "bar Answer = " << bar.f4() << std::endl;

}

---

Unfortunatly that solution is not possible in my case as the function in question is an overloaded operator.

Thanks anyway. I've solved it via template metaprogramming :)

So in case anyone ever needs to concatenate two containers or anything like that:

Code:

---

#ifndef _MOREITER_HPP_SR_H_
#define _MOREITER_HPP_SR_H_

#include <iterator>
#include <boost/iterator.hpp>
#include <boost/type_traits.hpp>
#include <boost/mpl/if.hpp>

namespace boost
{
        namespace internal
        {
                // Gets the lesser iterator category of the two arguments
                // Possible combinations:
                // Combination  Handled By  Result
                // II          IU          I
                // FI          FI          I
                // BI          UU          IB -> I
                // RI          UU          IR -> I
                // IF          IU          I
                // FF          FU          F
                // BF          UU          FB -> F
                // RF          UU          FR -> F
                // IB          IU          I
                // FB          FU          F
                // BB          BB          B
                // RB          UU          BR -> B
                // IR          IU          I
                // FR          FU          F
                // BR          BR          B
                // RR          RR          R

                // A version that compiles without partial spec. would have to explicitly
                // handle more cases.

                // UU
                template<typename LCAT, typename RCAT>
                struct lesser_category
                {
                        typedef typename lesser_category<RCAT, LCAT> type;
                };
                // IU
                template<typename RCAT>
                struct lesser_category<std::input_iterator_tag, RCAT>
                {
                        typedef std::input_iterator_tag type;
                };
                // FU
                template<typename RCAT>
                struct lesser_category<std::forward_iterator_tag, RCAT>
                {
                        typedef std::forward_iterator_tag type;
                };
                // FI
                template<>
                struct lesser_category<std::forward_iterator_tag,
                        std::input_iterator_tag>
                {
                        typedef std::input_iterator_tag type;
                };
                // BB
                template<>
                struct lesser_category<std::bidirectional_iterator_tag,
                        std::bidirectional_iterator_tag>
                {
                        typedef std::bidirectional_iterator_tag type;
                };
                // BR
                template<>
                struct lesser_category<std::bidirectional_iterator_tag,
                        std::random_access_iterator_tag>
                {
                        typedef std::bidirectional_iterator_tag type;
                };
                // RR
                template<>
                struct lesser_category<std::random_access_iterator_tag,
                        std::random_access_iterator_tag>
                {
                        typedef std::random_access_iterator_tag type;
                };
        }

        template<typename FirstIter, typename SecondIter,
                typename Category = internal::lesser_category<
                typename std::iterator_traits<FirstIter>::iterator_category,
                typename std::iterator_traits<SecondIter>::iterator_category>::type >
        class concatenation_iterator
                : public iterator<Category, typename std::iterator_traits<FirstIter>::value_type,
                typename std::iterator_traits<FirstIter>::distance_type,
                typename std::iterator_traits<FirstIter>::pointer,
                typename std::iterator_traits<FirstIter>::reference>
        {
        public:
                typedef FirstIter first_iterator_type;
                typedef SecondIter second_iterator_type;
                typedef concatenation_iterator<first_iterator_type, second_iterator_type,
                        Category> self;

        private:
                FirstIter begin1, end1;
                SecondIter begin2;
        public:
                // Creates a begin iterator
                concatenation_iterator(const FirstIter& b1, const FirstIter &e1, const SecondIter &b2)
                        : begin1(b1), end1(e1), begin2(b2)
                {}
                // Creates an end iterator
                concatenation_iterator(const FirstIter &e1, const SecondIter &e2)
                        : begin1(e1), end1(e1), begin2(e2)
                {}

                reference operator *() { return begin1 == end1 ? *begin2 : *begin1; }
                pointer operator ->() { return begin1 == end1 ? &*begin2 : &*begin1; }
                self & operator ++() { if(begin1 != end1) ++begin1; else ++begin2; return *this; }

                // Test the moving iterators
                friend bool operator ==(const self &x, const self &y) {
                        return x.begin1 == y.begin1 && x.begin2 == y.begin2;
                }
                friend bool operator !=(const self &x, const self &y) {
                        return x.begin1 != y.begin1 || x.begin2 != y.begin2;
                }

                // This needs more thinking about - partial specialization?
                // I may not use a proxy object for this if it's not
                // an input iterator.
                // But if one of the contained iterators is an input iterator
                // and uses shallow copy then this implementation fails.
                // Use template metaprogramming to specify the return type.
                class postinc_proxy {
                        value_type el;
                public:
                        explicit postinc_proxy(const self &) : el(*i) {}
                        value_type operator *() const { return el; }
                };

                typedef typename mpl::if_<is_same<Category, std::input_iterator_tag>,
                        postinc_proxy, self>::type postinc_ret;

                postinc_ret operator ++(int) { postinc_ret t(*this); ++*this; return t; }

        };

}

#endif

---

> Now, in case the second template parameter is float, f4 should return std::string instead of int.

What if f4() returns std::string for int, too?

Nope, not possible. Look at the long code I posted, the issue is the postfix ++ operator.