在C ++中，调用模板函数以从模板函数中获取指针的值

Question

I am trying to call a template function for the pointer that was given as template parameter in my calling function. My code is:

template <>
struct serialize_helper<std::string> {
     // not important code...
    }

};

template <class T>
inline void serializer(const T& obj, StreamType::iterator& res) {

    if(std::is_pointer<T>::value)
    {
        //THIS doesn' work
        serialize_helper<*T>::apply(*obj,res);
    }
    else
        serialize_helper<T>::apply(obj,res);

}

If I call:

std::string test("test");
serializer(test, res);

everything works fine. But I want also to be able to call the serializer with a pointer as obj:

std::string test* = new std::string("test");
serializer(test, res);

Dereferencing the pointer before calling the serializer function is not a possible option, please do not propose that. Inside the serializer function it is possible.

Shorter description: I want to call serializer with a std::string* and have that do the same thing has if I'd called it with the std::string it points to.

Answer 1

The whole body of your template function needs to compile for the types it's instantiated with, regardless of whether or not a branch will ever be taken. To get around this issue, you can define separate functions for when T is a pointer and when it's not.

Using SFINAE:

template <class T, std::enable_if_t<std::is_pointer<T>::value>* = nullptr>
inline void serializer(const T& obj, StreamType::iterator& res) {
    serialize_helper<std::remove_pointer_t<T>>::apply(*obj,res);
}

template <class T, std::enable_if_t<!std::is_pointer<T>::value>* = nullptr>
inline void serializer(const T& obj, StreamType::iterator& res) {
    serialize_helper<T>::apply(obj,res);
}

Using tagged-dispatch:

template <class T>
inline void serializer(const T& obj, StreamType::iterator& res, std::true_type) {
    serialize_helper<std::remove_pointer_t<T>>::apply(*obj,res);
}

template <class T>
inline void serializer(const T& obj, StreamType::iterator& res, std::false_type) {
    serialize_helper<T>::apply(obj,res);
}

template <class T>
inline void serializer(const T& obj, StreamType::iterator& res) {
    serializer(obj, res, std::is_pointer<T>());
}

Answer 2

I'd go with something like

template <class T>
inline void serializer(const T& obj, StreamType::iterator& res) {
    serialize_helper<T>::apply(obj,res);
}

template<class T>
inline void serializer(T* obj, StreamType::iterator& res) {
    serialize_helper<T>::apply(*obj,res);
}

Answer 3

You could use std::remove_pointer to do that with std::enable_if .

template <class T, typename std::enable_if<std::is_pointer<T>::value>::type* = nullptr>
inline void serializer(const T& obj) {
    serialize_helper<typename std::remove_pointer<T>::type>::apply(*obj);
}

template <class T, typename std::enable_if<!std::is_pointer<T>::value>::type* = nullptr>
inline void serializer(const T& obj) {
    serialize_helper<T>::apply(obj);
}

Note that I've removed the StreamType for simplicity.

live demo