类的关系 继承（Inheritance）、聚合（Aggregation）和关联（Association）

前言

在面向对象编程中，类之间的关系主要有以下几种：继承（Inheritance）、聚合（Aggregation）和关联（Association）。每种关系在对象的创建和销毁时，构造函数和析构函数的调用顺序都会有所不同。下面我将分别解释这些关系，并举例说明构造函数和析构函数的调用顺序。

继承关系

继承是面向对象编程的四大特性之一，它允许一个类（派生类/子类）继承另一个类（基类/父类）的属性和方法。

构造函数和析构函数调用顺序

• 构造对象时，先调用基类的构造函数，再调用派生类的构造函数。
• 销毁对象时，先调用派生类的析构函数，再调用基类的析构函数。

示例

#include<iostream>
class Base {  
public:  
    Base() { std::cout << "Base constructor\n"; }  
    ~Base() { std::cout << "Base destructor\n"; }  
};  
  
class Derived : public Base {  
public:  
    Derived() { std::cout << "Derived constructor\n"; }  
    ~Derived() { std::cout << "Derived destructor\n"; }  
};  
  
void test()
{
    Derived d;  // 输出：Base constructor, Derived constructor  
    // 当d离开作用域时  
    // 输出：Derived destructor, Base destructor
}
int main() {  
    std::cout<<"test start\n";

    test();
    std::cout<<"test end\n";
    return 0;  
}

聚合关系

聚合是一种“拥有”关系，表示一个对象是另一个对象的组成部分。聚合通常通过包含指向其他对象的指针或引用实现。

构造函数和析构函数调用顺序

• 构造对象时，先构造被包含的对象，再构造包含它的对象。
• 销毁对象时，先销毁包含它的对象，再销毁被包含的对象。

示例

#include<iostream>
class Part {  
public:  
    Part() { std::cout << "Part constructor\n"; }  
    ~Part() { std::cout << "Part destructor\n"; }  
};  
  
class Whole {  
private:  
    Part part;  
public:  
    Whole() { std::cout << "Whole constructor\n"; }  
    ~Whole() { std::cout << "Whole destructor\n"; }  
};  
  
void test()
{
    Whole d;  // 输出：Base constructor, Derived constructor  
    // 当d离开作用域时  
    // 输出：Derived destructor, Base destructor
}
int main() {  
    std::cout<<"test start\n";

    test();
    std::cout<<"test end\n";
    return 0;  
}

关联关系

关联关系表示两个类之间的某种联系，这种联系可以是单向的也可以是双向的，通常通过指针或引用实现。

构造函数和析构函数调用顺序

• 关联关系本身并不直接决定构造函数和析构函数的调用顺序，因为这取决于具体的实现和对象的创建/销毁顺序。
• 一般来说，当你创建或销毁一个对象时，与之关联的对象的构造函数或析构函数可能在任何时刻被调用，这取决于你如何在代码中管理这些对象。

示例

#include<iostream>
class ClassA {  
public:  
    ClassA() { std::cout << "ClassA constructor\n"; }  
    ~ClassA() { std::cout << "ClassA destructor\n"; }  
};  
  
class ClassB {  
private:  
    ClassA* a;  
public:  
    ClassB() {  
        a = new ClassA(); // 输出：ClassA constructor  
        std::cout << "ClassB constructor\n";  
    }  
    ~ClassB() {  
        delete a; // 输出：ClassA destructor  
        std::cout << "ClassB destructor\n";  
    }  
};  
  
int main() {  
    ClassB b; // 输出：ClassA constructor, ClassB constructor  
    // 当b离开作用域时  
    // 输出：ClassB destructor, ClassA destructor  
    return 0;  
}

这个关联关系的示例中，ClassB内部使用了一个指向ClassA的指针。因此，在构造ClassB对象时，我们首先构造ClassA对象，然后在ClassB的构造函数体中输出自己的构造函数信息。类似地，在销毁ClassB对象时，我们首先输出自己的析构函数信息，然后销毁ClassA对象。

请注意，关联关系中的对象创建和销毁顺序完全取决于你如何在代码中实现它们。上述示例中的顺序是基于在ClassB的构造函数中创建ClassA对象，并在ClassB的析构函数中销毁它。如果你在不同的地方或不同的时间创建和销毁这些对象，那么构造函数和析构函数的调用顺序也会相应改变。

继承 ，关联， 聚合都有的时候 ，构造函数 ，析构函数的调用顺序

