C ++:给定指针类型，如何恢复指针类型

enable_if：

struct Field {
  /*Other methods of Field*/
  template<class T> 
  typename std::enable_if<std::is_pointer<T>::value, T>::type Value() const {
    return this->PointerValue<typename std::remove_pointer<T>::type>();
  }
  template<class T> 
  typename  std::enable_if<!std::is_pointer<T>::value, T>::type Value() const {
    return this->SimpleValue<T>();
  }
};

当然std::enable_if，std::is_pointer<T>和std::remove_pointer<T>只有在您有C++11的情况下才可用。如果你不这样做，你可以将std::tr1::is_pointer或boost::is_pointer与boost::enable_if(或boost::enable_if_c(或自己编写的enable_if一起使用(看看这里如何做到这一点，这是非常微不足道的(。 remove_pointer也可以作为std::tr1::remove_pointer和boost::remove_pointer。

但是，根据您想要的内容，它可能仍然不能做您想要的，因为我编写它的方式您需要const P*传递给Value()，因为这就是PointerValue()返回的内容。如果要传递P*并取回const P*，可以将其更改为以下内容：

typename std::enable_if<
    std::is_pointer<T>::value, typename 
    std::add_const<typename 
        std::remove_pointer<T>::type
    >::type*
>::type Value() const;  

没有 c++11，请再次使用 std::tr1::add_const 或 boost::add_const

您希望函数模板具有两种不同的行为，具体取决于实例化它的参数类型。这需要模板专用化。在这种情况下，由于您希望专门针对所有指针类型，因此您需要的是部分模板专用化。

函数模板不支持部分专用化：解决方案是使用帮助程序类模板来执行操作：

template < typename T >
struct getValue
{
    static T apply() { default behavior }
};
template < typename T>
struct getValue< T * >
{
    static T * apply() { behavior for pointer types }
};

然后，可以在成员函数模板中使用此帮助程序类。但是，由于您需要访问 Field 实例中的某些数据，因此您需要将其传递给帮助程序类。

另一件事是Field::value的返回类型取决于模板参数。要确定正确的返回类型，一个好的解决方案是在帮助程序类中有一个 typedef，可以在声明 Field::value 时检索该 typedef。

以下是此解决方案的完整代码：

#include <iostream>
namespace detail { template < typename T > struct getValue; }
class Field
{
  public:
    void * getVoidPointerToTheActualValue() const;
    template< class T >
    typename detail::getValue< T >::result_type value() const;
  private:
    void * actualValue_;
};
namespace detail {
template < typename T >
struct getValue
{
    typedef T result_type;
    static result_type apply( Field const & f )
    {
        std::cout << "simpleValue" << 'n';
        return *reinterpret_cast< const T * >( 
                f.getVoidPointerToTheActualValue() );
    }
};
template < typename T >
struct getValue< T * >
{
    typedef T const * result_type;
    static result_type apply( Field const & f )
    {
        std::cout << "pointerValue" << 'n';
        return reinterpret_cast< const T * >(
                f.getVoidPointerToTheActualValue() );
    }
};
} //namespace detail

void * Field::getVoidPointerToTheActualValue() const
{
    return actualValue_;
}
template< class T >
typename detail::getValue< T >::result_type Field::value() const
{
    return detail::getValue< T >::apply( *this );
}

int main()
{
    Field f;
    f.value< int >();   //prints "simpleValue"
    f.value< int * >(); //prints "pointerValue"
}