0

我有一个程序，其中有很多嵌套的 if/switch 语句，这些语句在多个地方重复。我尝试将其提取出来并将开关放在模板方法类中，然后允许客户端使用重载来重载他们想要专门处理的开关分支：

class TraitsA {};
class TraitsB : public TraitsA {};

class Foo
{
    bool traitsB;
public:
    // Whether or not a Foo has traitsB is determined at runtime. It is a
    // function of the input to the program and therefore cannot be moved to
    // compile time traits (like the Iterators do)
    Foo() : traitsB(false) {}
    virtual ~Foo() {}
    bool HasTraitsB() const { return traitsB; }
    void SetTraitsB() { traitsB = true; }
};

class SpecificFoo : public Foo
{
};

template <typename Client> //CRTP
class MergeFoo
{
protected:
    Foo DoMerge(Foo&, const Foo&, int, TraitsA)
    {
        // Do things to merge generic Foo
    }
public:
    // Merge is a template method that puts all the nasty switch statements
    // in one place.
    // Specific mergers implement overloads of DoMerge to specify their
    // behavior...
    Foo Merge(Foo* lhs, const Foo* rhs, int operation)
    {
        const Client& thisChild = *static_cast<const Client*>(this);

        SpecificFoo* lhsSpecific = dynamic_cast<SpecificFoo*>(lhs);
        const SpecificFoo* rhsSpecific = dynamic_cast<const SpecificFoo*>(rhs);

        // In the real code these if's are significantly worse
        if (lhsSpecific && rhsSpecific)
        {
            if (lhs->HasTraitsB())
            {
                return thisChild.DoMerge(*lhsSpecific, 
                               *rhsSpecific, 
                               operation,
                               TraitsB());
            }
            else
            {
                return thisChild.DoMerge(*lhsSpecific,
                               *rhsSpecific,
                               operation,
                               TraitsA());
            }
        }
        else
        {
            if (lhs->HasTraitsB())
            {
                return thisChild.DoMerge(*lhs, *rhs, operation, TraitsB());
            }
            else
            {
                return thisChild.DoMerge(*lhs, *rhs, operation, TraitsA());
            }
        }
    }
};

class ClientMergeFoo : public MergeFoo<ClientMergeFoo>
{
    friend class MergeFoo<ClientMergeFoo>;
    Foo DoMerge(SpecificFoo&, const SpecificFoo&, int, TraitsA)
    {
        // Do things for specific foo with traits A or traits B
    }
};

class ClientMergeFooTwo : public MergeFoo<ClientMergeFoo>
{
    friend class MergeFoo<ClientMergeFooTwo>;
    Foo DoMerge(SpecificFoo&, const SpecificFoo&, int, TraitsB)
    {
        // Do things for specific foo with traits B only
    }
    Foo DoMerge(Foo&, const Foo&, int, TraitsA)
    {
        // Do things for specific foo with TraitsA, or for any Foo
    }
};

但是，这无法编译（至少在ClientMergeFooTwo's 的情况下），说它不能将 Foo& 转换为 SpecificFoo&。任何想法为什么它失败了转换而不是选择完美的通用重载MergeFoo？

编辑：好吧，考虑到我尝试编写它的速度，这个伪代码示例显然做得不太好。我已经纠正了一些错误...

4

4 回答 4

2

有什么想法为什么它没有在 MergeFoo 中选择完美的通用重载而不是转换失败？

是的，因为名称隐藏规则。如果派生类中的函数与基类中的函数同名，则基类函数是“隐藏”的，它甚至不看涉及函数的参数。

也就是说，解决方案很简单：使派生类中的基类版本可用，using MergeFoo::DoMerge而公共部分中的简单部分。

于 2011-07-01T01:11:43.330 回答
0 
const thisChild& = *static_cast<const Client*>(this);

我无法理解这个？类型（或变量）在哪里？你是不是这个意思：

const Client & thisChild = *static_cast<const Client*>(this);

在下面

SpecificFoo* rhsSpecific = dynamic_cast<const SpecificFoo*>(rhs);

const-ness 不匹配，就像您忘记的目标一样const。

于 2011-06-30T23:17:30.053 回答
0 
class ClientMergeFooTwo : public MergeFoo<ClientMergeFoo>

这可能是问题的原因。

于 2011-06-30T23:18:23.883 回答
0

可以使用更多关于它失败的地方的信息，但看起来为了做你想做的事，你需要在公共合并函数中调用 Client::DoMerge() 而不是仅仅调用 DoMerge() MergeFoo 的。

于 2011-06-30T23:20:02.053 回答