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，而不是让你的主Derived包含std::unique_ptr<Base> ptr，你可以设置为new derived_functions1或{{ 1}} 并在new derived_functions2 Derived和func1中实施，以致电func2和ptr->func1()。

要使所有工作正常，ptr->func2()也必须有Base，否则无法正确删除。

Answer 3

在此示例中，它不会编译，因为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();
    };
};

Answer 4

简短回答：否。类只能覆盖一次继承的虚函数。

但是，有一种设计模式可以即时交换函数的行为，称为策略模式。简而言之：具有可交换行为的类具有指向策略基类的指针，该基类定义该行为的接口。它包含具体的战略类。具有不同行为的函数只是将其调用委托给策略指针。以下是根据您的问题量身定制的示例：

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

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

4 个答案: