C++ 编写具有依赖于继承成员的函数的基类的正确方法

我想从基类派生两个类，因为它们共享极其相似的函数和成员变量，这两个类之间唯一的主要区别是

SomeClass

vs

SomeOtherClass

for

algo

。解决这一问题的最佳方法是什么

class A
{
    virtual doSomething(); // is it possible to implement it here instead so I don't repeat code?
    int shared_param_1;
    int shared_param_2;
}
class SGBM : public A
{
    SGBM()
    {
        algo->SGBMSpecificFunction();
    }

    std::shared_ptr<SomeClass> algo;

    doSomething()
    {
        algo->compute();
        // long code
    }

    int SGBM_param_1;
    int SGBM_param_2;
}
class BM : public A
{
    BM()
    {
        algo->BMSpecificFunction();
    }

    std::shared_ptr<SomeOtherClass> algo;

    doSomething()
    {
        algo->compute();
        // long completely similar code relying on algo
    }

    int BM_param_1;
    int BM_param_2;
}

A类
{
virtualdosomething（）；//是否可以在这里实现它，这样我就不会重复代码了？
int shared_param_1；
int共享参数2；
}
SGBM类：公共A
{
SGBM（）
{
algo->SGBMSpecificFunction（）；
}
std：：共享算法；
doSomething（）
{
算法->计算（）；
//长代码
}
int SGBM_参数1；
int SGBM_参数2；
}
BM类：公共A
{
BM（）
{
algo->BMSpecificFunction（）；
}
std：：共享算法；
doSomething（）
{
算法->计算（）；
//依赖于algo的长的完全相似的代码
}
int BM_param_1；
int BM_param_2；
}

谢谢大家!

A类
class A
{
    virtual doSomething(); // is it possible to implement it here instead so I don't repeat code?
    void doComputing()
    {
        doSomething();
        // common code here
    }
    
    int shared_param_1;
    int shared_param_2;
}
class SGBM : public A
{
    std::shared_ptr<SomeClass> algo;
    doSomething()
    {
        algo->compute();
    }
    int SGBM_param_1;
    int SGBM_param_2;
}
class BM : public A
{
    std::shared_ptr<SomeOtherClass> algo;
    doSomething()
    {
        algo->compute();
    }
    int BM_param_1;
    int BM_param_2;
}


{
virtualdosomething（）；//是否可以在这里实现它，这样我就不会重复代码了？
void doComputing（）
{
doSomething（）；
//这里的通用代码
}
int shared_param_1；
int共享参数2；
}
SGBM类：公共A
{
std：：共享算法；
doSomething（）
{
算法->计算（）；
}
int SGBM_参数1；
int SGBM_参数2；
}
BM类：公共A
{
std：：共享算法；
doSomething（）
{
算法->计算（）；
}
int BM_param_1；
int BM_param_2；
}

我认为最常用的方法是使用，即

SomeClass

和

SomeOtherClass

将需要从公共接口派生，您将通过构造函数将算法注入基类：

class Algorithm
{
public:
  virtual ~Algorithm() = default;
  virtual void algo() = 0;
};

class SomeClass : public Algorithm
{
public:
  void algo() override;
};

class SomeOtherClass : public Algorithm
{
public:
  void algo() override;
};

class A
{
public:
  explicit A(std::unique_ptr<Algorithm> algorithm)
    : algorithm{std::move(algorithm)} {}

  void do_something() { algorithm->algo(); }
private:
  std::unique_ptr<Algorithm> algorithm;
};

class SGBM : public A
{
public:
  explicit SGBM() : A{std::make_unique<SomeClass>()} {}
};

class BM : public A
{
public:
  explicit BM() : A{std::make_unique<SomeOtherClass>()} {}
};

---

如果您需要

BM

和

SGBM

的公共基类，您需要引入一个额外的基类，

a

然后从中继承。

您试图做的是所谓的

策略设计模式。这是一种行为模式，允许您动态切换不同的算法

可以找到一个起点

您可以按如下方式实施：

#包括
#包括
//抽象算法
类算法
{
公众：
void doSomething（）{compute（）；}//调用子类的计算方法
virtual~Algo（）=默认值；
私人：
virtual void compute（）=0；//Algo:：compute（）是要在子类中实现的虚拟函数
};
SGBM类：公共算法
{
私人：
//每个算法实现自己的计算方法
void compute（）重写
{
我可以认为这是一个主要基于观点的问题吗，但您可以采取的另一种方法是将公共状态封装到类中，然后从公共状态组合类。然后使用纯虚函数创建基类。派生类可以重写该虚函数并使用公共状态。或者，可以派生“公共”从提供存储的接口创建基。algo是一个接口还是两个不同的类？如果是接口，构造函数可以实例化相应的对象。如果是两个不同的类，则必须确实使用虚拟函数。它们是两个不同的类，具有类似的函数let SomeClass和SomeOtherClass继承meBaseClass使用虚拟方法compute，类SGBM和BM很好地结合在一起。是否有一个到
SomeClass
和
SomeOtherClass
的公共接口？看起来它们只需要一个公共方法
compute
。在
CRTP
示例中
a
不应该继承自
Concrete
a
是基类。@super我已经注意到并修复了它：）
template <typename Concrete>
class A
{
public:
  void do_something() { static_cast<Concrete*>(this)->algo->compute(); }
};

class SGBM : public A<SGBM>
{
private:
    std::shared_ptr<SomeClass> algo;
    friend class A<SGBM>;
};

class BM : public A<BM>
{
private:
    std::shared_ptr<SomeOtherClass> algo;
    friend class A<BM>;
};