这个问题我之前也踩过坑，核心是条件运算符的类型推导规则在这儿给咱们挖了个坑，咱们一步步拆解清楚：

错误原因 #

当你写const Abstract& p = condition ? B() : input;时，C++要求条件运算符的两个分支必须能转换为同一个共同类型。这里：

• B()是一个临时的B对象
• input是const Abstract&类型的引用

编译器会尝试把两者统一转换为const Abstract类型的临时对象——但Abstract是抽象类，根本没法直接实例化，所以就触发了cannot allocate an object of abstract type的错误。

解决方案 #

方案1：用if-else替代条件运算符（最推荐，改动最小） #

条件运算符的类型限制在这里绕不开，直接用if-else可以分别处理两个分支，完全避免类型转换问题，而且不需要修改任何调用方代码：

void foo(const Abstract& input) {
    bool condition = true;
    if (condition) {
        B().f();
    } else {
        input.f();
    }
}

这个方案逻辑清晰，改动极小，完美匹配你不想修改调用方的需求。

方案2：用辅助函数绕过类型推导 #

如果想保留类似条件运算符的简洁写法，可以封装一个辅助函数，利用函数参数的引用绑定特性来避开类型转换问题：

#include <iostream>
struct Abstract { virtual void f() const = 0; };
struct A: public Abstract { void f() const { std::cout << "Aaa" << std::endl;} };
struct B: public Abstract { void f() const { std::cout << "VBB" << std::endl;} };

// 辅助函数，接收Abstract的引用并调用f
void invoke_f(const Abstract& obj) {
    obj.f();
}

void foo(const Abstract& input) {
    bool condition = true;
    condition ? invoke_f(B()) : invoke_f(input);
}

int main() {
    A a;
    foo (a);
}

这里函数invoke_f的参数是const Abstract&，会分别绑定临时的B对象和传入的input引用，不会触发抽象类实例化的问题。

方案3：使用智能指针（适合需要复用对象的场景） #

如果之后需要多次使用这个对象，而不是只调用一次f()，可以用智能指针来管理对象生命周期：

#include <iostream>
#include <memory> // 包含智能指针头文件
struct Abstract { virtual void f() const = 0; };
struct A: public Abstract { void f() const { std::cout << "Aaa" << std::endl;} };
struct B: public Abstract { void f() const { std::cout << "VBB" << std::endl;} };

void foo(const Abstract& input) {
    bool condition = true;
    std::unique_ptr<const Abstract> ptr;
    if (condition) {
        ptr = std::make_unique<B>();
    } else {
        // 用std::addressof获取input的地址，避免重载&运算符的问题
        ptr.reset(std::addressof(input));
    }
    ptr->f();
    // 之后可以继续使用ptr做其他操作
}

int main() {
    A a;
    foo (a);
}

这个方案稍微复杂一点，但适合需要多次操作目标对象的场景。

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