C++中能否声明抽象类型变量？如何简化派生类调用逻辑？

我有一段C++代码，其中BaseType是抽象类，代码使用switch语句在不同case中实例化不同派生类，并调用FunctionThatTakesBaseType函数：

switch (foo)
{
    case 1:
    {
        SomeDerivedType t = SomeDerivedType(); //实例化某个派生类
        FunctionThatTakesBaseType(t);   //传递给该函数
        break;
    }
    case 2:
    {
        SomeOtherDerivedType t = SomeOtherDerivedType(); //实例化另一个派生类
        FunctionThatTakesBaseType(t);          //传递给同一函数
        break;
    }
    case 3:
    {
        ...
    }
}

在C#中，我可以更简洁地实现：在switch外声明基类变量，内部赋值后统一调用函数，代码如下：

BaseType t;  //声明在switch作用域外，以便后续统一调用函数
switch (foo)
{
case 1:
    t = new SomeDerivedType();
    break;
case 2:
    t = new SomeOtherDerivedType();
    break;
case 3:
    ...
}
FunctionThatTakesBaseType(t);

请问C++中能否实现类似写法？如何在外部作用域声明抽象类型变量，并在内部作用域赋值为具体派生类？是否必须使用堆分配的指针？直接声明Base t;会报错（尝试实例化抽象基类），而Base* t;是否只能通过堆分配赋值？

C可以实现类似逻辑，但因C与C#的类型模型差异（C#变量是引用类型，C++栈对象是值类型），无法直接照搬C#写法，以下是几种可行方案：

核心逻辑说明 #

C#中BaseType t;是引用变量，仅指向堆上的派生类对象，不存储实例本身；而C++中BaseType t;是直接在栈上创建BaseType实例，但抽象类含纯虚函数无法实例化，因此报错。要实现统一调用，必须通过指针或引用间接指向派生类对象。

方式1：使用智能指针（推荐，自动管理内存） #

借助C++11引入的std::unique_ptr托管堆上的派生类对象，既避免手动释放内存的风险，又能实现统一调用：

#include <memory>

std::unique_ptr<BaseType> t;
switch (foo) {
    case 1:
        t = std::make_unique<SomeDerivedType>();
        break;
    case 2:
        t = std::make_unique<SomeOtherDerivedType>();
        break;
    // 必须处理默认情况，避免t为空导致后续调用崩溃
    default:
        throw std::invalid_argument("无效的foo值");
}
// 若FunctionThatTakesBaseType接受BaseType&，则解引用指针
FunctionThatTakesBaseType(*t);
// 若函数接受BaseType*，直接传递原始指针
// FunctionThatTakesBaseType(t.get());

方式2：使用裸指针（不推荐，需手动管理内存） #

若项目不支持C++11及以上，可使用裸指针，但必须手动释放内存，否则会造成内存泄漏：

BaseType* t = nullptr;
switch (foo) {
    case 1:
        t = new SomeDerivedType();
        break;
    case 2:
        t = new SomeOtherDerivedType();
        break;
    default:
        break;
}
// 调用前必须检查指针是否为空
if (t != nullptr) {
    FunctionThatTakesBaseType(*t);
    delete t; // 手动释放堆内存
}

方式3：使用std::variant（C++17及以上，值语义场景适用） #

如果派生类类型固定且有限，可使用std::variant存储派生类对象，通过std::visit统一调用函数，这种方式无需堆分配，但要求派生类支持拷贝构造：

#include <variant>

std::variant<SomeDerivedType, SomeOtherDerivedType> t;
switch (foo) {
    case 1:
        t = SomeDerivedType();
        break;
    case 2:
        t = SomeOtherDerivedType();
        break;
    default:
        throw std::invalid_argument("无效的foo值");
}
// 用std::variant遍历对象并调用函数
std::visit([](auto& obj) { FunctionThatTakesBaseType(obj); }, t);

针对疑问的补充说明 #

1. 能否直接声明抽象基类变量？
   不能。C++中值类型变量必须是可实例化的类型，抽象类因含纯虚函数无法实例化，因此BaseType t;必然报错。

2. Base t是否只能通过堆分配赋值？*
   不是。理论上可以让指针指向栈上的派生类对象，但栈对象的生命周期必须覆盖后续调用范围，例如：

   SomeDerivedType d1;
   SomeOtherDerivedType d2;
   BaseType* t = nullptr;
   switch (foo) {
       case 1: t = &d1; break;
       case 2: t = &d2; break;
   }
   FunctionThatTakesBaseType(*t);
   

   但这种写法需要提前创建所有可能的派生类对象，既浪费内存又不灵活，实际开发中极少使用，因此通常优先选择堆分配配合智能指针的方案。

内容的提问来源于stack exchange，提问作者Todd Burch