c++ - 拥有类继承和拥有基类作为派生类中的数据成员之间有明显的区别吗？

Question

我对面向对象的范式还是有点陌生​​，因此关于 OOP 的一件事让我心神不宁。这听起来像是一个天真的问题，答案很明显，而且很可能是一个问题，但以下两种情况之间有什么区别:

案例一:

class A
{
public:
    A() = default; 
    A(int i) : data_point(i) {}; 
    virtual int process_data_point();

protected: 
    int data_point=0;
};

class B : public A
{
public:
    int process_data_point() override;
};

案例二:

class A
{
int data_point=0;

public:
    A() = default; 
    A(int i) : data_point(i) {}; 
    int process_data_point();
};


class B
{
public:
    A process_data_point_in_a_different_way();
    A data_point
};

我的意思是，我知道案例 1 涉及继承，它符合 OOP 的精神，但我无法逃避这样一种感觉，即人们也可以通过获取基类并定义包含数据成员的新类来模拟继承基类，具有一些附加功能(如案例 2 中所述)。我知道从长远来看模拟继承可能会变得过于复杂(特别是如果最终从数据成员类中获得一些不需要的功能)，但我希望对于一些简单的情况，继承模拟工作得很好。

有人可以更详细地说明这一点吗？关于仿真的想法本质上是不好的，还是在某些情况下有意义？

Answer 1

差异 1

在“继承”主题下还有另一个主题称为“多态性”——以相同方式关联不同对象的能力。当你使用继承的方式时，你可以做一个接口(interface)类，以后在多态的情况下使用。快速浏览一下这段代码:

class BaseClass {
public:
    virtual void action() = 0;
};

class A : public BaseClass {
public:
    void action() {
        cout << "A class" << endl;
    }
};

class B : public BaseClass {
public:
    void action() {
        cout << "B class" << endl;
    }
};

在这种情况下，我们有 3 个类。包含抽象函数“action”和两个继承类的基类。以下“main”函数展示了如何以多态方式使用它们:

int main() {
    A a;
    B b;
    vector<BaseClass*> all = vector<BaseClass*>();
    all.push_back(&a);
    all.push_back(&b);

    for (size_t i = 0; i < all.size(); i++) {
        all[i]->action();
    }
}

输出将是:

A class
B class

但是你看，我没有调用 a.action() 或 b.action() - 我在循环中调用了它们 all[i ]-> Action ()。没有继承就无法做到这一点。

差异 2

类中的“ protected ”特权仅授予类本身和继承类的访问权限。让我们看另一个例子:

class BaseClass {
private:
    void private_method() {
        cout << "Base class private method" << endl;
    }
protected:
    void protected_method() {
        cout << "Base class protected method" << endl;
    }
public:
    void public_method() {
        cout << "Base class public method" << endl;
    }
};

假设我们有这个类，它包括private_method、protected_method 和public_method。现在我们有两个不同的类。继承BaseClass的A类和包含BaseClass的B类。让我们看看我们可以在每个类中使用哪些方法:

class A : public BaseClass {
public:
    void test_privileges() {
        //this->private_method();   // Compilation error!
        this->protected_method();
        this->public_method();
    }
};

class B {
private:
    BaseClass bc;

public:
    void test_privileges() {
        //bc.private_method();      // Compilation error!
        //bc.protected_method();    // Compilation error!
        bc.public_method();
    }
};

如您所见，继承类和包含类之间存在保护差异。

差异 3

当你设计代码时，你希望它对每个人都尽可能清楚。为此，您必须在代码中保持逻辑流程。继承一个类和包含它在逻辑上是不同的。当你继承一个类时，你可以说继承人类是继承类，例如:

class Animal {};
class Dog : public Animal {};
class Cat : public Animal {};

Dog 是一种 Animal -> 所以 Dog 类必须继承 Animal 类。当你将一个类包含在另一个类中时，你可以说:The contains class have the includes class，例如:

class Tail {};
class Eye {};
class Dog {
private:
    Tail tail;
    Eye eye;
};

狗有尾部。 -> 所以 Dog 类包含 Tail 类。狗有眼睛。 -> 所以 Dog 类包含 Eye 类。