试验尾随返回类型和标记分派(dispatch)，我编写了以下代码。

#include <string>
#include <iostream>

using namespace std;

namespace Params
{
struct t_param1{};
struct t_param2{};
};

template<typename t_detail>
struct Select;

template<>
struct Select<Params::t_param1> {using choice = Params::t_param1;};

template<>
struct Select<Params::t_param2> {using choice = Params::t_param2;};

class Tester
{
private:
    using t_uint32 = uint32_t;
    using t_string = string;

private:
    t_uint32 m_param1;
//      t_string m_param2;

private:
    template<typename t_entity>
    void assign(const Params::t_param1&, t_entity&& entity);

    template<typename t_entity>
    void assign(const Params::t_param2&, t_entity&& entity);

    auto access(const Params::t_param1&) -> decltype(m_param1);
//      auto access(const Params::t_param2&) -> decltype(m_param2);


public:
    template<typename t_detail, typename t_entity>
    void assign(t_entity&& entity);

    template<typename t_detail>
    auto access() -> decltype(access(typename Select<t_detail>::choice()));
};

template<typename t_detail, typename t_entity>
void
Tester::assign(t_entity&& entity)
{
assign(typename Select<t_detail>::choice(), entity);
}


template<typename t_entity>
void
Tester::assign(const Params::t_param1&, t_entity&& entity)
{
m_param1 = entity;
cout << "Assigned m_param1 with " << entity << endl;
}

/*
template<typename t_entity>
void
Tester::assign(const Params::t_param2&, t_entity&& entity)
{
m_param2 = entity;
cout << "Assigned m_param2 with " << entity << endl;
}
*/



template<typename t_detail>
auto
Tester::access()
-> decltype(access(typename Select<t_detail>::choice()))
{
return(access(typename Select<t_detail>::choice()));
}

auto
Tester::access(const Params::t_param1&)
-> decltype(m_param1)
{
return(m_param1);
}

/*
auto
Tester::access(const Params::t_param2&)
-> decltype(m_param2)
{
return(m_param2);
}
*/

int main() {
auto tester = Tester();
tester.assign<Params::t_param1>(79);
//  tester.assign<Params::t_param2>("viziv");

auto param1 = tester.access<Params::t_param1>();
//  auto param2 = tester.access<Params::t_param2>();

cout << "Access: param1 = " << param1 << endl;
//  cout << "Access: param2 = " << param2 << endl;

return 0;
}

当我使用 Apple LLVM 版本 7.0.2 (clang-700.1.81) 编译此代码时，出现以下编译错误

junk1.cpp:78:9: error: out-of-line definition of 'access' does not match any declaration in 'Tester'
Tester::access()
        ^~~~~~
1 error generated.

奇怪的是，当我取消注释分配和访问 param2 的代码(在上面的代码中被注释掉)时，它可以正常编译并产生所需的结果。

我做错了什么？谁能向我解释为什么包含 param2 会改变编译行为？

最佳答案

我认为这里存在一个半问题。

首先在于使用尾随返回类型实质上创建了一个模板化函数。当您尝试使用类的功能时，类的类型不能不完整。

这就是为公众移动函数定义的原因access类声明中的方法修复它(Demo)；只要公众access，该类(class)就不完整方法尚未定义，并且在类完成之前无法定义该方法。

请注意，另一种解决此问题的方法是将 access 的私有(private)版本在某种程度上是非成员函数(例如，周围范围内的自由 float 函数)。

这种方法的问题(问题的一半，因为你实际上并没有尝试这样做)是，试图调用现在免费的 float 版本 access要求编译器评估所有可能的重载，包括公共(public)模板化 access (感谢ADL)。发生这种情况时，Select<t_detail>::choice在 non-deduced context 中评估, 无法获取到实际的底层类型。

所以，如果我们都移动私有(private) access在Tester之外和 将其重命名(类似于 access2 )，然后我们可以将公开的声明和定义分开 access功能(Demo)

关于c++ - 尾随返回类型和标签分发，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35484770/