当前位置：文档之家 › c++单继承的构造函数与析构函数

c++单继承的构造函数与析构函数

  • 格式：ppt
  • 大小：454.00 KB
  • 文档页数：39

下载文档原格式

  / 39

合集下载

vs构造函数和析构函数

vs构造函数和析构函数

vs构造函数和析构函数在Visual Studio 中，构造函数（Constructor）和析构函数（Destructor）是用于创建和销毁对象的特殊成员函数。

它们在类的生命周期中扮演着重要的角色。

以下是构造函数和析构函数的基本概念和用法：构造函数（Constructor）：构造函数是在对象被创建时调用的特殊成员函数。

它的主要目的是初始化对象的成员变量、分配资源或执行其他必要的初始化操作。

构造函数的名称与类名相同，没有返回类型。

class MyClass {public:// 构造函数MyClass() {// 这里可以进行初始化操作// 例如：初始化成员变量、分配资源等}// 其他成员函数和变量};在 Visual Studio 中，你可以定义多个构造函数，包括带有参数的构造函数，以支持不同的对象初始化方式。

析构函数（Destructor）：析构函数是在对象被销毁时调用的特殊成员函数。

它的主要目的是清理对象使用的资源、执行必要的清理操作等。

析构函数的名称是在类名前面加上波浪线 ~。

class MyClass {public:// 构造函数MyClass() {// 构造函数的初始化操作}// 析构函数~MyClass() {// 这里可以进行清理操作// 例如：释放资源等}// 其他成员函数和变量};在 Visual Studio 中，析构函数通常用于确保在对象销毁时进行资源清理，防止资源泄漏。

在使用Visual Studio 编写C++ 代码时，构造函数和析构函数的创建方式与标准 C++ 的方式相同。

请注意，构造函数和析构函数的调用是自动进行的，程序员不需要手动调用它们。

构造函数在对象创建时被自动调用，析构函数在对象销毁时被自动调用。

C++ 第3章类和构造函数

C++ 第3章类和构造函数
四、类内初始化顺序 初始化的顺序如下：首先topLeft的构造函数被调用，接着调用botRight的构造函数，最后 调用Rectangle的构造函数。 TopLeft初始化在botRight之前的原因不是因为：在成员初始化表中，TopLeft位于botRight之 前，而是因为在Rectangle类的定义中，TopLeft位于botRight之前。
1、类定义的一般形式如下： class Name { public:
类的公有函数
private: 私有的成员函数
私有的数据成员定义
}; <各个成员函数的实现> 注意：类的定义也是一个语句，所以要有分号结尾，否则，会产生难以理解的编 译错误。 2、类中的成员： 1． 数据成员，类的数据。 2． 成员函数，类的操作。
25
成员初始化表
class Image { public: Image(const int w, const int h); private: const int width; const int height; //... }; Image::Image (const int w, const int h) : width(w), height(h) { }
21
再讲访问权限
类成员有三种不同的访问权限： 1． 公有（public）成员可以被程序中任何代码访问。 2． 私有（private）成员只能被该类的成员函数及友元类的成员函数访问， 其它类及其子类的成员函数都不能访问。 3． 保护（protected）成员只能被该类的成员函数和说明为友元类的成员 函数访问，或子类的成员函数访问。 注意： 1.如果未指定类成员的访问权限，默认访问权限是私有的 2.数据成员和成员函数出现的顺序也没有关联

单例的构造函数和析构函数

单例的构造函数和析构函数

单例的构造函数和析构函数单例模式是一种常用的设计模式，其目的是保证一个类只有一个实例，并提供一个全局访问点。

在实际开发中，我们经常需要使用单例模式来管理全局资源，例如日志、数据库连接等。

在本文中，我们将介绍单例模式的构造函数和析构函数的实现方法。

首先，我们需要了解什么是单例模式以及它的特点。

一、什么是单例模式单例模式（Singleton Pattern）是一种常用的软件设计模式。

它保证一个类只有一个实例，并提供一个全局访问点。

二、单例模式的特点1. 单例类只有一个实例对象；2. 该实例对象由单例类自行创建；3. 单例类必须向外界提供访问该实例对象的方法；4. 单例类可以有多个方法，这些方法操作该实例对象。

三、构造函数和析构函数1. 构造函数构造函数是一种特殊的成员函数，在创建对象时被调用。

它负责初始化对象的成员变量，并为对象分配内存空间。

在单例模式中，由于只有一个实例对象，因此需要对构造函数进行特殊处理。

下面是一个简单的示例代码：```class Singleton {private:static Singleton* instance;Singleton() {}public:static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}};```在上面的代码中，我们定义了一个静态成员变量`instance`，并将构造函数设为私有。

这样就保证了只有单例类自己可以创建实例对象。

同时，我们定义了一个静态方法`getInstance()`，用于获取单例对象。

在该方法中，我们首先判断实例对象是否已经创建，如果没有，则创建一个新的实例对象并返回。

2. 析构函数析构函数是一种特殊的成员函数，在对象被销毁时被调用。

它负责释放对象占用的内存空间，并清理对象所持有的资源。

c++ 单例析构

c++ 单例析构

在C++中，单例是一种设计模式，用于确保一个类只能有一个实例。

析构函数是一个特殊的成员函数，用于清理对象分配的资源和执行其他必要的清理操作。

当使用单例模式创建的对象不再需要时，应该调用析构函数来释放资源并销毁对象。

然而，在单例模式中，由于只有一个实例存在，不能直接调用析构函数来销毁对象，否则将无法再次创建新的实例。

为了解决这个问题，可以使用"延迟销毁"的方法，即在程序退出时自动销毁单例对象。

可以通过在单例类中添加一个静态成员函数，用于获取唯一的实例，并在该函数内部定义一个静态局部变量作为实例的引用。

当程序退出时，静态局部变量会自动销毁，从而调用析构函数。

以下是一个示例代码，展示了如何在C++中实现单例模式的析构：```cppclass Singleton {public:// 获取唯一实例的静态成员函数static Singleton& getInstance() {static Singleton instance;return instance;}private:// 私有构造函数，防止外部实例化Singleton() {}// 析构函数~Singleton() {// 执行清理操作}// 禁用拷贝构造函数和赋值运算符Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;};int main() {// 获取单例实例Singleton& instance = Singleton::getInstance();// 使用单例对象...return 0;}```在上面的示例代码中，通过Singleton::getInstance()获取唯一的实例。

当程序退出时，静态局部变量instance会自动销毁，调用析构函数对资源进行清理操作。

基类和派生类

基类和派生类
这里说的访问来自两个方面：一是派生类中的新增成 员对从基类继承来的成员的访问；二是在派生类外部通 过派生类的对象对从基类继承来的成员的访问。
5
(1)公有继承（public）
当类的继承方式为公有继承时，基类的公有和保 护成员的访问属性在派生类中不变，而基类的私有 成员不可访问，
即基类的公有成员和保护成员被继承到派生类中 仍作为派生类的公有成员和保护成员，派生类的其 他成员可以直接访问它们。
具体赋值规则如下: 派生类的对象可以赋值给基类对象。 派生类的对象可以初始化基类对象的引用。 派生类对象的地址可以赋给指向基类对象的 指针。
15
例如： class A{...};
class B: public A
{void fun() {...}}; A a; B b; a=b; //将对象b中所含类A成员的值赋给对象a A &a1=b; //用派生类对象初始化基类对象的引用 A *pa =&b;
22
基类名1,继承方式2 基类名2,… {…} ;
{ 派生类类体
class C : public
};
A , private B
多重继承允许一个派生类同时继 {…} ; // C 公有
承多个基类中的成员，支持了软件 继承 A，私有继
的重用性，但也可能带来大量的二 承 B
义性问题。 17
复合与继承在软件渐增式开发中的应用
10
3.在派生类中重定义基类的函数
派生类自动继承了基类中定义的数据成员和成员函数。 如果派生类认为基类中某个成员函数的实现不能满足需 要，可以在派生类中重新定义该函数。
重定义基类的成员函数需要使用和该函数相同的函数 名和参数列表，如果参数列表不同，就是函数重载而不 是函数的重定义了。

构造函数的常见分类

构造函数的常见分类

构造函数的常见分类构造函数是面向对象编程中的一个重要概念，用于创建对象时初始化对象的成员变量。

构造函数根据不同的特点和功能可以被分为以下几类：1. 默认构造函数 (Default Constructors)默认构造函数是一种没有参数的构造函数，它在创建对象时会自动被调用。

如果一个类没有定义任何构造函数，编译器会自动为该类生成一个默认构造函数。

默认构造函数会将对象的成员变量设置为默认值，例如对于整型变量，默认值为0。

2. 带参数构造函数 (Parameterized Constructors)带参数构造函数是一种接受参数的构造函数，它允许在创建对象时初始化对象的成员变量。

通过在构造函数中传递参数，可以根据需要来设置对象的成员变量，提供了更灵活的对象创建方式。

3. 拷贝构造函数 (Copy Constructors)拷贝构造函数是一种接受同类型对象作为参数的构造函数，用于创建一个新对象并将传递的对象的值拷贝给新对象。

拷贝构造函数通常用于实现对象的深复制，以避免对象之间的浅复制引发的问题。

4. 移动构造函数 (Move Constructors)移动构造函数是C++11引入的一种特殊构造函数，用于实现资源的移动和所有权的转移。

移动构造函数接受同类型右值引用作为参数，将其值转移给新对象，并将原对象的值置为可安全销毁状态，避免进行不必要的拷贝操作，提高程序的性能效率。

5. 析构函数 (Destructors)析构函数是用于销毁对象的特殊函数，它在对象的生命周期结束时被自动调用。

析构函数用于清理对象所占用的资源，例如释放动态分配的内存、关闭打开的文件等，确保程序的稳定性和资源的正确释放。

不同类型的构造函数在对象的创建和销毁过程中发挥着不同的作用，为程序的正确运行和资源的有效管理提供了重要保障。

课课家教育-c++从入门到精通

课课家教育-c++从入门到精通c++98/11/14/17视频教程课程目标：本课程需要有基本的c语言基础，目标是希望通过学习，让我们对c 语言有一个比较全面的掌握，包括对c 98老标准、以及对c 11/14/17新标准的掌握，课程主要讲解定位在针对c 语言本身各种语法用法的讲解，通过学习，让大家更从容的应对c 开发工作岗位。

适合人群：对C语言有一定的掌握希望学习c语言或对C++98已经很熟，希望学习C++11/14/17新标准目录章节1c++语言课程介绍第1节c++ 语言课程详细介绍本节，老师要讲解如下这些内容：（1）总述以及基础要求；（2）简要自我介绍；（3）c++语言难度和就业问题；（4）c/c++语言的发展历程；（5）我们这门课程的讲解遵循哪个c++标准？（6）c++学习之道和学习忠告；（7）开发环境安装和设置；章节2基本语言第1节语言特性、工程构成、可移植性命名空间简介、基本输入输出精解本节课，老师要讲解如下话题：（1）命名空间概念简介；（2）基本输入输出cin、cout精解；第3节auto、头文件防卫、引用、常量本节课，老师要讲解如下话题：（1）局部变量及初始化；（2）auto；（3）头文件防卫式声明；（4）引用；（5）常量；第4节范围for、new内存动态分配、nullptr结构、权限修饰符、类简介函数新特性、内联函数、const详解01:43:17string类型介绍01:05:38vector类型介绍01:10:13本节课，老师要讲解如下话题：（1）vector类型简介；（2）定义和初始化vector对象；（3）vector对象上的操作；（3.1）范围for进一步讲解；第9节迭代器精彩演绎，失效分析及弥补、实战01:53:25类型转换：static_cast、reinterpret_cast等01:07:22类第1节成员函数、对象拷贝、私有成员00:54:47本节课，老师要讲解如下话题：（1）综述；（2）类基础；（3）成员函数；（4）对象的拷贝；（5）私有成员；第2节构造函数详解，explicit，初始化列表01:23:39inline、const、mutable、this、static01:23:49本节课，老师要讲解如下话题：（1）在类定义中实现成员函数inline（2）成员函数末尾的const（3）mutable（4）返回自身对象的引用，this（5）static成员第4节类内初始化、默认构造函数、=default;00:51:45拷贝构造函数00:46:50本节课，老师要讲解如下话题：（1）拷贝构造函数；第6节重载运算符、拷贝赋值运算符、析构函数01:13:09派生类、调用顺序、访问等级、函数遮蔽01:04:20基类指针、虚纯虚函数、多态性、虚析构01:32:57友元函数、友元类、友元成员函数00:47:42RTTI、dynamic_cast、typeid、虚函数表01:13:02基类与派生类关系的详细再探讨00:57:55左值、右值，左值引用、右值引用、move 01:46:31临时对象深入探讨、解析，提高性能手段01:30:28对象移动、移动构造函数、移动赋值运算符01:56:55继承的构造函数、多重继承、虚继承02:00:49本节课，老师要讲解如下话题：（1）继承的构造函数（2）多重继承(2.1)多重继承概述(2.2)静态成员变量(2.3)派生类构造函数与析构函数(2.4)从多个父类继承构造函数（3）类型转换（4）虚基类，虚继承（虚派生）（5）总结第16节类型转换构造函数、运算符，类成员指针01:57:00模板与泛型第1节模板概念，函数模板定义、调用01:10:40类模板概念，类模板定义、使用00:55:05用typename场合、默认模板参数、趣味写法分析01:12:23成员函数模板，显式实例化、声明00:50:34using定义模板别名，显式指定模板参数00:49:22本节课，老师要讲解如下话题：（1）using定义模板别名（2）显式指定模板参数第6节模板全特化、偏特化(局部特化)01:07:37智能指针第1节直接内存管理(new/delete)、创建新工程观察内存泄漏01:10:14本节课，老师要讲解如下话题：（1）直接内存管理(new/delete)（2）创建新工程，观察内存泄漏第2节new、delete探秘，智能指针概述、shared_ptr基础01:55:16shared_ptr常用操作、计数、自定义删除器等等01:56:26weak_ptr概述、weak_ptr常用操作、尺寸01:00:54本节课，老师要讲解如下话题：（1）weak_ptr概述（1.1）weak_ptr的创建shared_ptr使用场景、陷阱、性能分析、使用建议01:40:25本节课，老师要讲解如下话题：（1）std::shared_ptr使用场景（2）std::shared_ptr使用陷阱分析（2.1）慎用裸指针（2.2）慎用get()返回的指针（2.3）不要把类对象指针(this)作为shared_ptr返回，改用enable_shared_from_this（2.4）避免循环引用（3）性能说明（3.1）尺寸问题（3.2）移动语义（4）补充说明和使用建议第6节unique_ptr概述、常用操作00:58:28本节课，老师要讲解如下话题：（1）unique_ptr概述（1.1）常规初始化（unique_ptr和new配合）（1.2）make_unique函数（2）unique_ptr常用操作（2.1）unique_ptr不支持的操作（2.2）移动语义（2.3）release()（2.4）reset()（2.5）= nullptr（2.6）指向一个数组（2.7）get()（2.8）*解引用（2.9）swap()（2.10）智能指针名字作为判断条件（2.11）转换成s第7节返回unique_ptr、删除器、尺寸、智能指针总结00:57:55并发与多线程第1节并发基本概念及实现，进程、线程基本概念01:13:44线程启动、结束，创建线程多法、join，detach 01:24:45本节课，老师要讲解如下话题：（1）范例演示线程运行的开始和结束（1.1）thread（1.2）join()（1.3）detach()线程传参详解，detach()大坑，成员函数做线程函数01:45:26创建多个线程、数据共享问题分析、案例代码00:56:36互斥量概念、用法、死锁演示及解决详解01:24:46本节课，老师要讲解如下话题：（1）互斥量（mutex）的基本概念（2）互斥量的用法（2.1）lock()，unlock()（2.2）std::lock_guard类模板（3）死锁（3.1）死锁演示（3.2）死锁的一般解决方案（3.3）std::lock()函数模板（3.4）std::lock_guard的std::adopt_lock参数第6节unique_lock详解01:25:02单例设计模式共享数据分析、解决，call_once 01:17:03本节课，老师要讲解如下话题：（1）设计模式大概谈（2）单例设计模式（3）单例设计模式共享数据问题分析、解决（4）std::call_once()第8节condition_variable、wait、notify_one、notify_all 01:29:48async、future、packaged_task、promise01:47:46future其他成员函数、shared_future、atomic 01:37:48std::atomic续谈、std::async深入谈01:04:10windows临界区、其他各种mutex互斥量01:11:40补充知识、线程池浅谈、数量谈、总结00:56:55本节课，老师要讲解如下话题：（1）补充一些知识点（1.1）虚假唤醒（1.2）atomic（2）浅谈线程池（2.1）场景设想（2.2）实现方式（3）线程创建数量谈（4）c++11多线程总结章节7未归类知识点第1节函数调用运算符、function类模板01:00:44万能引用universal reference00:51:35理解模板类型推断、查看类型推断结果01:15:42引用折叠，转发、完美转发，forward 02:18:17理解auto类型推断，auto应用场合01:34:34详解decltype含义，decltype主要用途01:51:56本节课，老师要讲解如下话题：（1）decltype含义和举例（1.1）decltype后的圆括号中是个变量（1.2）decltype后的圆括号中非变量（是表达式）（1.3）decltype后的圆括号中是函数（2）decltype主要用途（2.1）应付可变类型（2.2）通过变量表达式抽取变量类型可调用对象、std::function、std::bind01:50:43本节课，老师要讲解如下话题：（1）可调用对象（1.1）函数指针（1.2）具有operator()成员函数的类对象（仿函数）（1.3）可被转换为函数指针的类对象（1.4）类成员函数指针（1.5）总结（2）std::function(可调用对象包装器)（2.1）绑定普通函数（2.2）绑定类的静态成员函数（2.3）绑定仿函数（2.4）小范例演示（3）std::bind绑定器（4）总结第8节lambda表达式，for_each、find_if简介01:38:26lambda表达式捕获模式的陷阱分析和展示00:52:37可变参数函数、initializer_list、省略号形参01:00:30内存高级话题第1节new、delete的进一步认识00:38:37本节课，老师要讲解如下话题：（1）总述与回顾（2）从new说起（2.1）new类对象时加不加括号的差别（2.2）new干了啥（2.3）malloc干了啥（2.4）总结学员评价课程网址：/course-5713.html。

C++试题

判断题1构造函数、析构函数、友元函数都属于类的成员函数。

2静态数据成员是类的所有对象共享的数据。

3 可以将派生类的对象的值赋给基类对象，也可以将基类对象的值赋给派生类对象。

4 派生类默认的继承方式为public。

5 类模板实例化的过程是类模板->模板类->对象。

6 多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。

7 构造函数可以重载，析构函数也可以重载。

8 如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同，那么，这个函数自动继承基类中虚函数的特性。

9 设A为类，则A类的复制构造函数原型声明为void A(A&)。

10 在公有继承中，基类中只有公有成员对派生类是可见的。

11 在公有继承中，基类的公有成员和私有成员在派生类中都是可见的。

12 虚基类是用来解决多继承中公共基类在派生类中只产生一个基类子对象的问题。

13 派生类是从基类派生出来，他不能生成新的派生类。

14 当一个对象调用成员函数时，编译程序先将对象的地址赋值给this指针后，再调用成员函数。

15 对象是属性和行为的集合。

16 模板的使用是为了加强类的封装性。

17 函数定义时在函数参数表后加=0表示该函数为纯虚函数。

18 可以以”类名：：静态成员函数（实参表）”和“对象.静态成员函数（形参表）”两种形式调用类的静态成员函数。

19 语句Int a(5),*p； *p=a;能够正常执行。

20 设A为类，则A *（*fpA[5]）()的正确描述是：fpA是一个数组，数组的5个元素都是A类对象。

21 重载双目运算符为成员函数时，一般将左操作数作为函数的参数。

22 可以将插入运算符“ <<”和提取运算符“ >> ”重载为类的成员函数。

23 C++语言中，即允许单继承，又允许多继承。

24 派生类的继承方式有两种：公有继承和私有继承。

25 在私有继承中，基类中所有成员对派生类的对象都是不可见的。

C++_CHAP9_史玉珍


第9章 继承与派生
构造函数

构造函数不能够被继承，因此，派生类的构造函 数必须通过跳动基类的构造函数来初始化函数子 对象，所以，在定义派生类的构造函数时，除了 对自己的数据成员进行初始化外，还必须负责调 用基类构造函数使基类的数据成员得以初始化。 如果派生类汇总还有子对象时，还应包含对子对 象初始化的构造函数。
public protected private
public protected 不可访问 public private 不可访问
protected Private 不可访问
私有继承
保护继承
第9章 继承与派生
9.2 单继承

9.2.1 9.2.2 9.2.3 9.2.4
基类成员的访问权限 构造函数和析构函数 作用域运算符:: 子类型和类型适应
void main() { B obj1; B obj2(5,6); B obj3(7,8,9); obj1.print(); obj2.print(); obj3.print(); }
第9章 继承与派生
派生类构造函数使用中应注意的问题
（1）派生类构造函数的定义中可以省略对基本结 构函数的调用，其条件是在基类中必须有缺省的 构造函数或者根本没有定义的构造函数。当然， 基类中没有定义构造函数，派生类基本不必负责 调用派生类构造函数。 （2）当基类的构造函数使用一个或多个参数时则 派生类必须定义构造函数，提供将参数传递给基类 构造函数的途径。在有的情况下，派生类构造函数 的函数体可能为空，仅起到参数传递作用。
第9章 继承与派生
9.1.2 派生类的定义格式
单继承的定义格式如下：
class <派生类名>:<继承方式><基类名

[学习C++]构造函数 析构函数和赋值操作符

几乎所有的类都有一个或多个构造函数，一个析构函数和一个赋值操作符。

这没什么奇怪的，因为它们提供的都是一些最基本的功能。

构造函数控制对象生成时的基本操作，并保证对象被初始化；析构函数摧毁一个对象并保证它被彻底清除；赋值操作符则给对象一个新的值。

在这些函数上出错就会给整个类带来无尽的负面影响，所以一定要保证其正确性。

本章我将指导如何用这些函数来搭建一个结构良好的类的主干。

构造函数，析构函数和赋值操作符几乎所有的类都有一个或多个构造函数，一个析构函数和一个赋值操作符。

这没什么奇怪的，因为它们提供的都是一些最基本的功能。

构造函数控制对象生成时的基本操作，并保证对象被初始化；析构函数摧毁一个对象并保证它被彻底清除；赋值操作符则给对象一个新的值。

在这些函数上出错就会给整个类带来无尽的负面影响，所以一定要保证其正确性。

本章我将指导如何用这些函数来搭建一个结构良好的类的主干。

条款11: 为需要动态分配内存的类声明一个拷贝构造函数和一个赋值操作符看下面一个表示string对象的类：// 一个很简单的string类class string {public:string(const char *value);~string();... // 没有拷贝构造函数和operator=private:char *data;};string::string(const char *value){if (value) {data = new char[strlen(value) + 1];strcpy(data, value);}else {data = new char[1];*data = '\0';}}inline string::~string() { delete [] data; }请注意这个类里没有声明赋值操作符和拷贝构造函数。

这会带来一些不良后果。

如果这样定义两个对象：string a("hello");string b("world");其结果就会如下所示：a: data——> "hello\0"b: data——> "world\0"对象a的内部是一个指向包含字符串"hello"的内存的指针，对象b的内部是一个指向包含字符串"world"的内存的指针。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Point3D(void)
{ z=0; cout<<"new 3D"<<endl;}
……... 如果使用基类的无
~{Pcooiuntt<3参<D"(数f)re构e 3造D"函<<数en，dl;可}
};
以省略不写。
main() {
Point3D *pt; pt=new Point3D(1,2,3); ...... delete pt; } 运行结果： new 2D new 3D free 3D free 2D
class data { int x;
派生类构造函数 public:
data(int x)
范例2 { data::x=x;
printf("class data\n"); } int getx(){return x;} }; class a { data d1; public:
class c:public b { public:
c(int x):b(x) { printf("class c\n");} }; int main(int argc, char* argv[]) { c c1(10);
printf("%d %d\n",c1.getdataa(), c1.getdatab());
printf("Hello World!\n"); return 0; }
class a class data class b class c
int getdatab(){return d2.getx();} };
10 10 Hello world!
派生类的析构函数
派生类的析构函数的构造规则
当派生类中包含使用new和delete运算符的指针成员时， 派生类必须显示定义析构函数
B's default constructor called.
A's default constructor called.
A's default constructor called.
B's default constructor called.
2021/2/23
A's constructor called. A's constructor called. B's constructor called. B's deconstructor called. A's deconstructor called. A's deconstructor called. A's constructor called. A's constructor called. B's constructor called. B's deconstructor called. A's deconstructor called. A's deconstructor called.
{ ......
}
class Point2D
{
private:
int x, y;
public :
Point2D(int x0, int y0)
{x=x0; y=y0; cout<<"new
2D"<<endl;}
Point2D(void)
{x=0; y=0; cout<<"new
2D"<<endl;}
cout << “\n平均分数: ” << average<< “\n年级: " << level; }
~A() {cout<<"A's destructor called."<<endl; }
void Print() const{cout<<a<<",";}
int Geta( )const { return a; }
private:
int a;
};
14
2021/2/23
class B:public A {
派生类构造函数
范例(续)
class derive1:base { int x2,y2;
A aa; public: derive1(int a,int b,int c,int d,int e); void print() {cout<<"drive1 "<<x2<<","<<y2<<endl;} }; derive1::derive1(int a,int b,int c,int d,int e):ase(c,d),aa(e) { x2=a;y2=b;cout<<"derive1 Cons\n";} void main() { derive1 d1(1,2,3,4,5); d1.print(); }
public: B() { b=0; cout<<"B's default constructor
called.\n"; } B(int i,int j,int k); ~B() { cout<<"B's destructor
called."<<endl; } void Print()const;
private: int b; A aa;
16
void main() {
B bb[2]; bb[0]=B(1,2,5); bb[1]=B(3,4,8); for(int i=0; i<2; i++)
bb[i].Print(); }
运行结果：
A's default constructor called.
A's default constructor called.
派生类的析构函数
范例（续） class derive1:base { int x2,y2; A aa; public: derive1(int a,int b,int c,int d,int e); void print() {cout<<"drive1 "<<x2<<","<<y2<<endl;} ~derive1() {cout<<"derive1 Desc\n";} }; derive1::derive1(int a,int b,int c,int d,int e):base(c,d),aa(e) { x2=a;y2=b;cout<<"derive1 Cons\n";} void main() { derive1 d1(1,2,3,4,5); d1.print(); }
~university( ) { if (name) delete name;}
void print( ) {
cout << “\n\n姓名: ” <<name<<“\n年龄: " << age << “\n性别: "<< sex;
} }; class student: public university { protected :
17
课堂练习：大学人员类
university name age sex print
student average level print
staff dept bonus print
#include<iostream.h> #include<string.h> class university {
派生类的构造函数与析构函数
基类往往有构造函数和析构函数，但它们不能被 派生类继承。
当创建一个派生类对象时，如何调用基类的构造 函数，在结束派生类的对象时，如何调用基类的 析构函数?
派生类构造函数
派生类构造函数的定义格式
<构造函数名>(参数表):<基类构造函数>(参数表), <对象成员名1>(参数表),..., <对象成员名n>(参数表)
派生类的析构函数 范例（续）
注意析构函 数执行顺序
#include <iostream>
2021/2/23
using namespace std;
class A
{
public:
A() { a=0;cout<<"A's default constructor called.\n"; }
A(int i) { a=i;cout<<"A's constructor called.\n"; }
派生类构造函数 范例(续)
注意构造函 数执行顺序
派生类构造函数
派生类构造函数的说明 若基类使用带缺省参数的构造函数或使用无参数的构 造函数,则在定义派生类构造函数时,可略去“<基类构 造函数>(参数表)”。 在下面的两种情况下，必须定义派生类的构造函数： 派生类本身需要构造函数； 创建派生类对象时，当基类含有带参数的构造函数 时，派生类必须定义构造函数，以提供把参数传递 给基类构造函数的途径。 在定义派生类对象时,构造函数的执行顺序是:先长辈 (基类),再客人(对象成员),后自己(派生类本身)。
派生类构造函数
范例
class A {