C++ 使用纯虚类和引用的多态性

Question

I get an error: cannot allocate an object of abstract type...

for

void foo(const Abstract& input)
{
    // just an example, this condition is returned by another function
    bool condition = true;
    // Key point: I want this decision to be done inside.
    const Abstract& p = condition ? B() : input;
    p.f();
}

I know this is not ideal as the caller should be in charge of this. But this would mean to change plenty of callers in my codebase. This is a reproducible example:

#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;}
};

void foo(const Abstract& input)
{
    // just an example, this condition is returned by another function
    bool condition = true;
    // Key point: I want this decision to be done inside.
    const Abstract& p = condition ? B() : input;
    p.f();
}

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

Answer 1

The reason this happens is a bit technical. You might know every expression in C++ has a value category : for object types, an lvalue names an existing object, a prvalue can be used to create an object of its type, and an xvalue is like an lvalue but allows the object to be moved from.

In your example, B() is a prvalue and input is an lvalue. But the conditional expression condition? B(): input condition? B(): input needs to have just one value category. This keeps the C++ language rules consistent, plus it would be impractical to define and determine how things work if an expression sometimes names an existing object and sometimes initializes a new object. So the rules for the conditional operator say that if either Y or Z is a prvalue, then X? Y: Z X? Y: Z is also a prvalue. So condition? B(): input condition? B(): input is a prvalue, which means it never actually names the existing object input , but might be used to create an object initialized from input .

And a prvalue creates objects using the expression's type. The type of X? Y: Z X? Y: Z is the "common type" of Y and Z . The common type of B and const Abstract is Abstract , since we can't guarantee that the result is a B . So the expression condition? B(): input condition? B(): input could in theory be used to create an object of type Abstract . But of course no such objects can ever be created.

Also, if we had this exact example except that class Abstract were not actually abstract, then the statement

const Abstract& p = condition ? B() : input;

would silently slice an object, and lose all the polymorphism! With condition true, it would create a temporary B , then create a temporary Abstract by slicing that B . With condition false, it would create a temporary Abstract by slicing input . In both cases, the binding to reference p would then extend the lifetime of the temporary Abstract object up to the } which ends the scope of p .

So the simplest way to get around this is probably to make sure your B object expression is an lvalue:

B b;
const Abstract& p = condition ? b : input;

Or if the default constructor of B is expensive or has undesirable side effects when it's not going to be used, maybe something like:

std::optional<B> b;
const Abstract& p = condition ? b.emplace() : input;