如何在当前作用域内按条件在栈上创建对象？

问题场景 #

我需要在当前作用域内，根据条件在栈上创建不同的派生类对象，但直接用三元表达式的写法无法运行：

bool doBase=true;
doBase ? Base obj() : Derived obj();
obj.print();

如果用if/else实现，又会导致print相关的10-50行代码重复：

bool doBase=true;
if (doBase) { 
  Base obj;
  obj.print(); // 这里是大量重复代码
} else { 
  Derived obj;
  obj.print(); // 重复的代码块
}

希望找到无需动态分配的解决方案。

可行方案 #

1. 使用std::variant（C++17及以上）

std::variant可以在栈上存储不同类型的对象，无需堆分配，结合std::visit能统一处理不同类型的对象调用：

#include <iostream>
#include <variant>

class Base {
public:
    virtual void print() { std::cout << "In base" << std::endl; }
    virtual ~Base() = default; // 基类必须加虚析构保证安全
};

class Derived : public Base {
public:
    void print() override { std::cout << "In derived" << std::endl; }
};

int main() {
    bool doBase = true;

    // 根据条件创建variant对象
    auto obj = doBase ? std::variant<Base, Derived>(Base{}) : std::variant<Base, Derived>(Derived{});
    // 统一调用print逻辑
    std::visit([](auto& obj) { 
        obj.print();
        // 这里可以添加所有10-50行的相关代码
    }, obj);

    doBase = false;
    auto obj2 = doBase ? std::variant<Base, Derived>(Base{}) : std::variant<Base, Derived>(Derived{});
    std::visit([](auto& obj) { obj.print(); }, obj2);
}

• 优势：类型安全，无堆分配，代码简洁，避免重复
• 注意：需要C++17及以上版本支持，基类必须有虚析构

2. 用Lambda封装重复逻辑（兼容旧C++标准）

如果项目不能用C++17，把重复的业务逻辑封装到lambda里，在分支中调用即可：

#include <iostream>

class Base {
public:
    virtual void print() { std::cout << "In base" << std::endl; }
};

class Derived : public Base {
public:
    void print() override { std::cout << "In derived" << std::endl; }
};

int main() {
    bool doBase = true;

    // 把所有重复代码放到这里
    auto process_object = [](Base& obj) {
        obj.print();
        // 这里添加10-50行的相关操作
    };

    if (doBase) {
        Base obj;
        process_object(obj);
    } else {
        Derived obj;
        process_object(obj);
    }

    doBase = false;
    if (doBase) {
        Base obj2;
        process_object(obj2);
    } else {
        Derived obj2;
        process_object(obj2);
    }
}

• 优势：兼容C++11及以上，代码结构清晰，无堆分配
• 注意：利用多态特性，确保基类的方法是虚函数

3. Placement New（底层场景可选，不推荐）

手动在栈上分配内存，用placement new构造对象，最后手动调用析构函数。这种方法繁琐易出错，仅适合底层开发场景：

#include <iostream>
#include <cstddef>

class Base {
public:
    virtual void print() { std::cout << "In base" << std::endl; }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void print() override { std::cout << "In derived" << std::endl; }
};

int main() {
    bool doBase = true;

    // 分配足够容纳最大类的栈内存，保证对齐
    alignas(std::max_align_t) char buffer[std::max(sizeof(Base), sizeof(Derived))];
    Base* obj;

    // 根据条件构造对象
    if (doBase) {
        obj = new(buffer) Base();
    } else {
        obj = new(buffer) Derived();
    }

    obj->print();
    // 手动调用析构函数
    obj->~Base();

    doBase = false;
    alignas(std::max_align_t) char buffer2[std::max(sizeof(Base), sizeof(Derived))];
    Base* obj2;

    if (doBase) {
        obj2 = new(buffer2) Base();
    } else {
        obj2 = new(buffer2) Derived();
    }

    obj2->print();
    obj2->~Base();
}

• 优势：完全手动控制内存，无堆分配
• 劣势：需要手动管理构造/析构，容易因内存对齐或析构遗漏导致bug

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