防止左值引用绑定到非常量对象

Question

I'd like to prevent the binding of lvalue references to non-const objects to my function argument, currently I have this code:

template <typename T>
using remove_cr = std::remove_const<typename std::remove_reference<T>::type>;

template <typename T>
using is_nc_lvalue_reference
  = std::integral_constant<bool,
      std::is_lvalue_reference<T>::value
      && !std::is_const<typename std::remove_reference<T>::type>::value
    >;

template <typename T>
void func(T && v, typename std::enable_if<
  std::is_same<THE_TYPE_I_WANT, typename remove_cr<T>::type>::value
  && !is_nc_lvalue_reference<T>::value>::type* = 0)
{
}

This seems a tremendous lot of code to me, does there exist a more elegant SFINAE or non-SFINAE method? I don't need perfect forwarding, but if I don't use it, I lose T .

The idea is, that const objects should not be modified, hence I can convert them to some other representation and feed them, say to a different process. If a non-const reference is given, the object it references can be modified, but the other process does not have access to memory space of the forwarding process and hence I don't forward it.

Answer 1

How about this:

template <typename T>
void func(const T &x) {
  process(x);
}

template <typename T>
void func(T &x) {
  do_nothing(x);
}

Example in action.