【Essential C++学习笔记】第五章 面向对象编程风格

2023-11-20 18:44

本文主要是介绍【Essential C++学习笔记】第五章 面向对象编程风格,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

本章节书里讲的比较杂,索性用自己的方式总结了一波,有些没有实质内容的章节就跳过了

文章目录

  • 第五章 面向对象编程风格
    • 5.1 面向对象编程概念
      • 1)[继承](https://blog.csdn.net/qq_62718027/article/details/125922249)
        • 1.继承格式
        • 2.访问权限和继承
        • 3.派生类和基类构造函数初始化列表的执行顺序
      • 2)多态
        • 1.多态的实现
        • 2.虚函数
        • 3.C++11新增的 override 和 final
          • ① `override`
          • ② `final`
        • 4.重载,覆盖(重写),重定义(隐藏)
        • 5.接口继承和实现继承
      • 3)总结
    • 5.4 不带继承的多态
      • 第一,**找出所有子类(一些类)共通的操作行为**
      • 第二,**找出哪些操作行为(基类成员函数)必须根据不同的派生类而有不同的实现方式**
      • 第三,**找出每个操作行为(基类成员函数)的访问层级**
    • 5.10 运行时的鉴定机制
      • typeid[运算符](https://so.csdn.net/so/search?q=运算符&spm=1001.2101.3001.7020)
      • type_info类
      • static_cast运算符
      • dynamic_cast运算符

第五章 面向对象编程风格

5.1 面向对象编程概念

面向对象编程概念最主要特质:继承多态

1)继承

  • 继承是将一群相关的类组织起来,分享这些类之间的共通数据操作行为
  • 继承允许我们依据另一个类来定义一个类,这使得创建和维护一个应用程序变得更容易。这样做,也达到了重用代码功能和提高执行效率的效果。
  • 当创建一个类时,不需要重新编写新的数据成员和成员函数,只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类,新建的类称为派生类
  • 继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。之前接触的复用都是函数复用,继承是类设计层次的复用
  • 间接利用指向抽象基类的指针或引用来操作一个类系统中的各个类对象,而非直接操作各个实际对象,这有什么好处呢?就是可以不在改动原有程序的前提下,加入或移除任何一个派生类
1.继承格式
class 新类的名字:继承方式 继承类的名字{};// 基类class Animal {// eat() 函数// sleep() 函数};//派生类class Dog : public Animal {// bark() 函数};
2.访问权限和继承

① 访问权限

访问publicprotectedprivate
同一个类yesyesyes
派生类yesyesno
外部的类yesnono
  • 基类private成员无论以什么方式继承到派生类中都是不可见的。
  • 使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public。

② 继承后的子类成员访问权限

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类不可见在派生类不可见在派生类不可见

③ 派生类继承了什么?

一个派生类继承了所有的基类方法,但下列情况除外:

  • 基类的构造函数、析构函数和拷贝构造函数。
  • 基类的重载运算符。
  • 基类的友元函数。

④ 同名的成员变量和成员函数

在有些时候,父类和子类中出现了同一个成员变量,如下name,这个时候编译器是以子类为优先。想要访问父类的name成员变量,就需要加上修饰

cout << people::name<< endl;

同样一个函数print在父类和子类中都存在,编译器会默认调用子类中匹配的函数,(函数重载是在同一个作用域,这里父类和子类是两个作用域)

3.派生类和基类构造函数初始化列表的执行顺序

构造函数调用顺序:基类 > 成员类 > 派生类

析构函数和构造函数相反,编译器默认先调用子类的析构函数,再调用父类的析构函数。

#include <iostream>
using namespace std;class A {public:A() {cout << "call A()" << endl;}~A() {cout << "call ~A()" << endl;}
};class B : A {public:B(int val) : A(), value(val) {val = 0;    // 重新赋值cout << "call B()" << endl;}~B() {cout << "call ~B()" << endl;}private:int value;
};int main() {B b(10);return 0;
}/*
* 结果如下
* call A()
* call B()
* call ~B()
* call ~A()
* 说明放在初始化列表的部分在构造函数之前执行
*/

2)多态

多态字面意思就是多种形态。

多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。

举个例子:买票

普通人全价,学生半价,军人全价但优先购票…

这就是对买票这一个具体行为,不同人去完成时产生的不同结果。

1.多态的实现

C++的多态必须满足两个条件:

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写
#include <iostream>
using namespace std;class Person
{
public:virtual void display(){cout << "全价票" << endl;}
};class Student :public Person
{
public:virtual void display() // //子类完成对父类虚函数的重写{cout << "半价票" << endl;}
};void BuyTicket(Person* p)
{p->display();
}int main(){Student st;Person p;BuyTicket(&st);  //半价票BuyTicket(&p);	//全价票system("PAUSE");return 0;
}
/*  将传地址改为传对象,不满足多态条件后,调用的都是父类的函数
void BuyTicket(Person p)
{p.display();
}
int main(){Student st;Person p;BuyTicket(st);  //全价票BuyTicket(p);	//全价票system("PAUSE");return 0;
}
*/

