(2011.09.27)《C++ Primer》第三部分学习笔记汇总——类和数据抽象

 

《C++ Primer》第三部分学习笔记汇总——类和数据抽象

 

《C++ Primer》 第12章学习笔记

第12章：类

——在C++中，用类来定义自己的抽象数据类型（abstract data type）。

 

第一节：类的定义和声明

 

@学习摘录126：数据抽象和封装

——类背后蕴涵的基本思想是：数据抽象和封装

 

@学习摘录127：类的数据抽象

——数据抽象是一种依赖于接口和实现分离的编程（和设计）技术。

——类设计者必须关心类是如何实现的，但使用该类的程序员不必了解这些细节。

 

@学习摘录128 ：类的封装

——封装是一项将低层次的元素组合起来形成新的、高层次实体的技术。

——函数是封装的一种形式：函数所执行的细节行为被封装在函数本身这个更大的实体中。

——被封装的元素隐藏了它们的实现细节——可以调用一个函数但不能访问它所执行的语句。

——类也是一个封装的实体：它代表若干成员的聚集，大多数（良好设计的）类类型隐藏了实现该类型的成员。

 

@学习摘录129：三种特殊的类型讨论抽象与封装性

——标准库类型vector同时具备数据抽象和封装的特性。

——数组在概念上类似于vector，但既不是抽象的，也不是封装的。可以通过访问存放数组的内存来直接操纵数组。

——标准库中的pair类就是一个实用的、设计良好的具体类而不是抽象类。具体类会暴露而非隐藏其实现细节。pair类型只是将两个数据成员捆绑成单个对象。

 

@学习摘录130：数据抽象与封装的好处

——1. 避免类内部出现无意的、可能破坏对象状态的用户级错误。

——2. 随时间推移可以根据需求改变或缺陷（bug）报告来完善类实现，而无须改变用户级代码。

——仅在类的私有部分定义数据成员，类的设计者就可以自由地修改数据。

——如果类的内部状态是私有的，则数据成员的改变只可能在有限的地方发生。

——如果数据是私有的并且没有改变成员函数的接口，则操纵类对象的用户函数无须改变。

 

@学习摘录131：可变数据成员

——可变数据成员永远都不能为const，甚至当它是const对象的成员时也如此。

——当成员声明为mutable成员时，则能破坏const性质，可以改变类的数据成员。

——如：

class Screen

{

public:

// interface member functions

private:

  mutable size_t access_ctr;   // may change in a const members

// other data members as before

};

 

第三节：类作用域

 

@学习摘录132：函数返回类型不一定在类作用域中

——如果返回类型使用由类定义的类型，则必须使用完全限定名。

class Screen

{

public:

  typedef std::string::size_type index;

  index get_cursor() const;

};

inline Screen::index Screen::get_cursor() const

{

 return cursor;

}

摘录有想132：

——个人看书理解：完全限定名是指全整的命名空间的名字

——如： Screen::index Screen::get_cursor()

 

@学习摘录133：类定义的处理阶段

——类定义实际上是在两个阶段处理：

——1. 首先，编译成员声明；

——2. 只有在所有成员出现之后，才编译它们的定义本身。

 

@学习摘录134：类成员声明的名字查找

——按以下方式确定在类成员的声明中用到的名字。

——1. 检查出现在名字使用之前的类成员的声明。

——2. 如果第一步查找不成功，则检查包含类定义的作用域中出现的声明以及出现在类定义之前的声明。

——例如：

typedef double Money;

class Account

{

public:

  Money balance()  {return bal;}

private:

  Money bal;

  // …

};

——在处理balance函数的声明时，编译器首先在类Account的作用域中查找Money的声明。——编译器只考虑出现在Money使用之前的声明。

——因为找不到任何成员声明，编译器随后在全局作用域中查找Money的声明。

——必须在类中先定义类型的名字，才能将它们用作数据成员的类型，或者成员函数的返回类型或形参类型。

 

@学习摘录135：类成员定义中的名字查找

——按以下方式确定在成员函数的函数体中用到的名字。

——1. 首先检查成员函数局部作用域中的声明。

——2. 如果在成员函数中找不到该名字的声明，则检查对所有类成员的声明。

——3. 如果在类中找不到该名字的声明，则检查在此成员函数定义之前的作用域中出现的声明。

 

第四节：构造函数的初始化式

——从概念上讲，可以认为构造函数分为两个阶段执行

——1. 初始化阶段

——2. 普通的计算阶段。

——不管成员是否在构造函数初始化列表中显式初始化，类类型的数据成员总是在初始化阶段初始化。

——初始化发生在计算阶段开始之前。

 

@学习摘录136：有时需要构造函数初始化列表

——有些成员必须在构造函数初始化列表中进行初始化。对于这样的成员，在构造函数函数体中对它们赋值不起作用。

——没有默认构造函数的类类型的成员，以及const或引用类型的成员，不管是哪种类型，都必须在构造函数初始化列表中进行初始化。

 

@学习摘录137：建议使用构造函数初始化列表

