Question

所以，我正在研究如何在Looking for design pattern to reduce virtual method overloads

中解决问题的解决方案

我的想法是使用可变参数模板来描述特定类可以接受哪些类型。这可能有一个小用例，但我喜欢玩模板...

这是我提出的（到目前为止）：

struct Struct
{
    virtual void doit() = 0;
};

struct StructA : Struct
{
    void doit() { std::cout << "A" << std::endl; }
};

struct StructB : Struct
{
    void doit() { std::cout << "B" << std::endl; }
};

struct StructC : Struct
{
    void doit() { std::cout << "C" << std::endl; }
};

template <typename Type>
struct Accepter
{
    void accept(const Type& t) { t.doit(); };
};

template <typename...Types>
struct MultiAccepter : Accepter<Types>... {};

当只将一种类型传递给MultiAccepter时，一切都按预期进行。只有在传递2个或更多模板参数类型时才会出现问题。看起来编译器失去了区分不同类型的能力。

int main()
{
    StructA struct_a;
    StructB struct_b;

    Accepter<StructA>                           accept_a;
    Accepter<StructB>                           accept_b;
    MultiAccepter<StructA>                      accept_multi_a;
    MultiAccepter<StructB>                      accept_multi_b;
    MultiAccepter<StructA, StructB>             accept_multi_ab;



    accept_a.accept(struct_a);              //OK
    accept_b.accept(struct_b);              //OK
    accept_multi_a.accept(struct_a);        //OK
    accept_multi_b.accept(struct_b);        //OK
    accept_multi_ab.accept(struct_a);       //NOK:
                                            //  error C2385: ambiguous access of 'accept'
                                            //      note : could be the 'accept' in base 'Accepter<StructA>'
                                            //      note : or could be the 'accept' in base 'Accepter<StructB>'
    accept_multi_ab.accept(struct_b);       //NOK:
                                            //  error C2385: ambiguous access of 'accept'
                                            //      note : could be the 'accept' in base 'Accepter<StructA>'
                                            //      note : or could be the 'accept' in base 'Accepter<StructB>'
                                            //  error C2664 : 'void Accepter<StructA>::accept(const Type &)' : cannot convert argument 1 from 'StructB' to 'const StructA &'
                                            //      with
                                            //      [
                                            //          Type = StructA
                                            //      ]
                                            //      note : Reason : cannot convert from 'StructB' to 'const StructA'
                                            //      note : No user - defined - conversion operator available that can perform this conversion, or the operator cannot be called
    return 0;
}

尝试使用gcc 5.2编译代码也不起作用： http://goo.gl/oVLHT8

我想这只是一个简单的问题，但我找不到解决方案。有人知道我做错了吗？

P.S。：此方面的示例描述了一个类似的模式： http://natsys-lab.blogspot.de/2013/07/c-variadic-templates-and-multiple.html

更新：基类Accepter<StructB>似乎定义了一个函数void accept(const StructA&)。我仍然不明白为什么会这样。

Answer 1

我使用此处描述的模式来解决问题：https://stackoverflow.com/a/28349054/1149664

诀窍是一次继承一个基类Task.Run()，然后将剩余的类型进一步推送到继承链。我还使用const方法使其保持一致。您可以根据需要随意调整。

Accepter<T0>

对可变参数模板多继承函数调用的Ambigious访问

1 个答案: