重载左值和左值参考的工厂函数-高效初始化

Question

Consider following piece of code:

struct b{
//slow to copy, fast to move data
};

template<class T>
struct c{
    c(T &&, b &&){}
    c(T &&, const b &){}
    //do I have to provide both? 
};

template<class T>
auto
make_c(T &&t, b &&_){
    return c<T>(std::forward<T>(t), std::move(_));
}

template<class T>
auto
make_c(T &&t, const b &_){
    return c<T>(std::forward<T>(t), _);
}
//do I have to make both make_c overloads?

As the comments say - is it necessary to make both rvalue and lvalue make_ functions/constructors or is there a way to avoid code duplication. I must say I feel somehow uncomfortable with copying most of the function code just removing move function.

PS: This is a synthetic example - adding additional template argument(s) is impossible due to msvc compiler issues with operator | overloading.

Answer 1

If you want to avoid copying the code, you'll need to use a forward reference . These, however, are based on a template argument deduction. That is, you could use something like this:

template<typename T, typename B>
auto
make_c(T&& t, B&& _){
    return c<T>(std::forward<T>(t), std::forward<B>(_));
}

While it may work to use manual overloading doing so doesn't quite work when you got multiple arguments requiring different treatment for lvalue and rvalue arguments: the number of overloads needed grows exponentially with the number of such arguments.