007's Studio.

Effective c++ 读书笔记第一章

C++ Effective C++
字数统计: 2.7k阅读时长: 11 min
2019/07/13 Share


Ⅰ、 让自习惯C++


条款01：视C++为一个语言连邦

C++是一个多重泛型编程语言，同时支持过程形式、面向对象形式、泛型形式、元编程形式的语言。

将C++是为一个联邦,主要的此语言为4个：

1.procedural-based C。C语言的面向过程
2.Object-Oriented C++。面向对象
3.Template C++。 C++ 的泛型 (generics) 编程和由 template 的强大功能带来 template metaprogramming (TMP,模板元编程)
4.STL。template程序库，主要包括 容器、迭代器、算法以及函数对象

tips:编程过程中在前面3个次语言之间切换时，可能导致高效编程守则要求的改变


条款02:尽量以 const, enum, inline 替换 #define

2.1、采用const替换#define

此处用宏定义一个常量

1
#define ASPECT_RATIO 1.653

记号名称ASPECT_RATIO可能未被登记到记录表(symbol table), 因为可能在编译前的预处理阶段被替换。
导致发生错误时不容易追踪该信息。

采用常量替换:

1
const double AspectRatio = 1.653 //大写名称通常用于宏，此处改变名称写法

常量定义式通常放在头文件

定义一个常量的 char*based字符串（不可改变指向不可改变内容）

1
2
3
4
5
6
const char* const autorName = "Scott Meyers"; 
//根据c++ primer观点，第一个const为底层const,保证指针指向内容不变
//第二个const为顶层const,保证指针指向地址不变

//采用string
const std::string autoirName("Scott Meyers");

定义一个class的专属常量

1
2
3
4
5
6
class GamePlayer{
    private:
        static const int NumTurns = 5; //这里只是常量声明式，声明式，声明式
        int scores[NumTurns];		//使用它
        ...
    };

  C++中 class专属常量又是static且为整数类型(eg: int,char,bool).需要特殊处理，如果未取地址，可以只声明，否则需要另外提供定义式。

1
const int GamePlayer::NumTurns;		//类内已经初始化赋值，无须也无法重新赋值。

#define无法为一个 class 定义一个专属变量，因为 #define 并不重视作用域。
也就是不存在所谓的 private #define

2.2、采用enum替换#define

  旧式编译器不支持 static 成员在声明式上获得初值，”in class” 初值设定也只允许对整数常量进行。
此时，需要将初值放在定义式：

1
2
3
4
5
6
7
class CostEstimate{
private:
    static const double FudgeFactor;	//static class 常量声明
    ...
};
const double
    CostEstimate::FudgeFactor = 1.35;	//位于实现文件内

  类内的数组声明式，编译器坚持必须在编译期间知道数组的大小。如果编译器不允许 “static 整数型class常量” 完成 “in class”初值设定，可改用所谓的 “the enum hack” 补偿做法。

1
2
3
4
5
6
7
class GamePlayer{
private:
    enum { NumTurns = 5};		//"the enum hack"
                                //令 NumTurns成为5的一个记号名称
    int socres[NumTurns];
    ...
};

注意：enum不能取地址

2.3、采用 template替换 #define

另一个常见的 #define 误用情况是以它实现宏（macros）。

1
2
//用宏比较a和b的较大值来调用f
#define CALL_WITH_MAX(a,b) f(a)>f(b) ? (a) : (b) )

缺点： 要为实参添加小括号防止错误，还有一些不容易发现的错误

如下：

1
2
3
int a = 5,b = 0;
CALL_WITH_MAX(++a, b);		//a被累加了两次
CALL_WITH_MAX(++a, b+10);	//a被累加了一次

采用template函数替代

1
2
3
4
5
template<typename T>
inline void callWithMax(const T& a,const T& b){	//采用 pass by reference-to-const
                                                //可以传递所有类型.
    f(a > b ? a : b);
}


条款03：尽可能使用const

3.1、const成员函数

目的：

1.使class接口比较容易被理解，那些可以改动，那些不行
2.使“操作const对象”称为可能。pass-by-reference-to-const方式传递对象。

const函数可被重载
1.const对象只能调用 const版本
2.non-const对象可以调用 const和non-const版本，默认为non-const版本。

3.2、bitwise constness 和 logical constness

1、bitwise const阵营的人相信，成员函数只有在不改变对象的任何成员变量(static除外)时
才可以说是 const。即不改变对象内的任何一个 bit 。
这种论点好处是很容易侦测违反点。
bitwise constness正是 C++ 对常量性的定义，因此 const 成员函数不可以更改对象内的
任何non-static成员变量。

不幸的是很多不具备const性质的函数却可以通过 bitwise测试。
实例：

1
2
3
4
5
6
7
8
9
10
11
12
class CTextBlock{
public:	
    ...
    char& operator[](std::size_t position) const	//bit const声明
    { return pText[position]; }                         //但实际没起到效果
private:
    char* pText;
};
//此时
const CTextBlock cctb("Hello");	//声明一个常量对象
char *pc = &cctb[0];
*pc = 'J';						//此时cctb变为 “Jello”

2、这种情况导出了所谓的logical constness。他们主张，一个 const成员函数
可以修改它所处理的对象内的某些 bits, 但只有在客户端侦测不出的情况下才得如此。

例如： CTextBlock class有可能高速缓存文本区域的长度以便询问：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class CTextBlock{
public:
    ...
    std::size_t length() const;
private:
    char *pText;
    std::size_t textLength;	//最近一次计算的文本区域长度
    bool lengthIsValid;		//当前长度是否有效
};
std::size_t CTextBlock::length() const
{
    if(!lengthIsValid)	{
        textLength = std::strlen(pText);	//error!!! const函数内
        lengthIsValid = true;				//不允许修改类成员
    }
    return textLength;
}

解决方案 mutable释放 non-static成员变量的bitwise constness约束

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class CTextBlock{
public:
    ...
    std::size_t length() const;
private:
    char *pText;
    mutable std::size_t textLength;	//mutable可能总是会被更改，
    mutable bool lengthIsValid;		//即使在const函数内
    };
    std::size_t CTextBlock::length() const
    {
        if(!lengthIsValid)	{
            textLength = std::strlen(pText);	//现在valid
            lengthIsValid = true;
        }
        return textLength;
    }

3.3、在 const 和 non-const 成员函数中避免重复

假设TextBlock的 operator[] 不单单返回一个 reference，还要做各种检测，
这样会导致写出的 const 和 non-const operator[] 冗余。

解决方案 令 non-const版本调用 const版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class TextBlock{
public:
    ...
    const char& operator[](std::size_t position) const //一如既往
    {   ...
        ...
        ...
        return text[position];
    }
    char& operator[](std::size_t position)           //调用 const版本
    {
        return
            const_cast<char>&(                      //将op[]返回值的const转除
            static_cast<const TextBlock&>(*this)    //为*this加上const
                [position];         //调用 const op[];
            );
    }
        ...
};

注意：反向操作将 const函数调用 non-const是不可取的


条款04：确定对象使用前已被初始化

定义类Point

1
2
3
4
5
class Point{
    int x,y;
};
...
Point p;	//p成员变量有时候会被初始化（为0），有时候不会

1.使用 C part of C++ 而且初始化可能招致运行期成本，那么不保证初始化
2.non-C parts of C++,则有所变化，如 vector（STL part of C++）保证初始化,
array（C part of C++) 不保证内容初始化。

最佳处理办法： 永远在使用对象前先将其初始化。对于无任何成员的内置类型，你必须手工完成此事。例如：

1
2
3
4
int x = 0;                              //对int初始化
const char* text = "A C-style string";	//对指针初始化
double d;
std::cin >> d;                          //调用输入流初始化

4.1、区分赋值和初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class PhoneNumber { ...};
class ABEntry{
public:
    ABEntry(const std::string&name, const std::string& address,//构造函数
            const std::list<PhoneNumber>& phones);
private:
    std::string theName;
    std::string theAddress;
    std::list<PhoneNumber> thePhones;
    int numTimesConsulted;
};
ABEntry::ABEntry(const std::string& name, const std::string& address,  
                const std::list<PhoneNumber>& phones)
{
    theName = name;         //这些都是赋值
    theAddress = address;   //而非初始化
    thePhone = phones;
    numTimesConsulted = 0;
}

  对象的初始化发生在进入构造函数之前，故以上的 theName, theAddress 和 thePhones均不是初始化，而是赋值。初始化发生在某些对象的default构造函数调用时，此时未进入ABEntry构造函数体，而对于 numTimesConsulted这类内置类型，赋值动作的时间点不确定。

