C++面向对象程序设计-北京大学-郭炜【课程笔记（七）】

2024-04-19 18:36
文章标签 c++ 笔记 程序设计 面向对象 课程 北京大学 郭炜

本文主要是介绍C++面向对象程序设计-北京大学-郭炜【课程笔记（七）】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

C++面向对象程序设计-北京大学-郭炜【课程笔记（七）】

  • 1、类型转换运算符
  • 2、自增、自减运算符的重载
  • 3、继承和派生的基本概念
    • 3.1、基本概念
    • 3.2、派生类对象的内存空间
  • 4、继承关系和复合关系
    • 4.1、继承关系的使用
    • 4.2、复合关系的使用
  • 5、派生类覆盖基类成员
  • 6、存储权限说明符：protected
  • 7、派生类的构造函数
  • 8、public继承的赋值兼容规则
  • 9、直接基类与间接基类（套娃）

毕业中：学习速度较慢
开始课程：P21 6_6. 类型转换运算符的重载
课程链接：程序设计与算法（三）C++面向对象程序设计 北京大学 郭炜
课程PPT：github提供的对应课程PPT

1、类型转换运算符

重载强制类型转换符 double 形式：operator double () {return real};
类型转换符重载是不需要写返回值类型的，默认其double自身。

案例：解释包含在代码中

#include <iostream>
using namespace std;class Complex
{double real, imag;public:Complex(double r=0, double i=0):real(r), imag(i) {};operator double () {return real;}// 重载强制类型转换运算符 double，返回类型就是double，不用单独写出
};int main()
{Complex c(1.2, 3.4);cout << (double)c << endl;   // 输出1.2  //等价于c.operator double()double n = 2 + c;  // 等价于double n = 2+c.operator double()// 本来2和c是不能相加的，因为2为一个整形数字，c确实一个对象，// 所以这里调用了重载类型转换运算符cout << n; // 输出 3.2
}

2、自增、自减运算符的重载

  • 自增运算符++、自检运算符–有前置/后置之分，为了区分所有重载的是前置运算符还是后置运算符，C++规定：

  • 前置运算符作为一元运算符重载

  • 重载为成员函数:
    T & operator++();
    T & operator–();
    重载为全局函数：
    T & operator++(T &);
    T & operator—(T &);
    使用样例：++obj, obj.operator++(), operator++(obj) 都调用上述函数

  • 后置运算符作为二元运算符重载，多写一个没用的参数即可，这参数不具备任何意义，也不会被使用；

  • 重载为成员函数:
    T operator++(int);
    T operator–(int);
    重载为全局函数:
    T operator++(T &, int);
    T operator–(T &, int);
    使用样例：obj++, obj.operator++(0), operator++(obj,0) 都调用上函数

注意事项：在vs中，obj++也调用前置重载，而dev则令obj++编译出错。

案例：课程中的所有解释均在代码中呈现，请配合课程看代码；

