Question

我想在C ++中创建一个适配器类，但我想要适应的接口有几个非虚方法。我还可以使用常规适配器模式吗？

    #include <iostream>
    using namespace std;

    class  NewInterface{
    public:
      int methodA(){ cout << "A\n"; }
      virtual int methodB(){ cout << "B\n"; }
    };

    class OldInterface{
    public:
      int methodC(){ cout << "C\n"; }
      int methodD(){ cout << "D\n"; }
    };

    class Old2NewAdapter: public NewInterface {
    public:
      Old2NewAdapter( OldInterface* a ){ adaptee = a; }
      int methodA(){ return adaptee->methodC(); }
      int methodB(){ return adaptee->methodD(); }
    private:
      OldInterface* adaptee;
    };

    int main( int argc, char** argv )
    {
      NewInterface* NI = new Old2NewAdapter( new OldInterface() );
      NI->methodA();
      NI->methodB();
      return 0;
    }

如果我有这个设置，输出将是“A D”而不是“C D”。

那么如何在不重写NewInterface的情况下将OldInterface改为NewInterface，以便所有方法都是虚拟的呢？

Answer 1

你能介绍另一堂课吗？如果可以，您可以将使用NewInterface的函数替换为偶数NewerInterface：

class NewerInterface
{
public:
    int methodA()
    {
        // preconditions
        int const result = doMethodA();
        // postconditions
        return result;
    }

    int methodB()
    {
        // preconditions
        int const result = doMethodB();
        // postconditions
        return result;
    }

private:
    virtual int doMethodA() = 0;
    virtual int doMethodB() = 0;
};

class Old2NewerInterface : public NewerInterface
{
public:
    explicit Old2NewerInterface(OldInterface& x) : old_(&x)

private:
    virtual int doMethodA() { return old_->methodC(); }
    virtual int doMethodB() { return old_->methodD(); }

private:
    OldInterface* old_;
};

class New2NewerInterface : public NewerInterface
{
public:
    explicit New2NewerInterface(NewInterface& x) : new_(&x)

private:
    virtual int doMethodA() { return new_->methodA(); }
    virtual int doMethodB() { return new_->methodB(); }

private:
    NewInterface* new_;
};

C ++中的适配器模式，具有非虚拟适配方法

1 个答案: