《Effective c++》Chapter6 读书笔记

最新推荐文章于 2022-05-13 16:03:05 发布
最新推荐文章于 2022-05-13 16:03:05 发布
阅读量158 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39621037/article/details/112991597
版权

Chapter6

条款32:确定你的public继承塑模出is-a关系
  • "public继承"意味is-a.适用于base classes身上的每一件事情一定也适用于derived classes身上，因为每一个derived class对象也都是一个base class对象.
条款33：避免遮掩继承而来的名称
  • derived classes内的名称会遮掩base class内的名称。只要名称相同就会被覆盖，无论函数参数是否相同，也无论是virtual还是non-virtual(见下例)
  • 为了让被遮掩的名称再见天日，可使用using声明式或转交函数(forwarding functions)
//例子一：名称相同即被覆盖

class Base{
    private:
        int x;
    public:
        virtual void mf1() =0;
        virtual void mf1(int);
        virtual void mf2();
        void mf3();
        void mf3(double);
        ...
};

class Derived:public Base{
    public:
        //mf1覆盖Base::mf1(),Base::mf1(int)
        virtual void mf1();
        //mf3覆盖Base::mf3(),Base::mf3(double)
        void mf3();
        void mf4();
        ...
};

int main(){
    Derived d;
    int x;
    ...
    d.mf1();    //没问题，调用Derived:mf1
    d.mf1(x);   //错误！因为Derived::mf1覆盖了Base::mf1
    d.mf2();    //没问题，调用Base::mf2
    d.mf3();    //没问题，调用Derived::mf3
    d.mf3(x);   //错误！因为Derived::mf3遮掩了Base::mf3
}

//例子二：使用using声明式，使得被覆盖的函数在derived class中可见

class Base{
    private:
        int x;
    public:
        virtual void mf1() =0;
        virtual void mf1(int);
        virtual void mf2();
        void mf3();
        void mf3(double);
        ...
};

class Derived:public Base{
    public:
        using Base::mf1();      //让Base class内名为mf1和mf3的所有东西
        using Base::mf3();      //在Derived作用域内都可见(并且public)
        virtual void mf1();
        void mf3();
        void mf4();
};

int main(){
    Derived d;
    int x;
    ...
    d.mf1();    //没问题，调用Derived::mf1
    d.mf1(x);   //没问题，调用Base::mf1
    d.mf2();    //没问题，调用Base::mf2
    d.mf3();    //没问题，调用Derived::mf3
    d.mf3(x);   //没问题，调用Base::mf3
}
条款34：区分接口继承和实现继承
  • public继承包含两个方面的概念：函数接口(function interfaces)继承和函数实现(function implementations)继承
    1. 声明一个pure virtual函数的目的是为了让dervied classes只继承函数接口
    2. 声明简朴的（非纯）impure virtual函数的目的，是让derived classes继承该函数的接口和缺省实现
    3. 声明non-virtual函数的目的是为了令derived classes继承函数的接口及一份强制性实现。任何derived class都不应该尝试改变继承而来的non-virtual函数
//pure virtual 函数：让derived classes继承函数接口


class Shape{
    public:
        virtual void draw() const = 0;
};


//impure virtual函数：让derived classes继承函数接口和缺省实现
//例子一：函数接口和缺省实现
class Airport {...};    //用以表现机场
class Airplane{
    public:
        virtual void fly(const Airport& destination);
};

void Airplane::fly(const Airport& destination){
    //缺省代码，将飞机飞至目的地
}

class ModelA:public Airplane {...};
class ModelB:public Airplane {...};

//例子二：函数接口和缺省实现分离
//方式一
class Airplane{
    public:
        //pure virtual提高函数接口
        virtual void fly(const Airport& destination)=0;
        ...
    protected:
        //定义protected defaultFly让derived classes继承缺省实现
        void defaultFly(const Airport& destination);
};

void Airplane:defaultFly(const Airport& destination){
    //缺省行为，将飞机飞至目的地
}

class ModelA:public Airplane{
    public:
        virtual void fly(const Airport& destination){
            defaultFly(destination);
        }
};

class ModelB:public Airplane{
    public:
        virtual void fly(const Airport& destination){
            defaultFly(destination);
        }
};

class ModelC:public Airplane{
    public:
        virtual void fly(const Airport& destination);
        ...
};

void ModelC::fly(const Airport& destination){
    //将C型飞机飞至指定目的地
}

//方式二
class Airplane{
    public:
        virtual void fly(const Airport& destination)=0;
        ...
};
void AIrplane::fly(const Airport& destination)  //pure virtual函数实现
{
    //缺省行为，将飞机飞至目的地
}

class ModelA:public Airplane{
    public:
        virtual void fly(const Airport& destination){
            Airplane::fly(destination);
        }
        ...
};