#include<iostream>
using namespace std;class CDemo
{private:int n;public:CDemo(int i=0):n(i) {}CDemo & operator++();   // 用于前置形式，返回值为引用CDemo operator++(int);  // 用于后置形式，返回值为对象// 后置类型的++为什么没使用&引用呢！// 答：在C++中 ++a；a的返回值就是a的引用；所以在重载前置++运算符时，我们需要尽量维持它原本的属性。   operator int() {return n;}  // 类型强制转换运算符，直接可以cout输出对象friend CDemo & operator--(CDemo &);     // 全局前置friend CDemo operator--(CDemo &, int);  // 全局后置
};CDemo & CDemo::operator++()  // 返回值为CDemo对象的引用
{// 前置 ++++n;return * this;   // 返回值是一个对象，即对* this的引用；
}  // ++s即为：s.operator++()，即返回值就是s的引用（& s）CDemo CDemo::operator++(int k)  // 这里的k是无用的参数； 返回值为CDemo对象
{// 后置 ++CDemo tmp(*this);   // 记录修改前的对象n++;return tmp;         // 返回修改前的对象
}  // s++即为：s.operator(0);CDemo & operator--(CDemo & d)  // 这里的引用可不是只为了节省空间，而是要通过该引用更改成员变量
{// 前置--d.n--;return d;   // 返回对操作数的引用，即d的引用
}  // --s即为：operator--(s)CDemo operator--(CDemo & d, int)
{// 后置--CDemo tmp(d);  // 生成一个临时的对象，因为后置本身输出的值大小不变，但其运行完后，该对象中的--或++才生效，所以返回的对象是其自身。d.n--;return tmp; // 返回操作数的对象，即d
}  // s--即为：operator--(s, 0)int main()
{CDemo d(5);cout << (d++) << ","; //等价于 d.operator++(0);   //重载为成员函数的形式cout << d << ",";   // 可以重载左移运算符或者重载一个强制类型转换运算符即可输出d；cout << (++d) << ","; //等价于 d.operator++();    //重载为成员函数的形式cout << d << endl;cout << (d--) << ","; //等价于 operator--(d,0);   //重载为全局函数的形式cout << d << ",";cout << (--d) << ","; //等价于 operator--(d);     //重载为全局函数的形式cout << d << endl;return 0;
}// OUT
MacBook-Air beida_lesson % g++ 21.cpp -o 21
MacBook-Air beida_lesson % ./21
5,6,7,7
7,6,5,5

注意事项：一共有以下一些观点：

由上述代码可知，后置运算符的重载比前置运算符的重载多了一个临时函数的构建，所以前置运算符在时间上的开销要小于后置运算符重载的开销，特别是遇到递归时，变得就比较明显了。所以提倡写前置运算符。

请添加图片描述

3、继承和派生的基本概念

3.1、基本概念

  • 继承：在定义一个新的类B时，如果该类与某个已有的类A相似（指的是B拥有A的全部特点），那么就可以把A作为一个基类，而把B作为基类的一个派生类（也称子类）。
  • 派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。
  • 派生类一经定义后，可以独立使用，不依赖于基类。
  • 派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public。
    • 在派生类的各个成员函数中，不能访问基类中的private成员。

案例

  • 所有学生都有的共同属性：
    • 姓名
    • 学号
    • 性别
    • 成绩
  • 所有学生都有的共同方法：（成员函数）
    • 是否该留级
    • 是否该奖励
  • 不同学生又有个字==各自不同的属性和方法
    • 研究生
      • 导师
      • 系
    • 大学生
      • 系
    • 中学生
      • 竞赛特长加分
class CStudent
{private:string sName;int nAge;public:bool IsThreeGood() {};void SetName(const string & name){sName = name;}
};// 要毕业的学生
class CUndergraduateStudent: public Cstudent
{private:int nDepartment;  // 添加自己的新的成员变量public:bool IsThreeGood() {.....};  // 覆盖（与基类的成员函数名一样，但内容不一样）bool CanBao Yan() {.....};
};   // 派生类的写法是：类名：public基类名// 研究生
class CGraduatedStudent:public CStudent
{private:int nDepartment;char szMentorName[20];public:int CountSalary() {.....};
}

3.2、派生类对象的内存空间

派生类对象的体积，等于基类对象的体积，再加上派生类对象自己的成员变量的体积。在派生类对象中，包含着基类对象，而且基类对象的春初位置位于派生类对象新增的成员变量之前。
在这里插入图片描述

举例一个完整的例子：两个类的简单学生管理程序