如果满足多态,编译器会调用指针指向对象的虚函数,而与指针的类型无关。如果不满足多态,编译器会直接根据指针的类型去调用虚函数。

2.虚函数
  • virtual修饰的关键字就是虚函数,且虚函数只能是类中非静态的成员函数

  • 子类和父类中的虚函数拥有相同的名字,返回值,参数列表,那么称子类中的虚函数重写了父类的虚函数

  • 虚函数可以不实现(定义)。不实现(定义)的虚函数是纯虚函数。 virtual int area() = 0;` = 0 告诉编译器,函数没有主体。那么纯虚函数有什么用呢?

    1,强制子类重写虚函数,完成多态。
    2,表示某些抽象类。

  • 虚函数重写的两个例外:

    1. 协变:子类的虚函数和父类的虚函数的返回值可以不同,也能构成重载。但对返回值有要求:需要子类的返回值是一个子类的指针或者引用,父类的返回值是一个父类的指针或者引用,且返回值代表的两个类也成继承关系。这个叫做协变。
    2. 析构函数的重写:析构函数名字天生不一样,怎么实现多态?
    /*test.1
    B继承了A,他们的析构函数没有重写。
    */
    class A
    {public:~A(){cout << "~A()" << endl;}
    };
    class B : public A
    {public:~B(){cout << "~B()" << endl;}
    };A* a = new B; //把B的对象切片给A类型的指针。delete a; //实际调用的是A的析构函数/*test.2
    B继承了A,他们的析构函数没有重写。
    */
    class A {public:virtual ~A() {cout << "~A()" << endl;}
    };class B : public A {public:~B() {cout << "~B()" << endl;}
    };A* a = new B; //把B的对象切片给A类型的指针。delete a; //有进行了重写,会先调用B的析构函数,后调用A的析构函数
    
3.C++11新增的 override 和 final
override

检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错。(定义在子类)

感觉没多大意义,有点画蛇添足,既然都想到了要写override,那还能忘记要重写基类的虚函数?或者说写错?

final

final修饰的虚函数无法重写。用final修饰的类无法被继承。final像这个单词的意思一样,这就是最终的版本,不用再更新了。(定义在父类)

子类对有final修饰的虚函数进行重写,会报错

4.重载,覆盖(重写),重定义(隐藏)
作用域组成要求
重载两者处在同一作用域函数名相同,参数、返回值不同
覆盖(重写)两者分别在基类和派生类的作用域函数名、参数、返回值相同(协变除外)两者都是虚函数
重定义(隐藏)两者分别在基类和派生类的作用域函数名相同,参数、返回值不同子类和父类的同名函数不是重定义就是重写
5.接口继承和实现继承

普通函数的继承就是实现继承,虚函数的继承就是接口继承。子类继承了函数的实现,可以直接使用。虚函数重写后只会继承接口,重写实现。所以如果不用多态,不要把函数写成虚函数

#include <iostream>
using namespace std;class A
{
public:virtual void fun(int val = 0){cout << "A->val = " << val << endl;}void Fun(){fun();//传过来一个子类指针调用fun()}
};class B:public A
{
public:virtual void fun(int val = 1){cout << "B->val = " << val << endl;}
};int main(){B b;b.Fun();system("PAUSE");return 0;
}

3)总结

  • 继承特性让我们可以定义一整群互有关联的类,并共享通用的接口
  • 多态则让我们可以用一种与类型无关的方式来操作类对象,通过抽象基类的指针或引用来操纵一整群互有关联的类的共同接口
  • 动态绑定在程序执行时隐居抽象基类的指针或引用所指的是基类对象的类型才能决定。

5.4 不带继承的多态

定义一个抽象基类

第一,找出所有子类(一些类)共通的操作行为

所有子类共通的操作行为,这些行为代表的是基类的公有接口

第二,找出哪些操作行为(基类成员函数)必须根据不同的派生类而有不同的实现方式

找出哪些操作行为(基类成员函数)必须根据不同的派生类而有不同的实现方式。
如果某操作行为(基类成员函数)必须根据不同的派生类而有不同的实现方式,这个操作行为就要成为整个类继承体系的虚函数即该成员函数(至少在基类中)的声明前加virtual。

第三,找出每个操作行为(基类成员函数)的访问层级

某个操作行为(类成员函数)能让一般程序(在该类主体和该类的派生类如果有派生类的话外)访问这个成员函数,那么我们将这个成员函数的声明/定义放进基类的public:里。
某个操作行为(类成员函数))在基类之外不需要被用到,自然不用在基类之外访问这个成员函数。我们就把这个成员函数的声明/定义放进基类的private:里
某个操作行为(类成员函数)在该类的派生类(如果有的话)主体/对象可以被访问,却不许一般程序访问。 那么我们就把这个成员函数的声明/定义放进基类的protected:里。

5.10 运行时的鉴定机制

typeid运算符

  • 这是运行时类型鉴定机制得一部分,由程序语言支持。
  • typeid运算符让我们得以查询多态化的类指针/引用,来获得类指针/引用所指对象的实际类型。用法举例
#include<typeinfo>
inline const char* num_sequence::what_am_i()const{return typeid(*this).name();}

type_info类

  • type_info类支持相等和不相等两个操作,举个例子:
num_sequence *ps=&fib;
//...
if(typeid(*ps)==typeid(Fibonacci))
{}
//...

这一堆代码是测试ps这个基类指针是否指向某个派生类类对象。

static_cast运算符

用static_cast运算符来强制转换(无条件转换)基类指针变为派生类指针。用法举例:

if(typeid(*ps)==typeid(Fibonacci))
{Fibonacci *pf=static_cast<Fibonacci*>(*ps);pf->gen_elems(64);//经过static_cast运算符转换指针变为派生类指针//这种写法得以被编译器承认
}

不过static_cast有个潜在危险,就是编译器无法确定转换类指针从基类到派生类是不是转换对了,所以我们加了if(typeid(*ps)==typeid(Fibonacci)){}如果typeid运算符(这里是==和())运算结果为真,就执行类指针的无条件转换。

dynamic_cast运算符

dynamic_cast运算符没有这种潜在危险。其用法举例:

	if(Fibonacci *pf=dynamic_cast<Fibonacci*>(ps)){pf->gen_elems(64);//经过dynamic_Cast运算符转换指针变为派生类指针//这种写法得以被编译器承认}

这篇关于【Essential C++学习笔记】第五章 面向对象编程风格的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/396670

相关文章

C++ 中的 if-constexpr语法和作用

《C++中的if-constexpr语法和作用》if-constexpr语法是C++17引入的新语法特性,也被称为常量if表达式或静态if(staticif),:本文主要介绍C++中的if-c... 目录1 if-constexpr 语法1.1 基本语法1.2 扩展说明1.2.1 条件表达式1.2.2 fa

C++中::SHCreateDirectoryEx函数使用方法

《C++中::SHCreateDirectoryEx函数使用方法》::SHCreateDirectoryEx用于创建多级目录,类似于mkdir-p命令,本文主要介绍了C++中::SHCreateDir... 目录1. 函数原型与依赖项2. 基本使用示例示例 1:创建单层目录示例 2:创建多级目录3. 关键注

C++从序列容器中删除元素的四种方法

《C++从序列容器中删除元素的四种方法》删除元素的方法在序列容器和关联容器之间是非常不同的,在序列容器中,vector和string是最常用的,但这里也会介绍deque和list以供全面了解,尽管在一... 目录一、简介二、移除给定位置的元素三、移除与某个值相等的元素3.1、序列容器vector、deque

C++常见容器获取头元素的方法大全

《C++常见容器获取头元素的方法大全》在C++编程中,容器是存储和管理数据集合的重要工具,不同的容器提供了不同的接口来访问和操作其中的元素,获取容器的头元素(即第一个元素)是常见的操作之一,本文将详细... 目录一、std::vector二、std::list三、std::deque四、std::forwa

C++字符串提取和分割的多种方法

《C++字符串提取和分割的多种方法》在C++编程中,字符串处理是一个常见的任务,尤其是在需要从字符串中提取特定数据时,本文将详细探讨如何使用C++标准库中的工具来提取和分割字符串,并分析不同方法的适用... 目录1. 字符串提取的基本方法1.1 使用 std::istringstream 和 >> 操作符示

C++原地删除有序数组重复项的N种方法

《C++原地删除有序数组重复项的N种方法》给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度,不要使用额外的数组空间,你必须在原地修改输入数组并在使用O(... 目录一、问题二、问题分析三、算法实现四、问题变体:最多保留两次五、分析和代码实现5.1、问题分析5.

C++ 各种map特点对比分析

《C++各种map特点对比分析》文章比较了C++中不同类型的map(如std::map,std::unordered_map,std::multimap,std::unordered_multima... 目录特点比较C++ 示例代码 ​​​​​​代码解释特点比较1. std::map底层实现:基于红黑

C++中函数模板与类模板的简单使用及区别介绍

《C++中函数模板与类模板的简单使用及区别介绍》这篇文章介绍了C++中的模板机制,包括函数模板和类模板的概念、语法和实际应用,函数模板通过类型参数实现泛型操作,而类模板允许创建可处理多种数据类型的类,... 目录一、函数模板定义语法真实示例二、类模板三、关键区别四、注意事项 ‌在C++中,模板是实现泛型编程

利用Python和C++解析gltf文件的示例详解

《利用Python和C++解析gltf文件的示例详解》gltf,全称是GLTransmissionFormat,是一种开放的3D文件格式,Python和C++是两个非常强大的工具,下面我们就来看看如何... 目录什么是gltf文件选择语言的原因安装必要的库解析gltf文件的步骤1. 读取gltf文件2. 提

C++快速排序超详细讲解

《C++快速排序超详细讲解》快速排序是一种高效的排序算法,通过分治法将数组划分为两部分,递归排序,直到整个数组有序,通过代码解析和示例,详细解释了快速排序的工作原理和实现过程,需要的朋友可以参考下... 目录一、快速排序原理二、快速排序标准代码三、代码解析四、使用while循环的快速排序1.代码代码1.由快