class ModelB:public Airplane{
    public:
        virtual void fly(const Airport& destination){
            Airplane::fly(destination);
        }
};

class ModelC:public Airplane{
    public:
        virtual void fly(const Airport& destination);
        ...
};
void ModelC:fly(const Airport& destination){
    //将C型飞机飞至指定目的地
}
条款35：考虑virtual函数以外的其他选择
  • virtual函数的替换方案有以下几种:
    1. 使用non-virtual interface(NVI)手法，那是Template Method设计模式的一种特殊形式。它以public non-virtual成员函数包裹较低访问性(private或protected)的virtual函数
    2. 将virtual函数替换为“函数指针成员变量”，这是Strategy设计模式的一种分解表现形式
    3. 以function成员变量替换virtual函数，因而允许使用任何可调用物
    4. 将继承体系内的virtual函数替换为另一个继承体系内的virtual函数。这是Strategy设计模式的传统实现手法
//方式一:NVI手法
class GameCharacter{
    public:
        //计算游戏中人物的健康指数
        int healthValue() const{
            ...     //做一些事情工作
            int retVal=doHealthValue();     //做真正的工作
            ...     //做一些事后工作
        }
        ...
    private:
        //derived classes可重新定义它
        //若derived classes要实现多态，可将其定义为protected
        virtual int doHealthValue() const{
            //缺省算法,计算健康指数
        }
};

//方式二：使用函数指针
class GameCharacter;
//计算健康指数的缺省算法
int defaultHealthCalc(const GameCharacter& gc);
class GameCharacter{
    public:
        typedef int (*HealthCalcFunc) (const GameCharacter&);
        explict GameCharacter(HealthCalcFunc fcf=defaultHealthCalc):healthFunc(hcf)
        {}
        int healthValue() const{
            return healthFunc(*this);
        }
    private:
        HealthCalcFunc healthFunc;
};

class EvilBadGuy:public GameCharacter{
    public:
        explict EvilBadGuy(HealthCalcFunc hcf=defaultHealthCalc):GameCharacter(hcf)
        {...}
        ...
};

int loseHealthQuickly(const GameCharacter&);    //健康指数计算函数1
int loseHealthSlowly(const GameCharacter&);    //健康指数计算函数22

//不同人物使用不同的健康计算函数
EvilBadGuy ebg1(lossHealthQuickly);
EvilBadGuy ebg2(lossHealthSlowly);


//方式三:使用function(c++11中function在头文件<functional>中)
class GameCharacter;
//计算健康指数的缺省算法
int defaultHealthCalc(const GameCharacter& gc);
class GameCharacter{
    public:
        typedef function<int(const GameCharacter&)> HealthCalcFunc;
        explict GameCharacter(HealthCalcFunc fcf=defaultHealthCalc):healthFunc(hcf)
        {}
        int healthValue() const{
            return healthFunc(*this);
        }
    private:
        HealthCalcFunc healthFunc;
};

class EvilBadGuy:public GameCharacter{
    public:
        explict EvilBadGuy(HealthCalcFunc hcf=defaultHealthCalc):GameCharacter(hcf)
        {...}
        ...
};

int loseHealthQuickly(const GameCharacter&);    //健康指数计算函数1
int loseHealthSlowly(const GameCharacter&);    //健康指数计算函数22
struct HealthCalculator{
    int operator()(const GameCharacter&) const
    { ... }
};

//不同人物使用不同的健康计算函数
EvilBadGuy ebg1(lossHealthQuickly);
EvilBadGuy ebg2(lossHealthSlowly);
EvilBadGuy ebg2(HealthCalculator());

//方式四:使用传统的strategy设计模式
class GameCharacter;
class HealthCalcFunc{
    public:
        ...
        virtual int calc(const GameCharacter& gc) const
        { ... }
        ...
};

HealthCalcFunc defaultHealthCalc;

Class GameCharacter{
    public:
        explict GameCharacter(HealthCalcFunc* phcf=&defaultHealthCalc):pHealthCalc(phcf)
        {}
        int healthValue() const
        { return pHealthCalc->calc(*this);}
    private:
        HealthCalcFunc* pHealthCalc;
};
条款36：绝不重新定义继承而来的non-virtual函数
  • non-virtual函数的不变性凌驾其特异性，所以任何情况下都不该重新定义一个继承而来的non-virtual函数
条款37：绝不重新定义继承而来的缺省参数值
  • virtual函数是动态绑定的，而缺省参数值却是静态绑定的。(即在多态中，永远使用的都是base class的缺省参数，而不会使用derived class的缺省参数)
条款38：通过复合塑模出has-a或"根据某物实现出"
  • 复合的意义和public继承完全不同
  • 在应用域，复合意味has-a(有一个)。在实现域，复合意味is-implemented-in-terms-of(根据某物实现出)(?)