——在许多类中，初始化和赋值严格来讲都是低效率的：数据成员可能已经被直接初始化了，还要对它进行初始化和赋值。

——比效率更重要的是，某些数据成员必须要初始化，这是一个事实。

——当类成员需要使用初始化列表时，通过常规地使用构造函数和初始化列表，就可以避免发生编译时错误。

 

@学习摘录138：成员初始化的次序

——成员被初始化的次序就是定义成员的次序

——初始化的次序常常无关紧要。但若一个成员是根据其他成员而初始化，则成员初始化的次序是至关重要的。

——建议：按照成员声明一致的次序编写构造函数初始化列表。

——此外，尽可能避免使用成员来初始化其他成员。

 

@学习摘录139：合成的默认构造函数

——只要一个类定义了一个构造函数，编译器再也不会生成默认构造函数。

——只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。

 

@学习摘录140：抑制由构造函数定义的隐式转换

——可以通过将构造函数声明为explicit，来防止在需要隐式转换的上下文中使用构造函数。

——explicit关键字只能用于类内部的构造函数声明上。

——通常，除非有明显的理由想要定义隐式转换，否则，单形参构造函数应该为explicit.

 

@学习摘录141：类成员的显式初始化

——显式初始脂类类型对象的成员有三个得大缺点

——1. 要求类的全体数据成员都是public

——2. 将初始化每个对象的每个成员的负担放在程序员身上。

——  这样的初始化是乏味且易于出错的，因为容易遗忘初始化式或提供不适当的初始化式。

——3. 如果增加或删除一个成员，必须找到所有的初始化并正确更新。

 

@学习摘录142：从C语言继承过来类的全部数据成员为public的显式初始化

——见实例：

struct Data

{

  int ival;

  char *ptr;

};

// val1.ival = 0;  val1.ptr = 0;

Data val1 = {0, 0};

// val2.ival = 1024;  val2.ptr = “Anna Livia Plurabelle”

Data val2 = {1024, “Anna Livia Plurabelle” };

 

第五节：友元

——友元（friend）机制允许一个类将其非公有成员的访问权授予指定的函数或类。

——通常，将友元声明成组地放在类定义的开始或结尾是个好主意。

 

第六节： static类成员

 

@学习摘录143：使用类的static成员的三大优点

——1. static成员的名字是在类的作用域中，因此可以避免与其他类的成员或全局对象名字冲突。

——2. 可以实施封装。static成员可以是私有成员，而全局对象不可以。

——3. 通过阅读程序容易看出static成员是与特定类关联的。这种可见性可清晰地显示程序员的意图。

 

@学习摘录144：定义static成员

——对象没有与static数据成员对应的数据成员，但是，存在一个单独的interestRate对象，由Account类型的全体对象共享。

class Account

{

public:

// interface functions here

void applyint()  {amount += amount * interestRate;}

static double rate() {return interestRate;}

static void rate(double);  // sets a new rate

private:

std:string owner;

double amount;

static double interestRate;

static double initRate();

};

——类外使用：rate = Accout::rate();

 

@学习摘录145：static成员函数

——当我们在类的外部定义static成员时，无须重复指定static保留字，该保留字只出现在类定义体内部的声明处。

void Account::rate(double newRate)

{

         interestRate = newRate;

}

 

@学习摘录146：static函数没有this指针

——static成员是类的组成部分但不是任何对象的组成部分，因此，static成员函数没有this指针。通过使用非static成员显式或隐式地引用this是一个编译时错误。

 

@学习摘录147：static数据成员的初始化

——static数据成员必须在类定义体的外部定义（正好一次）。不像普通数据成员，static成员不是通过类构造函数进行初始化，而是应该在定义时进行初始化。

——初始化static数据成员，先指定类型名，接着是成员的完全限定名：

—— double Account::interestRate = initRate();

——这规则有一个例外是，只要初始化式是一个常量表达式，整型const static数据成员就可以在类的定义体中进行初始化。

——如： private:  static cons tint period = 30;

 

@学习摘录147：static成员不是类对象的组成部分

——static成员独立于任何对象而存在，不是类类型对象的组成部分。

——static数据成员的类型可以是该成员所属的类类型。

——如：

class Bar

{

public:

// ….

private:

static Bar mem1;  // ok

Bar *mem2;     // ok

Bar mem3;      // error

};

 

 

《C++ Primer》 第13章学习笔记

第13章：复制控制

——复制构造函数、赋值操作符和析构函数总称为复制控制（copy control）。

——有一种特别常见的情况需要类定义自己的复制控成员的：类具有指针成员。

 

第一节：复制构造函数

——只有单个形参，而且该形参是对本类类型对象的引用（常用const修饰），这样的构造函数称为复制构造函数。

——复制构造函数可由编译器隐式调用。

 

@学习摘录148：复制构造函数与默认构造函数

——一般来说，最好显式或隐式定义默认构造函数和复制构造函数。

——只有不存在其他构造函数时才合成默认构造函数。

——如果定义了复制构造函数，也必须定义默认构造函数。

 

@学习摘录149：初始化的复制形式和直接形式