当一个类同时涉及到继承、关联和聚合关系时，构造函数和析构函数的调用顺序会基于这些关系的组合变得更为复杂。下面我将通过一个具体的例子来说明这种情况下的构造函数和析构函数的调用顺序。

假设我们有以下三个类：

• Base 类作为基类。
• Derived 类继承自 Base 类，同时包含一个指向 Associated 类的指针，表示关联关系。
• Associated 类包含一个 Aggregated 对象，表示聚合关系。

示例

#include<iostream>
class Aggregated {  
public:  
    Aggregated() { std::cout << "Aggregated constructor\n"; }  
    ~Aggregated() { std::cout << "Aggregated destructor\n"; }  
};  
  
class Associated {  
private:  
    Aggregated aggregated; // 聚合关系  
public:  
    Associated() { std::cout << "Associated constructor\n"; }  
    ~Associated() { std::cout << "Associated destructor\n"; }  
};  
  
class Base {  
public:  
    Base() { std::cout << "Base constructor\n"; }  
    virtual ~Base() { std::cout << "Base destructor\n"; }  
};  
  
class Derived : public Base { // 继承关系  
private:  
    Associated* associated; // 关联关系  
public:  
    Derived() {  
        associated = new Associated(); // 创建关联对象  
        std::cout << "Derived constructor\n";  
    }  
    ~Derived() {  
        delete associated; // 销毁关联对象  
        std::cout << "Derived destructor\n";  
    }  
};  
  
int main() {  
    Derived d; // 创建 Derived 对象  
    // 输出顺序：  
    // Base constructor  
    // Aggregated constructor  
    // Associated constructor  
    // Derived constructor  
  
    // 当 d 离开作用域时  
    // 输出顺序：  
    // Derived destructor  
    // Associated destructor  
    // Aggregated destructor  
    // Base destructor  
  
    return 0;  
}

在这个例子中：

1. 当创建 Derived 类的对象时：
   • 首先调用基类 Base 的构造函数。
   • 接着在 Derived 的构造函数体内，创建 Associated 类的对象。由于 Associated 类中包含一个 Aggregated 对象，因此在创建 Associated 对象时，会首先调用 Aggregated 的构造函数。
   • 然后调用 Associated 的构造函数。
   • 最后调用 Derived 的构造函数。
2. 当 Derived 的对象离开作用域时：
   • 首先调用 Derived 的析构函数。
   • 接着在 Derived 的析构函数体内，销毁 Associated 类的对象。在销毁 Associated 对象时，会首先调用 Associated 的析构函数。
   • 然后由于 Associated 类中包含一个 Aggregated 对象，所以在 Associated 的析构函数执行完后，会调用 Aggregated 的析构函数。
   • 最后调用基类 Base 的析构函数。

这个例子展示了当类之间同时存在继承、关联和聚合关系时，构造函数和析构函数的调用顺序。记住，构造函数的调用顺序是从基类到派生类，再到聚合和关联的对象；而析构函数的调用顺序则是相反的，从派生类到基类，再到聚合和关联的对象。
 

类的成员函数在类的关系中的访问权限

在C++中，类的成员函数和成员变量的访问权限通过public、private和protected三种访问修饰符控制，具体规则如下：

一、基本访问权限

1. ‌public（公有）‌

   • 成员函数/变量可被‌类内部、外部代码及派生类‌直接访问。
   • 例如：公有成员函数常作为类的接口供外部调用。

2. ‌private（私有）‌

   • 成员函数/变量仅能由‌类内部的成员函数‌访问，外部代码和派生类均无法直接访问。
   • ‌默认权限‌：若未显式指定，类成员默认为私有。

3. ‌protected（保护）‌

   • 成员函数/变量可被‌类内部及派生类的成员函数‌访问，但外部代码不可访问。
   • 适用于需要被子类继承但隐藏外部访问的场景。

二、特殊规则与示例

1. ‌默认权限差异‌

   • 类（class）成员默认私有，而结构体（struct）默认公有。
   • 示例：

     class MyClass { int var; // 默认为private }; 

2. ‌继承中的权限变化‌

   • ‌公有继承‌：基类的public/protected成员在派生类中保持原权限。
   • ‌私有继承‌：基类的public/protected成员在派生类中变为私有。
   • ‌保护继承‌：基类的public/protected成员在派生类中变为保护。

3. ‌访问权限冲突‌

   • 派生类无法直接访问基类的私有成员，即使通过公有继承。
   • 需通过基类的公有/保护成员函数间接访问。

三、总结对比