条款39：明智而审慎地使用private继承
  • private继承意味implemented-in-terms-of(根据某物实现出).private继承意味只有实现部分被继承.
    • 如果D以pirvate形式继承B，意思是D对象根据B对象实现而得，再没有其他意涵了
  • 使用复合(composition)通常可以替代private继承，所以尽可能使用复合，必要时才使用private继承(见例子)
  • 和复合不同，private继承可以造成empty base最优化。这对致力于“对象尺寸最小化”的程序库开发者而言，可能很重要(见例子)
//例子一：使用复合替代private继承
class Timer{
    public:
        explicit Timer(int tickFrequency);
        //函数每自动调用一次，定时器就滴答一次
        virtual void onTick() const;
        ...
};

//这里不能是public继承，因为Widget不是timer
class Widget:private timer{
    private:
        virtual void onTick() const;    //查看Widget的数据...等等
};


//使用复合
class Widget{
    private:
        class WidgetTimer:public Timer{
            public:
                virtual void onTick() const;
                ...
        };
        WidgetTimer timer;
};


//例子二：使用private继承进程empty base优化

//优化前:
class Empty();
class HoldAnInt{
    private:
        int x;
        Empty e;    //应该不需要任何内存
};

sizeof(Empty())==> =1 !!! //通常C++官方默默安插一个char到空对象内
sizeof(HoldAnInt)>sizeof(int)==> true

//优化后
class HoldAnInt:private Empty{
    private:
        int x;
};

sizeof(HoldAnInt)==sizeof(int)==> true      //编译器会进行`EBO`(empty base optimization;空白基类最优化)
条款40：明智而审慎地使用多重继承
  • 多重继承比单一继承复杂。它可能导致新的歧义性，以及对virtual继承的需要
  • virtual继承会增加大小、速度、初始化（及赋值）等等成本。如果virtual base classes不带任何数据，将是最具实用价值的情况
lingqing97
关注
专栏目录
C++三大特性笔记
杨
09-16 652
C++ 三大特性 封装，继承，多态 封装 定义：封装就是将抽象得到的数据和行为相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成类，其中数据和函数都是类的成员，目的在于将对象的使用者和设计者分开， 以提高软件的可维护性和可修改性 特性：1. 结合性，即是将属性和方法结合 2. 信息隐蔽性，利用接口机制隐蔽内部实现细节，只留下接口给外界调用 3. 实现代码重用 继承 定义：继承就是新类从已有类那里得到已有的特性。 类的派生指的是从已有类产生新类的过程。原有的类成为基类或
Effective C++ 阅读笔记之Chapter1
qq_51387669的博客
10-27 167
前言 大家好，我是雨墨，我深知好记性不如烂笔头的道理，所以在阅读的时候都尽量写读书笔记，方便日后复习，当然笔记并不能代替书籍上的内容。希望我的笔记也能帮助到大家，如果我的笔记有什么问题，欢迎大家给小老弟纠错~ 条款一总结 视 C++ 为 C 、 面向对象、template、STL 的联邦 条款二总结 宏定义的坏处： 一方面以 #define example 17举例 编辑器调试的时候，很有可能会造成错误信息是17，然后让你不知所措，这是什么？从哪来的？。 预处理器可能盲目地将example替换成17，导
C++的三大特性
继续微笑lsj
09-27 3715
OOP具有三大特性：封装性、继承性和多态性。 1.封装性(Encapsulation)      所谓封装，就是将某些东西包装和隐藏起来，让外界无法直接使用，只能通过某些特定的方式才能访问。OO将万物都视为“对象”(Object)，任何对象都具有特性和行为。我们将其特性称为“成员变量” (MemberVarible)，将其行为称之为“成员函数"(Member Function)，被封装的特
理解C++三大特性
Doo66的博客
08-15 1万+
封装，继承，多态      封装可以隐藏实现细节，使得代码模块化，继承可以扩展已存在的模块，它们目的都是为了：代码重用。而多态是为了实现另一个目的：接口重用。 什么是多态？      eg：开门，开窗户，开电脑，这里“开”就是多态。      多态性可以简单概括为“一个接口，多种实现”，是通过虚函数实现的。基类提供一个虚接口，其派生类重写这个接口，这样就构成了多态。
C++之三大特性 “封装”、“继承”、“多态”
qq_49613557的博客
10-25 1万+
C++之三大特性 “封装”、“继承”、“多态” 目录封装继承继承的概念及定义基类和派生类对象赋值转换继承中的作用域派生类的默认成员函数继承与友元继承与静态成员复杂的菱形继承及菱形虚拟继承继承的总结和反思多态二级目录三级目录 封装 继承 继承的概念及定义 继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触
C++三大特性
zoutaofen的博客
05-13 4642
C++三大特性前言一、封装二、继承三、多态 前言 C++三大特性—封装、继承、多态。 封装目的是实现代码模块化。 继承目的是实现代码扩展。 多态目的是分为静态多态和动态多态。静态多态：函数重载和泛型编程。动态多态：虚函数重写。 一、封装 封装就是将数据和行为(或功能)有机结合起来，形成一个整体。把数据和处理数据的操作结合形成类，数据和函数都是类的成员。增强安全性和简化编程。对外隐藏实现细节暴露公共接口。外部通过接口来调用。 封装类的访问类型： 私有成员(private)，只有此类的成员函数才能访问。 保护
[翻译]《Programming - Principles and Practice Using C++, Second Edition》- Chapter 1
WarwickCSProject
09-03 3020
本文导航（全文字左右，按正常阅读速度，大概需要分钟）Computers, People, and Programming 计算机，人和编程1.1 Introduction 介绍 Computers, People, and Programming 计算机，人和编程 Specialization is for insects. 专业化是为昆虫准备的。（而人应该什么都会做） ——R. A. Heinlein 罗伯特 · 海因莱因 1 In this chapter, we present some
SAP读书笔记
li_tony的专栏
11-26 4781
   作者：dyq_972 提交日期：2008-2-27 20:03:00 | 分类: | 访问量：1126 Pfcg Su53 查看权限对象 st01 跟踪 St22 看dump，以分析错误 eg.找到ABAP程序出错的地方，找出founction，用se37查看找到的founction，找到有关权限检查（authority check），找到object，在p
