c++ - 如何在一个类(class)中正确管理2个不同类型的容器？

Question

我有以下(有点伪)代码，它处理 2 种不同(但有点相似)类型的 2 个容器，我讨厌这些重复的添加和删除(以及我的真实代码中的 2 个搜索函数)

class PureAbstractClass
{
public:
    virtual char Func() = 0;
}

class PureOpt1 : PureAbstract
{
public:
    virtual int FOption1(A, B, C) = 0; // Notice 'C'
}

class PureOpt2 : PureAbstract
{
public:
    virtual int FOption2(A, B, D) = 0; // Notice 'D'
}

class Handler
{
public:
    void Add(PureOpt1* arg) { v1.add(arg); }
    void Add(PureOpt2* arg) { v2.add(arg); }

    // This is implemented using lambda
    // Sorry for LINQ syntax, lambdas are too long for pseudo code
    void Del1(char c) { arg = v1.find(obj => obj->Func() == c); v1.del(arg); }
    void Del2(char c) { arg = v2.find(obj => obj->Func() == c); v2.del(arg); }

    void Process(ch, A, B, C, D)
    {
        o1 = v1.Find(obj => obj->Func() == ch);

        if( null == o1 )
        {
             o2 = v2.Find(obj => obj->Func() == ch);
             if( null == o2 )
             {
                  DoSomething();
             }
             else
             {
                  o2->FOption2(A, B, D);
             }
        }
        else
        {
             o1->FOption1(A, B, C);
        }

    }

private:
    vector<PureOpt1*> v1;
    vector<PureOpt2*> v2;
}

由于 Process() 的存在，不可能将 Handler 设为模板类。

有没有更正确的方法来实现这种代码？

Answer 1

How to correctly manage 2 containers of different types in a class?

答案是只使用 1 个容器。

最简单的解决方案是在基类中使用纯虚拟方法:

class PureAbstractClass
{
public:
    virtual char Func() = 0;
    virtual int FOption(A, B, C, D) = 0; 
}

然后两个 child 都覆盖 FOption() 并忽略他们不需要的参数。可能有更好的解决方案，但您没有提供足够的信息。您的解决方案 - 将它们放在 2 个单独的容器中可能是最糟糕的。如您所见，您的解决方案 与继承冲突(您删除了继承并使两个子类都成为独立的类，并且您的代码中没有任何变化)。或者，您可以使用 dynamic_cast，但使用它通常会显示糟糕的程序设计:

PureAbstractClass *o = find( ... );
if( !o ) {
   DoSomething();
   return;
}
if( PureOpt1 *po1 = dynamic_cast<PureOpt1 *>( o ) )
     po1->FOption1( A, B, C );
else {
    if( PureOpt2 *po2 = dynamic_cast<PureOpt2 *>( o ) )
        po2->FOption2( A, B, D );
    else
       // something wrong object is not PureOpt1 nor PureOpt2
}

注意:在这种情况下，FOption1() 和 FOption2() 完全没有必要是虚拟的。而且你不应该忘记将虚拟析构函数添加到基类。

或者您可以使用 boost::variant 和 visitor patter，在这种情况下您也不需要继承，但您可以使您的代码通用。