add_const won't work with forwarding references - c++

Question

I'm using the add_const typetrait in a scenario where it's applied on a forwarding reference type. Everything looked like no constness was added to the type so I made a small example to verify that was the case (PrintType is an incomplete type that will cause a compilation error, forcing the compiler to spit out the name of the template argument in the error message) :
#include <iostream>
#include <type_traits>
#include <complex>
template <class T>
struct PrintType;
template <class T>
void f(T&& arg)
{
PrintType<std::add_const_t<decltype(arg)>> local;
(void)local;
}
int main()
{
std::complex<double> co;
f(co);
}
The error message says :
main.cpp: In instantiation of 'void f(T&&) [with T = std::complex<double>&]':
main.cpp:20:9: required from here
main.cpp:12:48: error: 'PrintType<std::complex<double>&> local' has incomplete type
PrintType<std::add_const_t<decltype(arg)>> local;
ie the trait transformed my type to T = std::complex<double>& instead of T = std::complex<double> const&

Answer 1

The type trait works as expected. You should consider what you are attempting to do, which is to add constness to a reference. You can't rebind a reference (it's not mutable), so essentially any reference is a const reference
T& == T& const
What I suppose you expect to do is to create a reference to a const type (which reminds me of the const iterator vs const_iterator thingy) which cant' be done this way, for the same reason you can't typedef a reference type to a reference to a const type this way :
typedef T& ref_t;
typedef const ref_t const_ref_t; // This is not T const& !!
To sum up, adding const to a reference type makes it a const reference (which is the same as a reference) and not a reference to a const type

Answer 2

For situations like these, it can be useful to have a type trait that transfers the reference to a new type. This can complement another trait that does the same for const and volatile, implemented almost identically. In your case, you should only need to worry about lvalue references if you use T instead of decltype(arg). However, if using a lambda, you definitely do need to worry about rvalue references as well.
Here is a sample implementation:
template<typename T, bool ApplyLvalueRef, bool ApplyRvalueRef>
struct apply_ref {
static_assert(!(ApplyLvalueRef && ApplyRvalueRef), "Improper use: T cannot be & and &&");
using possibly_lref = std::conditional_t<
ApplyLvalueRef,
std::add_lvalue_reference_t<T>,
T
>;
using type = std::conditional_t<
ApplyRvalueRef,
std::add_rvalue_reference_t<possibly_lref>,
possibly_lref
>;
};
template<typename From, typename To>
struct transfer_ref : apply_ref<To, std::is_lvalue_reference<From>{}, std::is_rvalue_reference<From>{}> {};
template<typename From, typename To>
using transfer_ref_t = typename transfer_ref<From, To>::type;
At first glance, it seems a bit silly to have separate booleans for lvalue vs. rvalue. However, this allows for applying neither. There should never be a situation in which both are true, and this is enforced by the static assertion.
Now we can easily write the function:
template <class T>
void f(T&& arg)
{
using with_const = std::add_const_t<std::remove_reference_t<T>>;
PrintType<transfer_ref_t<T, with_const>> local;
(void)local;
}
Since we cannot apply const to a reference, we must strip it, add const to the referred type, and then add the reference back.