Modern C++ Design 笔记 第十一章 MultiMethods(2)
斯巴达的勇士已经是雅典的臣民了。。。
02-01 2405
 紧接这上次没说完的来说。上回我们介绍了最基本的brute-force方案。那个安全的类型遍历匹配方案。说到在类数量比较多的时候不一定高效。很简单的可以知道原来的时间复杂度是O(n)，n就是类的数量。所以估摸这转化成O(log(n))应该差不多了。所以这个第二方案就是用关联性的容器来替代依次遍历。我们把这个方案称之为The Logarithmic Double Dispatcher. 就像Scot
计算机视觉学习资料汇总（超多干货）
qq_29462849的博客
12-21 3940
前言 本资料首发于公众号【3D视觉工坊】，更多干货请关注公众号后台回复关键字获取~ （一）基础操作 Linux 学习网站 Linux中国：https://linux.cn/ 鸟哥的linux私房菜：http://linux.vbird.org/ Linux公社： https://www.linuxidc.com/ 学习书籍 《鸟哥的Linux私房菜》 《Linux命令行与shell脚本编程大全》 ...
C++封装、继承、多态
热门推荐
ruyue_ruyue的专栏
11-22 10万+
C++封装继承多态总结 面向对象的三个基本特征 面向对象的三个基本特征是：封装、继承、多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！ 封装
C++三大特性：封装、继承、多态
Lose_Raven
09-25 585
1.面向对象 面向对象的三大特性：封装、继承、多态。        类和对象：类由数据成员和成员函数构成，代表抽象派，玩的就是概念，某种意义上来说是一种行为艺术；而对象是具体的，比如说过年回家和老爹下中国象棋，发现棋盘上少了一对‘象’，那是你爸在告诉你该找“对象”了（单身狗表示选择Go Die）。 　　封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不
c++ 三大特性
xmmdbk的博客
03-22 1049
封装：将函数具体实现的细节隐藏，提供调用接口，这样使程序更安全，更容易管理。继承：指可以使用现有类所有的功能，一个对象可以直接使用另外一个对象的所有属性和方法。并在无需编写原来代码的情况下可以进行扩展功能，继承是一种从一般到特殊的一种关系。多态：从编码角度，多态就是同一种调用，可以产生，多种不同的效果，利用同一类类型的指针来指向不同类的对象。虚函数的实现，就体现多态性。...
c++三大特性
无问西东的博客
12-06 6719
C++的三大特性为：继承，多态，封装 封装可以隐藏实现细节，使得代码模块化， 继承可以扩展已存在的模块，它们目的都是为了： 代码重用。 而多态是为了实现另一个目的： 接口重用。 （1）继承。 一个对象直接使用另一个对象的属性和方法。 定义：继承就是新类从已有类那里得到已有的特性。 类的派生指的是从已有类产生新类的过程。原有的类成为基类或父类，产生的新类称为派生类或子类， 子类继承基类后，可以创建子类对象来调用基类函数，变量等 优点： 1.减少重复的代码。 2.继承是多态的前提。 3.继承增加了类的耦合性。
Effective C++ 读书笔记与理解
"Effective C++读书笔记" 在深入探讨《Effective C++》的读书笔记之前，首先需要明白这本书是由Scott Meyers所著，是C++程序员必读的经典之一，旨在帮助开发者掌握C++语言的高级技巧和最佳实践。笔记中提到了几个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值