C ++函数，返回指向抽象类的指针

Question

函数返回指向抽象类的指针是否有意义？

Answer 1

Of course, that's the whole point of polymorphism : to pass around and use pointers to abstract classes, regardless of what the concrete implementation is.

Among others, the Factory Pattern typically returns a pointer to an abstract class.

Answer 2

Yes it makes sense to manipulate pointer (or reference) to an abstract class in order to decouple the interface from the actual implementation and exploit the benefits of polymorphism .

But note that if the function is in charge of allocating the returned object (some kind of factory ), make sure to use a virtual destructor to be able to correctly delete the object from the abstract class pointer :

class Base {
  public:
    virtual ~Base() {}
};

class Derived : public Base {
  public:
    ~Derived() override {
        // Do some important cleanup
    }
};

Base* factory() {
    return new Derived;
}

Base* base = factory();
base->~Base(); // calls Derived::~Derived

Without the virtual destructor's of Base , the destructor of Derived would not have been called.

Answer 3

Yes it does make sense.
It's like using interfaces.

Answer 4

Sort of. Say you have an abstract class named AClass , with a concrete implementation called CClass . You could return a pointer to an instance of CClass which could be of type AClass* or CClass* . However, as you can't instantiate an abstract class, you can't return a pointer to an instance of an abstract class.

However, if you return AClass* , your client will only be able to access the interface of AClass ; if they want to access CClass functionality not included in the interface of AClass , they will need to cast the pointer to be CClass* .