6.4 子对象和堆对象

大家好，欢迎来到IT知识分享网。

6.4 子对象和堆对象

在编程中，理解子对象和堆对象的概念以及它们的使用方法，对于编写复杂和高效的程序至关重要。本节将详细讲述子对象和堆对象的定义和用法。

6.4.1 子对象

当一个类的成员是另一个类的对象时，这个对象就被称为子对象。子对象反映了两个类之间的包含关系，也称为组合关系。这是一种将复杂问题分解为多个简单问题的方法。

子对象的定义

例如：

class A { public: A(int i, int j) : A1(i), A2(j) {} void print() { cout << A1 << ", " << A2 << endl; } private: int A1, A2; }; class B { public: B(int i, int j, int k) : a(i, j), b(k) {} void print() { a.print(); cout << b << endl; } private: A a; int b; }; 

在上述例子中，类 B 中的成员 a 就是子对象，它是 A 类的对象作为 B 类的成员。

成员初始化列表

在包含子对象的类的构造函数中，通常使用成员初始化列表来初始化子对象。例如：

B(int i, int j, int k) : a(i, j), b(k) {} 

这种方法在初始化子对象和其他成员时非常有效。

示例

#include <iostream> using namespace std; class A { public: A(int i, int j) : A1(i), A2(j) { cout << "A Constructor\n"; } void print() { cout << A1 << ", " << A2 << endl; } ~A() { cout << "A Destructor\n"; } private: int A1, A2; }; class B { public: B(int i, int j, int k) : a(i, j), b(k) { cout << "B Constructor\n"; } void print() { a.print(); cout << b << endl; } ~B() { cout << "B Destructor\n"; } private: A a; int b; }; int main() { B b(6, 7, 8); b.print(); return 0; } 

执行上述程序，输出结果如下：

A Constructor B Constructor 6, 7 8 B Destructor A Destructor 

可以看到，构造函数和析构函数按顺序被调用，反映了子对象的初始化和销毁过程。

6.4.2 堆对象

堆对象是指在程序运行过程中，根据需要动态创建或销毁的对象。堆对象通常被创建在内存的空闲存储单元中，这些存储单元被称为堆。使用 new 和 delete 运算符可以动态分配和释放内存。

使用 new 运算符

new 运算符用于动态创建对象或数组，返回一个指向新创建对象的指针。

创建单个对象

格式如下：

类型* 指针名 = new 类型(参数); 

例如：

A* ptr = new A(5, 6); 

创建数组

格式如下：

类型* 指针名 = new 类型[大小]; 

例如：

int* p = new int[10]; 

使用 delete 运算符

delete 运算符用于销毁动态创建的对象，释放其占用的内存。

删除单个对象

格式如下：

delete 指针名; 

例如：

delete ptr; 

删除数组

格式如下：

delete[] 指针名; 

例如：

delete[] p; 

示例

#include <iostream> using namespace std; class A { public: A(int i, int j) : A1(i), A2(j) { cout << "Constructor.\n"; } ~A() { cout << "Destructor.\n"; } void print() { cout << A1 << ", " << A2 << endl; } private: int A1, A2; }; int main() { A* a1 = new A(1, 2); A* a2 = new A(5, 6); a1->print(); a2->print(); delete a1; delete a2; return 0; } 

执行上述程序，输出结果如下：

Constructor. Constructor. 1, 2 5, 6 Destructor. Destructor. 

动态数组

可以使用 new 创建动态数组，并用 delete[] 释放。例如：

#include <iostream> using namespace std; int main() { int* p = new int[5]; for (int i = 0; i < 5; ++i) { p[i] = i + 1; } for (int i = 0; i < 5; ++i) { cout << p[i] << " "; } cout << endl; delete[] p; return 0; } 

执行上述程序，输出结果如下：

1 2 3 4 5 

动态对象数组

同样，也可以使用 new 创建对象数组。例如：

#include <iostream> #include <cstring> using namespace std; class B { public: B(const char* s = "", double n = 0.0) { strcpy(name, s); b = n; cout << "Constructor\n"; } ~B() { cout << "Destructor " << name << endl; } void getb(char* s, double& n) const { strcpy(s, name); n = b; } private: char name[80]; double b; }; int main() { B* p = new B[3]; p[0] = B("ma", 4.8); p[1] = B("wang", 3.6); p[2] = B("li", 3.1); char s[80]; double n; for (int i = 0; i < 3; ++i) { p[i].getb(s, n); cout << s << ", " << n << endl; } delete[] p; return 0; } 

执行上述程序，输出结果如下：

Default Default Default Constructor Constructor Constructor ma, 4.8 wang, 3.6 li, 3.1 Destructor li Destructor wang Destructor ma 

通过以上内容，我们详细讨论了子对象和堆对象的定义和用法，并通过具体的示例展示了如何在程序中应用这些概念。希望这些内容能帮助读者更好地理解和使用子对象和堆对象，提高程序的可读性和效率。