Const参数绑定到C ++模板中的非const引用

Question

Consider something like:

template <typename T>
void f(T& x) 
{
    ....       
}

Why does something like const int binds to f(T&) ?

This seems to me kind of a violation of const-correctness . In fact, if f() takes a non -const T& reference, then it's very likely that f() will modify its argument (else, f() would have been defined as void f(const T&) ).

In code like this:

template <typename T>
inline void f(T& x) 
{
    x = 0;
}

int main() 
{
    int n = 2;
    f(n);

    const int cn = 10;
    f(cn);
}

the compiler tries to call f() with T = const int , then of course there is an error message because of the x = 0; assignment inside f() 's body.
This is the error message from GCC:

 test.cpp: In instantiation of 'void f(T&) [with T = const int]': test.cpp:13:9: required from here test.cpp:4:7: error: assignment of read-only reference 'x' x = 0; ^ 

But why does the compiler try to bind a const argument with a function template which takes a non -const parameter?

What's the rationale behind this C++ template rule?

Answer 1

T binds to const int .

To avoid that, you may use SFINAE:

template<typename T>
typename std::enable_if<!std::is_const<T>::value, void>::type
f(T& arg) {}

or deleted function:

template <typename T> void f(T& arg) {}
template <typename T> void f(const T&) = delete;

Answer 2

You can use std::enable_if plus eg std::is_const to avoid that T binds to a const type.

---

Re …

“What's the rationale behind this C++ template rule?”

it can possibly be found in Bjarne's design-and-evolution book, but about the most common rationale is that the rules have been chosen for simplicity and uniformity, and so it appears to be also here: treating some types in special ways would introduce needless complexity.

Answer 3

const int cn = 10;

That means 'cn' is const, you can't change it in anyway, anywhere and anytime.

More:

const int cia = 10;
int ia = 10;

The type of cia is different with ia. So T will be const int, not int.

typedef const int      cint;
cint cia = 10;
int ia = 10;

T will be used as cint, not int.