// Small functions
void doThingsWithA(const A& a)
{
    // do stuff
}

void doThingsWithB(const B& b)
{
    // do stuff
}

void doThingsWithC(const C& c)
{
    // do stuff
}

// Big function
void doThingsWithABC(const A& a,const B& b,const C& c)
{
    // do stuff
    doThingsWithA(a);
    doThingsWithB(b);
    doThingsWithC(c);
    // do stuff
}

但是现在,使用移动语义,允许我的函数将rvalue引用作为参数并添加这些重载可能会变得有趣(至少在某些情况下)：

void doThingsWithA(A&& a);
void doThingsWithB(B&& b);
void doThingsWithC(C&& c);

从我收集的内容来看,如果我想在我的大函数中调用那些重载,我需要使用完美的转发,这可能看起来像这样(它的可读性稍差,但我想它可以用模板类型的良好命名约定)：

template<typename TplA,typename TplB,typename TplC>
void doThingsWithABC(TplA&& a,TplB&& b,TplC&& c)
{
    // do stuff
    doThingsWithA(std::forward<TplA>(a));
    doThingsWithB(std::forward<TplB>(b));
    doThingsWithC(std::forward<TplC>(c));
    // do stuff
}

我的问题是：这是不是意味着如果我的小函数有其他重载,那么可以调用具有不适合的类型参数的大函数？

我认为这可能有助于防止这种情况：

template<typename TplA,typename TplC,class = typename std::enable_if<std::is_same<A,std::decay<TplA>::type>::value>::type,class = typename std::enable_if<std::is_same<B,std::decay<TplB>::type>::value>::type,class = typename std::enable_if<std::is_same<C,std::decay<TplC>::type>::value>::type>
    doThingsWithABC(TplA&& a,TplC&& c)
{
    // do stuff
    doThingsWithA(std::forward<TplA>(a));
    doThingsWithB(std::forward<TplB>(b));
    doThingsWithC(std::forward<TplC>(c));
    // do stuff
}

虽然我不确定它是否不是太严格,因为我不知道如果我试图用可隐式转换为A,B或C的类型调用大函数它的行为如何……

但是……即使假设这个有效,我真的没有其他选择吗？ (我的意思是……眼睛不容易)