指针的C ++模板专业化？

Question

I read book < C++ Templates - the Complete Guide > and learned template specialization for pointer. (maybe I misunderstand this part of the book)

(1) Here's my simple template:

#include <iostream>

template<typename T>
void Function(const T& a)
{
    std::cout << "Function<T>: " << a << std::endl;
}

template<typename T>
void Function<T*>(const T* a)
{
    std::cout << "Function<T*>: " << a << std::endl;
}

int main(void)
{
    Function(1);
    Function(1.2);
    Function("hello");
    Function((void*)0x25);

    return 0;
}

I use ubuntu16.04 x64, g++ 5.3, the compiler report:

$ g++ main.cpp -o main.exe 
main.cpp:10:29: error: non-type partial specialization ‘Function<T*>’ is not allowed
 void Function<T*>(const T* a)

(2) but this code is correct:

#include <iostream>

template<typename T>
void Function(const T& a)
{
    std::cout << "Function<T>: " << a << std::endl;
}

int main(void)
{
    Function(1);
    Function(1.2);
    Function("hello");
    Function((void*)0x25);

    return 0;
}

result shows:

$ g++ main.cpp -o main.exe
$ ./main.exe 
Function<T>: 1
Function<T>: 1.2
Function<T>: hello
Function<T>: 0x25

My question is: Is the book about pointer specialization is wrong ? Or I mis understand the meaning of this part in the book ? Or something else ?

Update about pointer specialization in class.

(3) template class with pointer specialization:

#include <iostream>

template<typename T>
struct Base {
    T member;

    Base(const T& a)
        : member(a)
    {
    }

    void hello()
    {
        std::cout << member << std::endl;
    }
};

template<typename T>
struct Base<T*> {
    T* member;

    Base(T* a)
        : member(a)
    {
    }

    void hello()
    {
        std::cout << member << std::endl;
    }
};

int main(void)
{
    Base<int> b1(12);
    Base<double> b2(2.4);
    Base<char*> b3("hello");
    Base<void*> b4((void*)0x25);

    b1.hello();
    b2.hello();
    b3.hello();
    b4.hello();

    return 0;
}

this code is correct with one warning:

$ g++ main.cpp -o main.exe 
main.cpp: In function ‘int main()’:
main.cpp:37:27: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
     Base<char*> b3("hello");
                           ^
$ ./main.exe 
12
2.4
hello
0x25

(4) template class without pointer specialization:

#include <iostream>

template<typename T>
struct Base {
    T member;

    Base(const T& a)
        : member(a)
    {
    }

    void hello()
    {
        std::cout << member << std::endl;
    }
};

int main(void)
{
    Base<int> b1(12);
    Base<double> b2(2.4);
    Base<char*> b3("hello");
    Base<void*> b4((void*)0x25);

    b1.hello();
    b2.hello();
    b3.hello();
    b4.hello();

    return 0;
}

result is the same:

$ g++ main.cpp -o main.exe
main.cpp: In function ‘int main()’:
main.cpp:39:27: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
     Base<char*> b3("hello");
                           ^
$ ./main.exe 
12
2.4
hello
0x25

Does this means pointer specialization is needless ? Or maybe this feature behave differently on different compiler ?

Answer 1

as you've been already told, partial specialization of function templates are not allowed. You can use std::enable_if for this:

template <typename T, typename std::enable_if_t<!std::is_pointer<T>::value>* = 0>
void func(T val) { std::cout << val << std::endl; }

template <typename T, typename std::enable_if_t<std::is_pointer<T>::value>* = 0>
void func(T val) { func(*val); }

If you are looking for simpler syntax, wait for concepts

Answer 2

The error message told you what is wrong:

 non-type partial specialization 'Function<T*>' is not allowed 

You can only partially specialize types (classes). You've tried to partially specialize a function. Functions are not types; you can only fully specialize them.

Answer 3

Two problems:

1. You are not allowed to partially specialise a function.

2. The behaviour of (void*)0x25 is undefined . With the exception of nullptr , you are not allowed to set a pointer to memory you don't own, with the exception of one past the final element of an array and one past the address of a scalar.