C++, value2pointer 模板

设想这么一个模板value2pointer,无论 T是什么类型：普通对象，普通指针，智能指针，该模板都提供正确的 operator-> 和 operator *。 更直观的说，我们是要这样的 main 能编译和执行：

int main() {
    {
        value2pointer<std::string> str("value2pointer");
        str->insert(str->size(), " success");
        std::cout << *str << std::endl;
        const value2pointer<std::string> cstr("const value2pointer");
        std::cout << *cstr << ':' << cstr->size() << std::endl;
    }

    {
        std::string sstr("value2pointer");
        value2pointer<std::string*> pstr(&sstr);
        pstr->insert(pstr->size(), " success");
        std::cout << *pstr << std::endl;
        std::string csstr("const value2pointer");
        const value2pointer<std::string*> cpstr(&csstr);
        std::cout << *cpstr << ':' << cpstr->size() << std::endl;
    }

    {
        value2pointer<boost::shared_ptr<std::string> > sptrp(
                boost::shared_ptr<std::string>(new std::string("value2pointer"))
                );
        sptrp->insert(sptrp->size(), " success");
        std::cout << *sptrp << std::endl;
        const value2pointer<boost::shared_ptr<std::string> > csptrp(
                boost::shared_ptr<std::string>(new std::string("const value2pointer"))
                );
        std::cout << *csptrp << ':' << csptrp->size() << std::endl;
    }
}

为了理解各种类型的不同之处，我们分开来看。
对于普通类型例如std::string, operator -> 必须返回 std::string*, operator * 则返回 std::string&
对于普通指针类型例如std::string*, operator -> 返回 std::string*, operator * 返回 std::string&
对于智能指针类型例如boost::shared_pointer operator -> 返回 boost::shared_pointer&, operator * 返回std::string

为了提供同时适用这几种类型的value2pointer模板，必须提供一个编译期的类型判断政策类

template <typename T,
          bool is_pointer = boost::is_pointer<T>::value,

          bool is_smartpointer = has_arrow_operator<T>::value>
struct value2pointer_policy;

然后针对不同的真值做模板偏特化：
template <typename T>
struct value2pointer_policy<T, false, true> {
...
}; //shared_pointer

template <typename T>
struct value2pointer_policy<T, true, false> {
...
}; //std::string*

template <typename T>
struct value2pointer_policy<T, false, false> {
...
}; //std::string

并在这个政策类里提供这几个类型和函数：
    typedef value_type;
    typedef const value_type const_value_type;
    typedef pointer_type;
    typedef const T const_pointer_type;

    static value_type& to_value_reference(T& v);
    static const_value_type& to_value_reference(const T& v);
    static pointer_type to_pointer(T& v);
    static const_pointer_type to_pointer(const T& v);

接下来的难点就是：
1. has_arrow_operator 怎么写
2. 智能指针的 value_type 怎么获取

对于 难点 1， 见 http://blog.chinaunix.net/u/8057/showart_2083226.html
对于 难点 2， 我使用了 boost 的 BOOST_TYPEOF， C++03 还没有提供 typeof 标准， boost 提供了一个宏包装了各个编译器的不同实现（C++0x 将会提供标准的 decltype 关键词）

在贴完整代码前，必须提醒的一点是：
1. 模板偏特化不是所有编译器都支持很好（常用的 gcc 和 msvc 7+ 可以）
2. BOOST_TYPEOF 也不是所有编译器都支持

我的测试编译器是 
gcc (GCC) 4.4.1 20090725 (Red Hat 4.4.1-2)

完整代码：

#include 
#include 
#include 
#include 
#include 


/* type trait : has_arrow_operator */
template <typename T>
struct has_arrow_operator {
    template <typename> struct test;

    template<typename U>
    static boost::type_traits::yes_type check_sig(testU::operator ->)>* = NULL);

    template<typename U>
    static boost::type_traits::no_type check_sig(...);

    static const bool value = sizeof(check_sig<T>(0)) == sizeof(boost::type_traits::yes_type);
};