——直接初始化直接调用与实参匹配的构造函数，复制初始化总是调用复制构造函数。

——复制初始化首先使用指定构造函数创建一个临时对象，然后用复制构造函数将那个临时对象复制到正在创建的对象。

——有些类的构造函数定义为explicit。如果构造函数是显式的，则初始化失败；如果构造函数不是显式的，则初始化成功。

——class Foo { Foo(const Foo&); // copy constructor };

 

@学习摘录150：合成的复制构造函数

——如果我们没有定义复制构造函数，编译器会为我们合成默认构造函数（synthesized copy constructor）。

——即使我们定义了其他构造函数，也会合成复制构造函数。

 

@学习摘录151：逐个成员初始化（memberwise initialize）

——合成复制构造函数执行逐个成员初始化，将新对象初始化为原对象的副本。

——逐个成员初始化最简单的概念模型是，将合成复制构造函数看作每个数据成员在构造函数初始化列表中进行初始化。

 

@学习摘录152：禁止复制

——有些类需要完全禁止复制，为了防止复制，类必须显式声明其复制构造函数为private。

——如果复制构造函数是私有的，将不允许用户代码复制该类类型的对象，编译器将拒绝任何进行复制的尝试。

——当声明一个(private)复制函数但不对其定义时，可以连友元和成员中的复制也禁止。

——声明而不定义成员函数是合法的，但是，使用未定义成员的任何尝试将导致链接失败。

 

第二节：赋值操作符

 

@学习摘录153：赋值操作符的定义

——赋值操作符的返回类型应该与内置类型赋值运算返回的类型相同。

——class Sales_item{ Sales_item& operator = (const Sales_item & ); };

 

@学习摘录154：合成赋值操作符

——合成赋值操作符会执行逐个成员赋值：右操作数对的每个成员赋值给左操作数对象的对应成员。

——除数组之外，每个成员用所属类型的常规方式进行赋值。对于数组，给每个数组元素赋值。

 

第三节：析构函数

——析构函数通常用于释放在构造函数或在对象生命期内获取的资源。

 

@学习摘录155：何时编写显式析构函数

——如果类需要析构函数，则它也需要赋值操作符和复制构造函数，这是一个有用的经验法则，称为三法则（rule of three）。

 

@学习摘录156：合成析构函数

――与复制构造函数或赋值操作符不同，编译器总会为我们合成一个析构函数。

——析构函数与复制函数或赋值操作符之间的一个重要区别是，即使我们编写了自己的析构函数，合成析构函数仍然运行。

——合成析构函数按对象创建时的逆序撤销每个非static成员，因此，它按成员在类中声明次序的逆序撤消成员。

 

第五节：管理指针成员

——包含指针的类需要特别注意复制控制，原因是复制指针时只复制指针中的地址，而不会复制指针指向的对象。

 

@学习摘录157：管理指针成员的方法

——1. 指针成员采取常规指针型行为。　这样的类具有指针的所有缺陷但无需特殊的复制控制。

——2. 类可以实现所谓的“智能指针”行为。指针所指向的对象是共享的，但类能够防止悬垂指针。（悬垂指针主要使用的是使用计数技术）

——3. 类采取值型行为。指针所指向的对象是唯一的，由每个类对象独立管理。

摘录有想157：

——之前一直对智能指针不怎么懂，今天，再次看了几个例子以后，自己打了一次代码以后，发觉，原来，这个智能指针也没有想像中的复杂，只是多了一个计数的功能。

 

@学习摘录158：智能指针

——一个行为类似指针但也提供其他功能的类。

——智能指针的一个通用形式接受指向动态分配对象的指针并负责删除该对象。

——用户分配对象，但由智能指针删除它。

——智能指针类需要实现复制控制成员来管理指向共享对象的指针。

——只有在撤消了指向共享对象的最后一个智能指针后，才能删除该共享对象。

——使用计数是实现智能指针类的最常用的方式。

 

 

 

《C++ Primer》 第14章学习笔记

第14章：重载操作符与转换

——这里说一下，这章的学习笔记比较少，因为将本章看了一遍后，感觉可以收益的地方，的确不算多。

 

@学习摘录159：输入和输出操作符最主要区别

——输入和输出操作符有如下区别：输入操作符必须处理错误和文件结束的可能性。

 

第九节：转换与类类型

 

@学习摘录160：避免转换函数的过度使用

——转换操作符有两个潜在的缺陷：

——1. 定义太多转换操作符可能导致二义性代码；

——2. 一些转换可能利大于弊。

——避免二义性最好的方法是：

——保证最多只有一种途径将一个类型转换为另一类型。

——做到这一点，最好的方法是限制操作符的数目，尤其中，到一种内置类型应该只有一个转换。

 

@学习摘录161：转换和操作符

——如果类既定义了转换操作符又定义了重载操作符，容易产生二义性。

——1. 不要定义相互转换的类，即如果类Foo具有接受类Bar的对象的构造函数，不要再为类Bar定义到类型Foo的转换操作符。

——2. 避免到内置算术类型的转换。