采用 member initialization list (成员初值列）来为对象的成员初始化。

1
2
3
4
5
6
7
ABEntry::ABEntry(const std::string& name, const std::string& address,  
                 const std::list<PhoneNumber>& phones)
    :theName(name),	    //此处均为初始化，如果
    theAddress(address),    //类成员没有在指定，编译器
    thePhones(phones),      //调用默认构造函数
    numTimesCosulted(0)		
    {}

如果成员变量为 const 或 references，则一定需要初值，不能被赋值。

C++成员初始化次序
base classes 更早由于其 drived classes 被初始化，而 class 的成员变量按照成员声明次序被初始化

4.2、不同编译单元内定义的 non-local static 对象的初始化次序

local static对象： 寿命从构造直至程序结束为止，因此不包括 stack和heap-based对象。这种对象包括 global对象 、定义于namespace作用域内的对象、在classed内、在函数内、以及在 file作域内被声明为 static的对象。
函数内的 static对象称为为 local static对象(它们相对函数而言为 local)，其他 static对象称为 non-local static对象。它们的析构函数会在 main()结束时自动调用。

编译单源：是指产出单一目标文件的那些源码。基本上它是单一源码文件加上其所含的头文件。

问题在于C++对于定义于不同编译单元内的 non-local static对象的初始化次序并无明确定义

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class FileSystem{		//编译单元A
public:
    ...
    std::size_t numDisk() const;
    ...
};
extern FileSystem tfs;	//预备给用户使用的对象
/*----------------------------------------------------------*/
class Directory{
public:
    Directory( params); //编译单元B
    ...
};
Directory::Directory( params)
{
    ...
    std::size_t disks = tfs.numDisks();
    ...
}

假设，采用 创建一个 Driectory对象 

1
Directory tempDir( params);

  此时 tempDir构造函数调用了 dfs函数对象，故 dfs必须先于 tempDir初始化，否则后果很严重。以下是解决方案：

采用 local static对象替换 non-local static对象
这是 Singleton模式的一个常见手法

这个手法基础在于：C++保证,函数内的local static对象会在“该函数被调用期间”
“首次遇上该对象的定义式”时被初始化。如果函数从未调用，则不会生成对象，
也免去了多余的构造函数析构函数的调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class FileSystem{...};              //同前
FileSystem& tfs()                   //定义一个local static对象 
{                                   //返回一个reference
    static FileSystem fs;
    return fs;
}
class Directory{...};               //同前
Directory::Directory( params)			
{
    ...
    std::size_t disk = tfs().numDisks();
    ...
}
Directory& tempDir()                //同前,返回一个 reference to tfs
{
    static Directory td;
    return td;
}

以上的 reference-returing函数往往十分单纯：定义并初始化一个local static，然后返回它。

注意：这些内含 static对象的事实使他们在多线程有不确定性。任何一种 non-const static对象，无论是local还是non-local，多线程环境下的等待某事发生都会有麻烦。

解决方案：在程序单线程启动阶段手工调用所有reference-returing函数，可以消除与初始化有关的“竞速形势”。

原文作者：007havegone

原文链接：http://007havegone.github.io/2019/07/13/Effective-c-读书笔记第一章/

发表日期：July 13th 2019, 10:28:44 pm

更新日期：August 18th 2019, 9:34:29 pm

版权声明：‘原创内容，转载时请附上出处’

CATALOG
  1. 1. Ⅰ、 让自习惯C++
    1. 1.1. 条款01：视C++为一个语言连邦
    2. 1.2. 条款02:尽量以 const, enum, inline 替换 #define
      1. 1.2.1. 2.1、采用const替换#define
      2. 1.2.2. 2.2、采用enum替换#define
      3. 1.2.3. 2.3、采用 template替换 #define
    3. 1.3. 条款03：尽可能使用const
      1. 1.3.1. 3.1、const成员函数
      2. 1.3.2. 3.2、bitwise constness 和 logical constness
      3. 1.3.3. 3.3、在 const 和 non-const 成员函数中避免重复
    4. 1.4. 条款04：确定对象使用前已被初始化
      1. 1.4.1. 4.1、区分赋值和初始化
      2. 1.4.2. 4.2、不同编译单元内定义的 non-local static 对象的初始化次序
Total : 23
2019
算法导论 持久动态集合 二叉搜索树 逆序对 主方法 时间复杂度 算法分析 排序 线段树 中位数 二分查找 d叉堆 操作系统 Win10 cmd 二叉树 中序遍历 VS Code Markdown Tomcat IDEA Tomcat乱码 Server tomcat启动失败 Eclipse无法创建虚拟机 vm参数 Jdk版本过高 C++ Effective C++ 顺序统计树 Young氏矩阵 堆 红黑树 平衡树 数据结构
算法导论 操作系统 踩坑 Tomcat tomcat 读书笔记 数据结构 数据结构/算法导论