// File name：22.cpp
#include<iostream>
#include<string>
using namespace std;class CStudent
{private:string name;string id;  // 学号char gender; // 性别， “F”代表女， “M”代表男int age;public:void PrintInfo();void SetInfo(const string & name_, const string & id_, int age_, char gender_);string GetName() {return name;}
};void CStudent::PrintInfo()
{cout << "Name = " << name << endl;cout << "ID = " << id << endl;cout << "Age = " << age << endl;cout << "Gender = " << gender << endl;
}void CStudent::SetInfo(const string & name_, const string & id_,int age_, char gender_)
{name = name_;id = id_;age = age_;gender = gender_;
}class CUndergraduateStudent:public CStudent
{// 本科生类，继承了CStudent类private:string department;  // 学生所属的系的名称public:void QualifiedForBaoyan(){// 输出给予保研资格cout << "qualified for baoyan" << endl;}void Printfo()   // 覆盖：CUndergraduateStudent自己的Printfo{CStudent::PrintInfo();   // 调用基类PrintInfocout << "Department:" << department << endl;}void SetInfo(const string & name_, const string & id_, int age_, char gender_, const string & department_){CStudent::SetInfo(name_, id_, age_, gender_);  // 调用基类的Setinfodepartment = department_;}
};int main()
{CUndergraduateStudent s2;s2.SetInfo("Harry Potter", "118829212", 19, 'M', "Computer Science");cout << s2.GetName() << "" ;s2.QualifiedForBaoyan();s2.PrintInfo();return 0;
}// OUT
MacBook-Air beida_lesson % g++ 22.cpp -o 22
MacBook-Air beida_lesson % ./22
Harry Potterqualified for baoyan
Name = Harry Potter
ID = 118829212
Age = 19
Gender = M

4、继承关系和复合关系

继承关系：“是” 关系

  • 基类A，B是基类A的派生类。
  • 逻辑上要求：“一个B对象也是一个A对象”。（例：从学生类派生出中学生类，因为中学生也是学生。）

复合关系：“有”关系。

  • 类C中“有”成员变量k，k是类D的对象，则C和D是复合关系
  • 一般逻辑上要求：“D对象是C对象的固有属性或组成部分”。

4.1、继承关系的使用

在这里插入图片描述
请添加图片描述

4.2、复合关系的使用

请添加图片描述在这里插入图片描述在这里插入图片描述

5、派生类覆盖基类成员

派生类可以定义一个和基类成员同名的成员，这叫覆盖。在派生类中访问这类成员时，缺省的情况是访问派生类中定义的成员。要在派生类中访问有基类定义的同名成员时，要使用作用域符号::。


class base
{int j;public:int i;void func();
};class derived : public base
{public:int i;void access();void func();
};void derived::access()
{// j = 5; // error,这是base的私有成员变量，派生类derived不能访问i = 5; // 引用的是派生类的ibase::i = 5; // 引用的基类的ifunc();  // 派生类的base::func(); // 基类的}int main()
{derived obj;obj.i = 1;   // 派生类的iobj.base::i = 1;  // 引用的基类的i
}// 在派生类和基类中不要写相同的成员变量，如上代码中的i

注意事项：在派生类和基类中不要写相同的成员变量，如上代码中的i

6、存储权限说明符：protected

在这里插入图片描述
特点：基类的protected成员：可以被以下函数访问：

  • 基类的成员函数
  • 基类的有缘函数
  • 派生类的成员函数可以访问当前对象的基类的保护成员
class People
{private: int nPrivate;  // 私有成员public: int nPublic;    // 公有成员protected: int nProtected;  // 保护成员
};class Son:public People
{void Accesspeople(){nPublic = 1;     // OknPrivate = 1;    // wrongnProtected = 1;  // Ok, 访问从基类继承的protected成员Son f;  // 非当前对象 f.nProtected = 1; // wrong, f 不是当前对象}
};int main()
{People f; Son s;f.nPublic = 1;s.nPublic = 1;f.nProtected = 1; f.nPrivate = 1; s.nProtected =1; s.nPrivate = 1; 
}

7、派生类的构造函数

在这里插入图片描述


class Bug
{private:int nLegs;int nColor;public:int nType;Bug(int nLegs_, int nColor_);void PrintBug(){};
};class FlyBug:public Bug  // FlyBug是Bug的派生类
{int nWings;public:FlyBug(int nLegs_, int nColor_, int nWings_);
};Bug::Bug(int legs, int color)
{nLegs = legs;nColor = color;
}// 错误的FlyBug构造函数
FlyBug::FlyBug(int legs, int color, int wings)
{nLegs = legs;   // 不能访问nColor = color; // 不能访问nType = 1;      // OK，基类的公有成员，没有问题的nWings = wings;
}// 正确的FlyBug构造函数
// 直接初始化派生类所包含的基类的Bug对象（即Bug构造函数）初始化列表
FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color) // 基类的构造函数
{nWings = wings;
}int main()
{FlyBug fb(2, 3, 4);  // 调用构造函数初始化fb.PrintBug();fb.nType = 1;fb.nLegs = 2;   // error , nLegs is privatereturn 0; 
}

在这里插入图片描述
例：

#include <iostream>class Base
{public:int n;Base(int i):n(i){std::cout << "Base" << n << " constructed " << std::endl;}~Base(){std::cout << "Base " << n << "destructed" << std::endl;}
};class Derived:public Base
{public:Derived(int i):Base(i) // 1、先进入Base构造函数{ std::cout << "Derived constructed " << std::endl;} //2、进入Drivate构造函数~Derived(){std::cout << "Derived destructed" << std::endl;}
};int main()
{Derived Obj(3);return 0;// 3、执行 Derived析构函数// 4、执行 Base析构函数
}// OUT
MacBook-Air beida_lesson % ./23
Base3 constructed 
Derived constructed 
Derived destructed
Base 3destructed

例题2:

#include <iostream>class Bug
{private:int nLefs; int nColor;public:int nType;Bug(int legs, int color);void PrintBug() {};
};class Skill
{public:Skill(int n) {};
};class nWings
{public:nWings(int nWings_) {};
};class FlyBug:public Bug
{nWings w1;Skill sk1, sk2;public:FlyBug(int legs, int color, int wings);
};FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color), sk1(5), sk2(2), w1(wings) {}

