C++ 在C++；，有没有可能；超载“；是另一个类的成员的对象？

我有一个类

驱动程序

，它基于一个成员进行一系列计算，该成员是另一个类

计算的对象。
驱动程序的标题如下所示：

// driver.hpp

#ifndef DRIVER
#define DRIVER

class driver
{
   public:

   // Making this public may be considered bad practice but this is for illustration purposes only:
   computation_A compute;

   void do_computation_1();
   void do_computation_2();
};

#endif

// driver.cpp

void driver::do_computation_1()
{
    compute.do_something;

    // use the results somehow
}

void driver::do_computation_2()
{
    compute.do_another_thing;

    // use the results somehow
}

源代码如下所示：

// driver.hpp

#ifndef DRIVER
#define DRIVER

class driver
{
   public:

   // Making this public may be considered bad practice but this is for illustration purposes only:
   computation_A compute;

   void do_computation_1();
   void do_computation_2();
};

#endif

// driver.cpp

void driver::do_computation_1()
{
    compute.do_something;

    // use the results somehow
}

void driver::do_computation_2()
{
    compute.do_another_thing;

    // use the results somehow
}

实际上，源代码很大，包含许多对
compute
成员的调用

现在，我希望
driver
能够支持另一种计算类，
computation\u B
，基于一些运行时标准，例如布尔开关
bool use\u B
。
computation\u B
将具有与
computation\u A
相同的函数名，但功能不同（例如，
computation\u A
和
computation\u B
都源自抽象类
computation
——我在这里有一些灵活性）

此外，
driver.cpp
中的所有后续函数调用都是相同的。例如，如果
use\u B
设置为
true
（可能在
Initialize
方法中），则
compute.do\u在
driver:：do\u computation\u 1
中执行
computation\u B
中定义的操作。换句话说，在
driver.cpp
中实际上没有任何变化，它只是调用了所有相同的函数，但属于不同的类

我想我正在寻找一种超负荷
计算的方法

有没有一种方法可以让我在不对driver.cpp进行重大更改的情况下实现这一点？我不介意更改
driver.hpp
，但直觉上我觉得我不应该重写
driver.cpp
中所有相同的函数

作为解决方案，首先想到的是以某种方式使用模板。但我不知道怎么做。我的理解是模板在编译时起作用，但是
use\B
的值直到运行时才知道（例如，它是用户输入）

另一个选项是将
compute
声明为指向抽象类
computement
的指针。然后，根据
use\B
，将
compute\u A
或
compute\u B
类的成员分别指向
compute\u A
或
compute\u B
。这需要我将所有函数调用
compute.do…
更改为
compute->do…
。我想这很容易做到，但我想知道是否有更好的解决方案（我不是一个经验丰富的程序员，我发现总有比我认为的好方法更好的方法……）

谢谢。
有很多不同的方法。下面是一些针对低数量的
driver.cpp文件中的更改。请注意，形式是非常简洁和骨架

案例1——您知道编译时的类型。简单的基于模板的解决方案

    struct mult
    {
        int a; 
        double do_work(int b) { return a * b; }
    };
    struct add
    {   
        double a;
        double do_work(int b) { return a + b;}
    };
    template <class C> struct driver
    {
        C c;
        int x; 
        void foo() { std::cout << c.a << "|" << c.do_work(x) << "\n"; }
    };

// ...

    driver<add> a(1);
    driver<mult> m(1.0);
    a.x = 10;
    m.x = 20;
    a.foo();
    m.foo();

子类A--您不需要将add/mult保存在驱动程序中（99%的情况下）

struct驱动程序
{
驱动程序（inti）：c（std:：make_unique（i））{
驱动程序（双d）：c（std:：make_unique（d））{
//如果需要可复制性，则视情况而定
//添加复制构造函数或将uniqe_ptr替换为共享_ptr
std：：唯一的ptr c；
int x；
void foo（）{std:：cout a（）~base（）；}；
};
结构驱动程序
{
驱动程序（inti）：c（i）{}
驱动程序（双d）：c（d）{}
amu-c；
int x；
void foo（）{std:：cout a（），这正是多态性所指的情况类型。您已经提到了解决方案-“可能
计算\u a
和
计算\u B
都源自抽象类
计算
”将
compute
变成一个
computation*
指针，根据需要指向
computation\u a
或
computation\u B
对象。这正是多态性发明的目的。事实上，当我读你的帖子时，我以为你是在设置问题，以便自己回答（这没问题）你需要做一个指针或引用，尽管它看起来是有效的。我的问题的原因似乎是有答案（除了怀疑是否有更好的答案），一个比我更有经验的同事反复告诉我：“如果你使用C++，永远不要使用指针”。这常常让我感到困惑。不过，谢谢你的评论，我现在对这个解决方案更有信心了。唉，经验丰富的程序员并不总是知道他们在说什么。“从不使用指针”应该是“避免使用拥有的原始指针”。
std:：unique\u ptr
（或者
std:：shared_ptr
如果你真的需要共享所有权）就是答案。
    union amu // this exposes a and m, you may want encapsulate amu in class
    {
        add a;
        mult m;
        amu(int i) : a(i) {};
        amu(double d) : m(d) {};
        base& operator*() {return *static_cast<base*>(&a);}
        base* operator->() {return static_cast<base*>(&a);}
        ~amu() {static_cast<base*>(&a)->~base();};
    };

    struct driver
    {
        driver(int i) : c(i) {}
        driver(double d) : c(d) {}
        amu c;
        int x;
        void foo() { std::cout << c->a() << "|" << c->do_work(x) << "\n"; }
    }