前言
在面向对象编程中,类之间的关系主要有以下几种:继承(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"; }
};
int main() {
Derived d; // 输出:Base constructor, Derived constructor
// 当d离开作用域时
// 输出:Derived destructor, Base destructor
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"; }
};
int main() {
Whole w; // 输出:Part constructor, Whole constructor
// 当w离开作用域时
// 输出:Whole destructor, Part destructor
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;
}
在这个例子中:
- 当创建
Derived
类的对象时:- 首先调用基类
Base
的构造函数。 - 接着在
Derived
的构造函数体内,创建Associated
类的对象。由于Associated
类中包含一个Aggregated
对象,因此在创建Associated
对象时,会首先调用Aggregated
的构造函数。 - 然后调用
Associated
的构造函数。 - 最后调用
Derived
的构造函数。
- 首先调用基类
- 当
Derived
的对象离开作用域时:- 首先调用
Derived
的析构函数。 - 接着在
Derived
的析构函数体内,销毁Associated
类的对象。在销毁Associated
对象时,会首先调用Associated
的析构函数。 - 然后由于
Associated
类中包含一个Aggregated
对象,所以在Associated
的析构函数执行完后,会调用Aggregated
的析构函数。 - 最后调用基类
Base
的析构函数。
- 首先调用
这个例子展示了当类之间同时存在继承、关联和聚合关系时,构造函数和析构函数的调用顺序。记住,构造函数的调用顺序是从基类到派生类,再到聚合和关联的对象;而析构函数的调用顺序则是相反的,从派生类到基类,再到聚合和关联的对象。