template <typename T,
          bool is_pointer = boost::is_pointer<T>::value,
          bool is_smartpointer = has_arrow_operator<T>::value>
struct value2pointer_policy;

template <typename T>
struct value2pointer_policy<T, false, true> {
    typedef BOOST_TYPEOF(*(((T*)NULL)->operator->())) value_type;
    typedef const value_type const_value_type;
    typedef T& pointer_type;
    typedef const T& const_pointer_type;

    static value_type& to_value_reference(T& v) {
        return *v;
    }
    static const_value_type& to_value_reference(const T& v) {
        return *v;
    }
    static pointer_type to_pointer(T& v) {
        return v;
    }
    static const_pointer_type to_pointer(const T& v) {
        return v;
    }
};

template <typename T>
struct value2pointer_policy<T, true, false> {
    typedef typename boost::remove_pointer<T>::type value_type;
    typedef const value_type const_value_type;
    typedef T pointer_type;
    typedef const T const_pointer_type;

    static value_type& to_value_reference(T& v) {
        return *v;
    }
    static const_value_type& to_value_reference(const T& v) {
        return *v;
    }
    static pointer_type to_pointer(T& v) {
        return v;
    }
    static const_pointer_type to_pointer(const T& v) {
        return v;
    }
};

template <typename T>
struct value2pointer_policy<T, false, false> {
    typedef T value_type;
    typedef const value_type const_value_type;
    typedef T* pointer_type;
    typedef const T* const_pointer_type;

    static value_type& to_value_reference(T& v) {
        return v;
    }
    static const_value_type& to_value_reference(const T& v) {
        return v;
    }
    static pointer_type to_pointer(T& v) {
        return &v;
    }
    static const_pointer_type to_pointer(const T& v) {
        return &v;
    }
};

template <typename T>
class value2pointer {
    typedef value2pointer_policy<T> policy;

    T value;

public:
    value2pointer(const T &v) : value(v) {
    }

    T& get_value_reference() {
        return value;
    }

    const T& get_value_reference() const {
        return value;
    }

    typename policy::value_type& get_real_value() {
        return policy::to_value_reference(value);
    }

    typename policy::const_value_type& get_real_value() const {
        return policy::to_value_reference(value);
    }

    typename policy::value_type& operator *() {
        return policy::to_value_reference(value);
    }

    typename policy::const_value_type& operator *() const {
        return policy::to_value_reference(value);
    }

    typename policy::pointer_type get_pointer () {
        return policy::to_pointer(value);
    }

    typename policy::const_pointer_type get_pointer() const {
        return policy::to_pointer(value);
    }

    typename policy::pointer_type operator -> () {
        return policy::to_pointer(value);
    }

    typename policy::const_pointer_type operator -> () const {
        return policy::to_pointer(value);
    }
};

int main() {
    {
        value2pointer<std::string> str("value2pointer");
        str->insert(str->size(), " success");
        std::cout << *str << std::endl;
        const value2pointer<std::string> cstr("const value2pointer");
        std::cout << *cstr << ':' << cstr->size() << std::endl;
    }

    {
        std::string sstr("value2pointer");
        value2pointer<std::string*> pstr(&sstr);
        pstr->insert(pstr->size(), " success");
        std::cout << *pstr << std::endl;
        std::string csstr("const value2pointer");
        const value2pointer<std::string*> cpstr(&csstr);
        std::cout << *cpstr << ':' << cpstr->size() << std::endl;
    }

    {
        value2pointer<boost::shared_ptr<std::string> > sptrp(
                boost::shared_ptr<std::string>(new std::string("value2pointer"))
                );
        sptrp->insert(sptrp->size(), " success");
        std::cout << *sptrp << std::endl;
        const value2pointer<boost::shared_ptr<std::string> > csptrp(
                boost::shared_ptr<std::string>(new std::string("const value2pointer"))
                );
        std::cout << *csptrp << ':' << csptrp->size() << std::endl;
    }
}

测试结果：
$ dync++ value2pointer.hpp 
value2pointer success
const value2pointer:26
value2pointer success
const value2pointer:28
value2pointer success
const value2pointer:33