Question

Is it possible to convert the is_const expressions into a test function or is this impossible because top level cv-qualifieres are ignored during template type deduction?

int main()
{
  using std::is_const;

  const int x = 0;
  int y = 0;

  // move to "bool test()"
  std::cout
    << "main, x: " << is_const<decltype(x)>::value << "\n"  // true
    << "main, y: " << is_const<decltype(y)>::value << "\n"  // false
    ;

  std::cout
    << "test, x: " << test(x) << "\n"  // false, I wanted true
    << "test, y: " << test(y) << "\n"  // false
    ;
}

I have unsuccessfully tried various versions similar to:

template<typename T>
bool test(T x)
{
  return is_const<???>::value;
}

I want to make sure that I am not missing something and that writing such a testfunction is indeed impossible. (If it was possible, I would also like to know whether a C++03 version was possible.)

Thank you for your consideration

Update

Due to Mankarse I learned that type deduction is different in case of rvalue references:

template<typename T> void t1(T x);
template<typename T> void t2(T& x);
template<typename T> void t3(T&& x);

const int x = 42;
int y = 0;

t1(x);  // T = int:        t1<int>(int x)
t1(y);  // T = int:        t1<int>(int x)

t2(x);  // T = const int: t2<const int>(const int& x)
t2(y);  // T = int: t2<int>(int& x)

t3(x);  // T = const int&: t3<const int&>(const int& && x)
t3(y);  // T = int&:       t3<int&>(int& && x)

Answer 1

In C++11, this can be done with perfect forwarding rvalue references:

template<typename T>
bool test(T&& x)
{
    return std::is_const<typename std::remove_reference<T>::type>::value;
}

In C++03, you can instead use an lvalue reference:

template<typename T>
bool test(T& x) {
    return boost::is_const<T>::value;
}

The differences between the two are demonstrated below:

typedef int const intc;
intc x = intc();
int y = int();
std::cout                                     // C++11 C++03
  << "x: " << test(x) << "\n"                 // 1     1
  << "y: " << test(y) << "\n"                 // 0     0
  << "move(x): " << test(std::move(x)) << "\n"// 1     1 (when compiled as C++11)
  << "move(y): " << test(std::move(y)) << "\n"// 0     compilation error
  << "intc{}: " << test(intc()) << "\n"       // 0     compilation error
  << "int{}: " << test(int()) << "\n"         // 0     compilation error
;