老师版本：

#include <iostream>class Bug
{private:int nLefs; int nColor;public:int nType;Bug(int legs, int color);void PrintBug() {};
};class Skill
{public:Skill(int n) {};
};class FlyBug:public Bug
{int nWings;Skill sk1, sk2;public:FlyBug(int legs, int color, int wings);// nWings(int nWings_) { nWings = nWings_};
};FlyBug::FlyBug(int legs, int color, int wings):Bug(legs, color), sk1(5), sk2(2), nWings(wings) {}

请添加图片描述
请添加图片描述

8、public继承的赋值兼容规则

以下等号“=”并没有采用运算符重载。

请添加图片描述

9、直接基类与间接基类（套娃）

请添加图片描述
请添加图片描述
例：

#include <iostream>class Base
{public:int n;Base(int i):n(i){std::cout << "Base" << n << " constructed " << std::endl;}~Base(){std::cout << "Base " << n << "destructed" << std::endl;}
};class Derived:public Base
{public:Derived(int i):Base(i){ std::cout << "Derived constructed " << std::endl;}~Derived(){std::cout << "Derived destructed" << std::endl;}
};class MoreDerived:public Derived
{public:MoreDerived():Derived(4){std::cout << "More Derived constructed" << std::endl;}~MoreDerived(){std::cout << "More Derived destructed " << std::endl;}
};int main()
{MoreDerived Obj;return 0;
}// OUT~MoreDerived()^
2 errors generated.
MacBook-Air beida_lesson % g++ 23.cpp -o 23
MacBook-Air beida_lesson % ./23            
Base4 constructed 
Derived constructed 
More Derived construct

这篇关于C++面向对象程序设计-北京大学-郭炜【课程笔记（七）】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/918285。

相关文章

C++中实现调试日志输出

C++中实现调试日志输出

《C++中实现调试日志输出》在C++编程中,调试日志对于定位问题和优化代码至关重要,本文将介绍几种常用的调试日志输出方法,并教你如何在日志中添加时间戳,希望对大家有所帮助... 目录1. 使用 #ifdef _DEBUG 宏2. 加入时间戳：精确到毫秒3.Windows 和 MFC 中的调试日志方法MFC
阅读更多...
深入理解C++ 空类大小

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中，规
阅读更多...
在 VSCode 中配置 C++ 开发环境的详细教程

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode（VSCode）中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境：详细教程1. 什么是 VSCode？2. 安装 VSCo
阅读更多...
C++11的函数包装器std::function使用示例

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function
阅读更多...
【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...
【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

系列文章目录 监督学习：参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归（SAheart.csv） 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2