perfect-forwarding

I am writing library which wraps a lot of functions and methods from other library. To avoid coping of return values I am applying std::forward like so: template<class T> T&& wrapper(T&& t) { f(t); // t passed as lvalue return std::forward<T>(t); } f returns void and takes T&& (or overloaded on valueness). Wrapper always returns wrappers's param and on returned value should preserve valuness of argument. Do I actually need to use std::forward in return ? Does RVO makes it superfluous? Does the fact that it is a reference (R or L) makes it superfluous? Is it needed if return is not last

(This question follows from this answer ) I am trying to adapt a trampoline function that is currently just passing through a variable number of arguments. I would like to have it convert any argument PyObject* pyob to Object{pyob} , but forward all other arguments through. So (void* self, int, PyObject*, float) -> (int, Object, float) In that example, the first self argument is stripped away. This always happens. Out of the remaining arguments, one of them is of type PyObject*, and hence requires conversion to Object. Here is the function: template <typename T, T t> struct trap; template

I'm experimenting with Perfect Forwarding and I found that std::forward() needs two overloads: Overload nr. 1: template <typename T> inline T&& forward(typename std::remove_reference<T>::type& t) noexcept { return static_cast<T&&>(t); } Overload nr.2: template <typename T> inline T&& forward(typename std::remove_reference<T>::type&& t) noexcept { static_assert(!std::is_lvalue_reference<T>::value, "Can not forward an rvalue as an lvalue."); return static_cast<T&&>(t); } Now a typical scenario for Perfect Forwarding is something like template <typename T> void wrapper(T&& e) { wrapped(forward<T>

Obviously it is possible to pass an rvalue reference to std::thread constructor. My problem is with definition of this constructor in cppreference . It says that this constructor: template< class Function, class... Args > explicit thread( Function&& f, Args&&... args ); Creates new std::thread object and associates it with a thread of execution. First the constructor copies/moves all arguments (both the function object f and all args...) to thread-accessible storage as if by the function: template <class T> typename decay<T>::type decay_copy(T&& v) { return std::forward<T>(v); } As far as I

I suppose when a universal reference parameter is matched with an rvalue reference argument, an rvalue reference argument is returned. However, my testing shows that the rvalue reference is turned into a lvalue reference by the universal reference function template. Why is it so? #include <iostream> #include <type_traits> using namespace std; template <typename T> T f1(T&&t) { //<-----this is a universal reference cout << "is_lvalue reference:" << is_lvalue_reference<T>::value << endl; cout << "is_rvalue reference:" << is_rvalue_reference<T>::value << endl; cout << "is_reference:" << is