Question

The following errors due to the const int specialization:

#include <iostream>
using std::cout;
using std::endl;

template <typename T> void g(T val)
{
    cout << "unknown" << endl;
}

template <> void g(int && val)
{
    cout << "int &&" << endl;
}

template <> void g(const int && val)
{
    cout << "const int &&" << endl;
}

template <> void g(int & val)
{
    cout << "int &" << endl;
}

template <> void g(const int & val)
{
    cout << "const int &" << endl;
}

template <> void g(int val)
{
    cout << "int" << endl;
}

template <> void g(const int val)  //redefinition here
{
    cout << "const int" << endl;
}

int main() {}

error: redefinition of 'g'
template <> void g(const int val)
                 ^

Why are T& and T&& distinct from const T& and const T&& but T is not distinct from const T?

Answer 1

Because top-level const-ness of function parameters is an implementation detail of the function. For example, the following is valid:

// Prototype
void foo(int c);

// Implementation
void foo(int const c) { ... }

Since the argument is passed by value, the caller doesn’t really care whether the function is going to modify its own private copy. Therefore, top-level const-ness is not part of the function signature.

Note that this only applies to top-level const-ness! int and int const are equivalent in a function prototype, as are int * and int * const. But int * and int const * are not.