Converting possible lvalue reference template to lvalue

Question

What I'm trying to achieve is something like this:

template<typename T>
void foo(T t) {
    TWithoutReferenceType t1 = Magic(t); //some magic here
}

TWithoutReference is the same type of T but without reference, so for example:

Magic(int i) -> int i
Magic(int& i) -> int i
Magic(int&& i) -> int i

I don't know if this is possible for rvalue references or what it could mean in practice though.

WHY I NEED IT:

template <typename ReturnType, typename... Args>
function<ReturnType(Args...)> memoize(const function<ReturnType(Args...)>& func)
{
    return ([=](Args... args) mutable {
        static map<tuple<Args...>, ReturnType> cache;
        tuple<Args...> t(args...);
        auto result = cache.insert(make_pair(t, ReturnType{}));
        ...

So for example if Args ... is vector<double> & and I change the order of the elements, the correspondent key in cache is changed also, and I don't want that this happens, so I don't want that a key change in the future as side effect.

Sorry if I posted the whole code, but I'm afraid that if I make it simpler I'll lose the point of the question.

Are you saying that you want `tuple` to be a tuple of non-reference types — M.M, Apr 28 '16 at 04:23
Exactly. And I think that this is a duplicate of [this](http://stackoverflow.com/questions/12742877/remove-reference-from-stdtuple-members) question — justHelloWorld, Apr 28 '16 at 04:25
OK, let us know if that solution worked for you and I'll close the question — M.M, Apr 28 '16 at 04:26

songyuanyao · Accepted Answer · 2016-04-28T08:14:43.060

2

What you're finding is std::remove_reference:

If the type T is a reference type, provides the member typedef type which is the type referred to by T. Otherwise type is T.

Possible implementation
template< class T > struct remove_reference      {typedef T type;};
template< class T > struct remove_reference<T&>  {typedef T type;};
template< class T > struct remove_reference<T&&> {typedef T type;};

You might implement Magic as

template <typename T> 
typename remove_reference<T>::type Magic(T t) { 
    return t; 
}

edited Apr 28 '16 at 08:14

answered Apr 28 '16 at 03:22

songyuanyao

169,198
16
310
405

So can you write the function that I'm look for using `std::remove_reference` please? – justHelloWorld Apr 28 '16 at 03:55

Jarod42 · Answer 2 · 2016-04-28T08:33:21.230

2

You have several choices including:

template <typename T>
typename std::remove_reference<T>::type Magic(const T& t) { return t; }

or

template <typename T>
typename std::remove_reference<T>::type Magic(T&& t) { return t; }

edited Apr 28 '16 at 08:33

answered Apr 28 '16 at 08:06

Jarod42

203,559
14
181
302

you probably want `typename std::remove_reference::type` as the return type in the second one. – M.M Apr 28 '16 at 08:16
@M.M Isn't it the same thing? – songyuanyao Apr 28 '16 at 08:17
@songyuanyao: Not if you provide the template parameter, i.e: `Magic(my_int);`, but that change nothing for `Magic(my_int);` – Jarod42 Apr 28 '16 at 08:21
@Jarod42 Sorry didn't get it. I meant `typename std::remove_reference::type` and `std::remove_reference_t` is the same thing, isn't it? – songyuanyao Apr 28 '16 at 08:28
There are the same but `remove_reference_t` is only available since c++14 (and OP's tag is c++11). – Jarod42 Apr 28 '16 at 08:32
@Jarod42 Fine, got it. – songyuanyao Apr 28 '16 at 08:34

Converting possible lvalue reference template to lvalue

2 Answers2