如何清晰地编写虚拟函数

如何解决如何清晰地编写虚拟函数

我对C ++很陌生，正在学习如何编写简洁的代码。 我想在下面的subrivate1mngr和derived2mngr类中重写函数manage（）。 该代码对于这两个函数是通用的，唯一的区别是用于调用该代码的对象类型。 我不想在derived1mngr和derived2mngr中复制相同的代码。 有什么建议会有所帮助吗？ 如何在基类管理中将代码分组在一起？

class Base{
    public:
    virtual void handle(){
        cout<< "handle base";
        ....//do something
    }
    void fn1() {...}
    .....
    void fn10() {...}
};

 class D1: public Base{
    public:
    void handle(){
        Base::handle();
        cout<< "D1 handle";
        ....//do something
    }
};
class D2: public Base{
    public:
    void handle(){
        Base::handle();
        cout<< "D2 handle";
        ....//do something
    }
};

class basemngr {
    public:
        virtual void manage() {
        }
        void callA() {....};
        void callB() {...};
};

class derived1mngr: public basemgr{
    public:
      void manage() {
          D1 d1;
          d1.handle();
          d1.fn1();
          d1.fn2();
          if ( d1.fn3()) {
              callA(); 
          }
         if ( d1.fn4()) {
              callB(); 
          }
        }
};

class derived2mgr{
    public:
          void manage() {
              D2 d2;
              d2.handle();
              d2.fn1();
              d2.fn2();
              if ( d3.fn3()) {
                  callA(); 
             }
             if ( d2.fn4()) {
                  callB(); 
             }
        }
};

int main ()
{
     basemgr* d1m = new derived1mgr();
     d1m-> manage();
}

解决方法

也许是这样：

class basemngr {
    public:
        virtual void manage() {
        }
        void manageImpl(Base& b) {
          b.handle();
          b.fn1();
          b.fn2();
          // ...
        }
        void callA() {....};
        void callB() {...};
};

class derived1mngr: public basemgr{
    public:
      void manage() {
          D1 d1;
          manageImpl(d1);
     }
};

,

通常来说，使用虚拟函数进行继承不是为了代码重用。模板是。

这种情况让模板感到震惊，因为正如您所指出的，除了所使用的类型外，其他功能都是相同的。

template <typename D,typename M>  
inline void manage(M& mngr) {
  D d;
  d.handle();
  d.fn1();
  d.fn2();
  if (d1.fn3()) {
    mngr.callA(); 
  }
  if (d.fn4()) {
    mngr.callB(); 
  }
}

然后可以这样调用此自由函数：

derived2mgr mngr;
manage<D2>(mngr);

请注意，您可以通过指定每个类要使用的D类型来对此进行改进：

class MyMngr {
  public:
    using D = D3;
    /* ... */
};

这将允许我们重写该函数，而无需声明要明确使用哪种D类型->出错的机会更少。

template <typename M>  
inline void manage(M& mngr) {
  typename M::D d;
  // ...
}