c++ - 派生类可以有两组虚函数吗？

Question

是否可以让派生类拥有两组与基类相同的虚函数？我正在寻找类似以下的东西。能够在两组函数指针之间进行选择的想法。

class Base
{
    virtual void func1;
    virtual void func2;
};

class Derived: Base
{
    float somemember;

    void somefunction()
    {
        Base* func = this->derived_functions1;
    }
    class derived_functions1
    {
        virtual void func1()
        {
           return somemember*100;
        }
        virtual void func2;
    };
    class derived_functions2
    {
        virtual void func1;
        virtual void func2;
    };
};

Answer 1

class Base
{
public:
    virtual void func1();

    virtual ~Base(){}
};

struct Impl1 : Base
{
    void func1() override {}
};

struct Impl2 : Base
{
    void func1() override {}
};

struct Derived :  Base
{
    Derived(std::unique_ptr<Base> implementation) :
        impl(std::move(implementation))
    {}

    void func1() override { impl->func1(); }

    void changeImpl(std::unique_ptr<Base> implementation)
    {
        impl = std::move(implementation);
    }

private:
    std::unique_ptr<Base> impl;
};

Answer 2

不是你做的那样。但是你可以让两个内部class derived_functionsX都成为它们public: Base，而不是让你的 mainDerived包含一个std::unique_ptr<Base> ptr你可以设置为new derived_functions1ornew derived_functions2 并实现 inDerived func1并func2调用ptr->func1()and ptr->func2()。

为了使所有这些正常工作，Base还必须有一个virtual ~Base() {}否则无法正确删除。

Answer 3

简短的回答：不能。一个类只能重写一次继承的虚函数。

但是，有一种设计模式可以动态交换函数的行为，称为策略模式。简而言之：具有可交换行为的类有一个指向 Strategy 基类的指针，该基类定义了该行为的接口。它填充了具体的策略类。具有不同行为的函数只是将其调用委托给 Strategy 指针。这是一个针对您的问题量身定制的示例：

class Base {
public:
    virtual void func1() = 0;
    virtual void func2() = 0;

    virtual ~Base(){}
};

#include <iostream>
#include <memory>

class Derived : public Base
{
  struct F1Strategy { 
    virtual void f1Impl() = 0; 
    virtual ~F1Strategy() {}
  };

  struct Impl1 : F1Strategy {
    void f1Impl() override { std::cout << "one!\n"; }
  };

  struct Impl2 : F1Strategy {
    void f1Impl() override { std::cout << "two?\n"; }
  };    

  std::unique_ptr<F1Strategy> f1Strategy;
public:
  Derived() 
    : f1Strategy(new Impl1())
  {}

  void func1() override { f1Strategy->f1Impl(); }

  void func2() override { 
    static std::unique_ptr<F1Strategy> otherStrategy(new Impl2());
    f1Strategy.swap(otherStrategy);
  }
};

int main() {
  std::unique_ptr<Base> pb(new Derived());
  pb->func1();  //  ==> one!
  pb->func2();  //swap
  pb->func1();  //  ==> two?
  pb->func1();  //  ==> two?
  pb->func2();  //swap
  pb->func1();  //  ==> one!
}

在行动中看到它：http: //ideone.com/zk3UTI

Answer 4

在这个例子中，它不会编译，因为derived_function1并且derived_functions2不是继承自Base.

但是你可以有这样的东西：

class Base
{
    virtual void func1();
    virtual void func2();
};

class Wrapper    {
  public:
    Wrapper(int arg)
    {
        switch(arg)
        {
        case 1:
            b = new derived_functions1;
            break;
        case 2: 
            b = new derived_functions2;
            break;
        default:
            cout << "bad value of arg" << arg << endl;
            exit(1);
        }
    }
 ~Wrapper()
 {
    delete b;
 }
 Base* GetClass()
 {
    return b;
 }
 private:
    Base *b;

    class derived_functions1: public Base
    {
        virtual void func1();
        virtual void func2();
    };
    class derived_functions2: public Base
    {
        virtual void func1();
        virtual void func2();
    };
};