C++14自动lambda可以接受obj--但是模板函数不能？

Question

下面是一个完整演示我所看到的问题的程序。

首先，我从一个使用其他类型的分组定义的对象开始，我开始使用std::tuple<>来管理分组。

template <typename> class object;
template <typename... Rs> class object<std::tuple<Rs...> > {
};

我打算这些对象能够将void类型分散在“包”中。我已经意识到无法“实例化”这种类型的元组（请参见std：：tuple中的Void类型）

template <typename... Rs> struct TGrp {};

template <typename> class object;
template <typename... Rs> class object<TGrp<Rs...> > {
};

这些类型的“分组”结构在可变递归中经常使用，它们永远不会被创建/使用。只是为了对模板arg进行分组。

但是，我“希望”对象的签名由“用户期望的”类型/名称组成。

基本上，当std::tuple用于“分组”时，我尝试了传递这些对象的任何可能方法，但只能找到一种方法：自动lambdas。

>

为什么“自动”lambda能起作用？

关于延迟模板扣减的事？就像不同的B/W“自动”和“decltype（自动）”？

如何“设计”一个函数参数来接受这些对象之一。

示例：

#include <tuple>
#include <iostream>

#define GRP std::tuple      // IF 'tuple' used:  compile error where noted below
//#define GRP TGrp          // if THIS is used:  all works, and TGrp() is never constructed


// Grouping mechanism
template <typename... Ts> struct TGrp {
    TGrp() {
        std::cout << "Never printed message\n";
    }
};


// MAIN OBJECT (empty for forum question)
template <typename> class object;
template <typename... Rs> class object<GRP<Rs...> > {
};



// Regular function                  (does NOT work)
void takeobj(object<GRP<void> >& obj) { (void)obj; }

// Lambda - taking anything...       (only thing I could make WORK)
auto takeobj_lambda = [](auto obj) { (void)obj; };

// Template func - taking anything   (does NOT work)
template <typename T> void takeobj_templ_norm(T obj) { (void)obj; }
template <typename T> void takeobj_templ_clref(const T& obj) { (void)obj; }
template <typename T> void takeobj_templ_lref(T& obj) { (void)obj; }
template <typename T> void takeobj_templ_rref(T&& obj) { (void)obj; }


int main()
{
    object<GRP<void> > oval;

    //takeobj(oval);                  // <--    causes compile error

    takeobj_lambda(oval); // works

    //takeobj_templ_norm(oval);       // <--    also error
    //takeobj_templ_clref(oval);      // <--    also error
    //takeobj_templ_lref(oval);       // <--    also error
    //takeobj_templ_rref(oval);       // <--    also error
    return 0;
}

编辑：添加修剪后的复制：

#include <tuple>


// MAIN OBJECT (empty for forum question)
template <typename> class object;
template <typename... Rs> class object<std::tuple<Rs...> > {
};

// Regular function                  (does NOT work)
void takeobj(object<std::tuple<void> >& obj) { (void)obj; }

// Lambda - taking anything...       (only thing I could make WORK)
auto takeobj_lambda = [](auto obj) { (void)obj; };


int main()
{
    object<std::tuple<void> > oval;

    //takeobj(oval);                  // <--    causes compile error
    takeobj_lambda(oval); // works

    return 0;
}

Answer 1

std::tuple 是对象 > 的关联类，因此在执行参数相关查找的非限定调用中，将实例化std::tuple 以查找任何可能已内联定义的friend函数。此实例化会导致错误。

如果被调用的对象没有命名函数或函数模板，则不执行参数相关的查找；因此，使用lambda Works-takeObj_lambda是一个对象。

如果您使用限定调用(::takeobj(oval))，或者在takeobj((takeobj)(oval))中加上括号，那么代码将编译。这两种方法都禁用ADL。