C ++：在f的派生类实现中，可以将纯虚函数f的参数x替换为x的子类型吗？

Question

Consider the following abstract class, which will be the interface for a class that writes the information carried by some object to standard output.

class FileBuilder
{
public:                                                                         
    virtual void build(const Object& object) = 0;

    virtual ~FileBuilder() = default;
};

At this point I will note that Object is also an abstract class with derived class SpecialObject . Now I am going to implement SpecialFileBuilder : FileBuilder , as follows.

class SpecialFileBuilder : public FileBuilder
{
public:                                                                         
    void build(const SpecialObject& specialObject);
};

...

void SpecialFileBuilder::build(const SpecialObject& specialObject)
{
    // Do some stuff
}

I don't fully understand why this should not be possible. SpecialFileBuilder respects the interface FileBuilder , and everywhere which expects a FileBuilder can instead be given a SpecialFileBuilder . I appreciate your help in advance.

Of course, this would work if I changed things to the following.

void SpecialFileBuilder::build(const Object& object)

However, in my implementation of SpecialFileBuilder::build() I need to use the fact that the argument is a SpecialObject , not just an Object .

How should I instead approach this design?

Answer 1

TL;DR no, this does not make any sense.

Full version below.

I don't fully understand why this should not be possible.

virtual void build(const Object& object) = 0;

This declaration is a promise . It promises that build can accept any Object as an argument. Such promises are legally binding for derived classes, ie they must implement the promise as stated by the base class. Note the declaration does not promise that build can accept some objects and not others.

FileBuilder* builder = GetBuilder(); // we don't know what kind of builder it is

SpecialObject some;
builder->build(some); // must work

OtherSpecialObject some;
builder->build(other); // must work too

UnrelatedObject whatever;
builder->build(whatever); // must work as well

Now looking at the other declaration

void build(const SpecialObject& specialObject);

It reneges on the promise. The original promise is strong. Give me any object, I can deal with it. The new promise is weak. Oh, I am a special little builder, I can only cope with special little objects!

Sorry bud, you cannot override a strong promise with a weaker one. If you were allowed to, how would we be able to trust any promise?

Now if your design doesn't fit in this outline, ie you always know what kind of builder you get, and you don't want to promise to cope with all kinds of objects, then you have selected a wrong tool for the job. Perhaps you want to give generic programming a try.

template <typename T>
class FileBuilder {
   virtual void build (const T& t) = 0;
};

class SpecialBuilder:  public FileBuilder<SpecialObject> {
   void build (const SpecialObject& t) override;
};

Now the code above won't work, we need to fix it

FileBuilder<SpecialObject>* builder = GetBuilder<SpecialObject>(); // we know exactly what we want to build

SpecialObject some;
builder->build(some); // will work;

OtherSpecialObject other;
builder->build(other); // sorry that's not in the contract, won't compile

Answer 2

I don't fully understand why this should not be possible. SpecialFileBuilder respects the interface FileBuilder, and everywhere which expects a FileBuilder can instead be given a SpecialFileBuilder

You may have covariant return type.

But for argument, you would need contra-variant return type (which is not supported in C++).

As following code should be correct

SpecialFileBuilder specialFileBuilder;
FileBuilder& fileBuilder;
SpecialObject2 specialObject2; // Other derived class, unrelated to SpecialObject
Object& object = specialObject2;

fileBuilder.build(object); // correct type
// but
specialFileBuilder.build(specialObject2); // won't compile

contra-variant parameter would be

struct Base {
    virtual void f(const Cat&) = 0;
};

struct Derived : Base
{
    void f(const Animal&) override; // if contra-variance was supported
};