C++ 总结

来源：互联网发布：mac酷狗制作铃声编辑：程序博客网时间：2024/05/10 03:58

一、C++类的定义

C++中使用关键字 class 来定义类, 其基本形式如下:
class 类名
{

public:

//公共的行为或属性

private:

//公共的行为或属性

};

示例:
定义一个点(Point)类, 具有以下属性和方法:
■ 属性: x坐标, y坐标
■ 方法: 1.设置x,y的坐标值; 2.输出坐标的信息。
实现代码:

class Point

{

public:

void setPoint(int x, int y);

void printPoint();

private:

int xPos;

int yPos;

};

代码说明:
上段代码中定义了一个名为 Point 的类, 具有两个私密属性, int型的xPos和yPos, 分别用来表示x点和y点。

在方法上, setPoint 用来设置属性, 也就是 xPos 和 yPos 的值; printPoint 用来输出点的信息。

1 数据抽象和封装

抽象是通过特定的实例抽取共同特征以后形成概念的过程。一个对象是现实世界中一个实体的抽象，一个类是一组对象的抽象。
封装是将相关的概念组成一个单元，然后通过一个名称来引用它。面向对象封装是将数据和基于数据的操作封装成一个整体对象，对数据的访问或修改只能通过对象对外提供的接口进行。

2 类定义

几个重要名词：

(1) 类名

遵循一般的命名规则; 字母，数字和下划线组合，不要以数字开头。

(2) 类成员

类可以没有成员，也可以定义多个成员。成员可以是数据、函数或类型别名。所有的成员都必须在类的内部声明。
没有成员的类是空类，空类也占用空间。

class People

{

};
sizeof(People) = 1;

(3) 构造函数

构造函数是一个特殊的、与类同名的成员函数，用于给每个数据成员设置适当的初始值。

(4) 成员函数

成员函数必须在类内部声明，可以在类内部定义，也可以在类外部定义。如果在类内部定义，就默认是内联函数。

3 类定义补充

3.1 可使用类型别名来简化类

除了定义数据和函数成员之外，类还可以定义自己的局部类型名字。

使用类型别名有很多好处，它让复杂的类型名字变得简单明了、易于理解和使用，还有助于程序员清楚地知道使用该类型的真实目的。

class People

{

public:

typedef std::string phonenum; //电话号码类型

phonenum phonePub; //公开号码

private:

phonenum phonePri;//私人号码

};

3.2 成员函数可被重载

可以有多个重载成员函数，个数不限。

3.3 内联函数

有三种：

（1）直接在类内部定义。
（2）在类内部声明，加上inline关键字，在类外部定义。
（3）在类内部声明，在类外部定义，同时加上inline关键字。注意：此种情况下，内联函数的定义通常应该放在类定义的同一头文件中，而不是在源文件中。这是为了保证内联函数的定义在调用该函数的每个源文件中是可见的。

3.4 访问限制

public，private，protected 为属性/方法限制的关键字。

3.5 类的数据成员中不能使用 auto、extern和register等进行修饰, 也不能在定义时进行初始化

如 int xPos = 0; //错;

例外：
静态常量整型（包括char,bool）数据成员可以直接在类的定义体中进行初始化，例如：

static const int ia= 30;

4 类声明与类定义

4.1 类声明(declare)
class Screen;

在声明之后，定义之前，只知道Screen是一个类名，但不知道包含哪些成员。只能以有限方式使用它，不能定义该类型的对象，只能用于定义指向该类型的指针或引用，声明（不是定义）使用该类型作为形参类型或返回类型的函数。
void Test1(Screen& a){};

void Test1(Screen* a){};

4.2 类定义(define)
在创建类的对象之前，必须完整的定义该类，而不只是声明类。所以，类不能具有自身类型的数据成员，但可以包含指向本类的指针或引用。
class LinkScreen
{

public:
  Screen window;
  LinkScreen* next;
  LinkScreen* prev;
}; //注意，分号不能丢

因为在类定义之后可以接一个对象定义列表，可类比内置类型，定义必须以分号结束：
class LinkScreen{ /* ... */ };

class LinkScreen{ /* ... */ } scr1,scr2;

5 类对象

定义类对象时，将为其分配存储空间。

Sales_item item; //编译器分配了足以容纳一个 Sales_item 对象的存储空间。item 指的就是那个存储空间。

6 隐含的 this 指针

成员函数具有一个附加的隐含形参，即 this指针，它由编译器隐含地定义。成员函数的函数体可以显式使用 this 指针。

6.1 何时使用 this 指针

当我们需要将一个对象作为整体引用而不是引用对象的一个成员时。最常见的情况是在这样的函数中使用 this：该函数返回对调用该函数的对象的引用。

class Screen

{

...
public:
Screen& set(char);
};

Screen& Screen::set(char c)

{
contents[cursor] = c;
return *this;
}

7 类作用域

每个类都定义了自己的作用域和唯一的类型。

类的作用域包括：类的内部（花括号之内）, 定义在类外部的成员函数的参数表(小括号之内)和函数体（花括号之内）。

class Screen

{

//类的内部

...

};

//类的外部

char Screen::get(index r, index c) const
{
index row = r * width; // compute the row location
return contents[row + c]; // offset by c to fetch specified character
}
注意：成员函数的返回类型不一定在类作用域中。可通过类名::来判断是否是类的作用域，::之前不属于类的作用域，::之后属于类的作用域。例如

Screen:: 之前的返回类型就不在类的作用域，Screen:: 之后的函数名开始到函数体都是类的作用域。

class Screen

{

public:

typedef std::string::size_type index;

index get_cursor() const;

};

Screen::index Screen::get_cursor() const //注意：index前面的Screen不能少

{

return cursor;

}

该函数的返回类型是 index，这是在 Screen 类内部定义的一个类型名。在类作用域之外使用，必须用完全限定的类型名 Screen::index 来指定所需要的 index 是在类 Screen 中定义的名字。

二构造函数

构造函数是特殊的成员函数，用来保证每个对象的数据成员具有合适的初始值。
构造函数名字与类名相同，不能指定返回类型（也不能定义返回类型为void），可以有0-n个形参。
在创建类的对象时，编译器就运行一个构造函数。

1 构造函数可以重载

可以为一个类声明的构造函数的数量没有限制，只要每个构造函数的形参表是唯一的。

class Sales_item;

{

public:

Sales_item(const std::string&);

Sales_item(std::istream&);

Sales_item(); //默认构造函数

};

2 构造函数自动执行

只要创建该类型的一个对象，编译器就运行一个构造函数：
Sales_item item1("0-201-54848-8");
Sales_item *p = new Sales_item();
第一种情况下，运行接受一个 string 实参的构造函数，来初始化变量item1。

第二种情况下，动态分配一个新的 Sales_item 对象，通过运行默认构造函数初始化该对象。

3 构造函数初始化式
与其他函数一样，构造函数具有名字、形参表和函数体。

与其他函数不同的是，构造函数可以包含一个构造函数初始化列表：

Sales_item::Sales_item(const string &book): isbn(book), units_sold(0), revenue(0.0)

{ }

构造函数初始化列表以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个数据成员后面跟一个放在圆括号中的初始化式。

构造函数可以定义在类的内部或外部。构造函数初始化只在构造函数的定义中指定。

构造函数分两个阶段执行：(1)初始化阶段；(2)普通的计算阶段。初始化列表属于初始化阶段(1)，构造函数函数体中的所有语句属于计算阶段(2)。
初始化列表比构造函数体先执行。不管成员是否在构造函数初始化列表中显式初始化，类类型的数据成员总是在初始化阶段初始化。

3.1 哪种类需要初始化式

const 对象或引用类型的对象，可以初始化，但不能对它们赋值，而且在开始执行构造函数的函数体之前要完成初始化。

初始化 const 或引用类型数据成员的唯一机会是构造函数初始化列表中，在构造函数函数体中对它们赋值不起作用。
没有默认构造函数的类类型的成员，以及 const 或引用类型的成员，必须在初始化列表中完成初始化。

class ConstRef

{

public:

ConstRef(int ii);

private:

int i;

const int ci;

int &ri;

};

ConstRef::ConstRef(int ii)

{

i = ii; // ok

ci = ii; // error

ri = i; //

}

应该这么初始化：

ConstRef::ConstRef(int ii): i(ii), ci(i), ri(ii) { }

3.2 成员初始化的次序
每个成员在构造函数初始化列表中只能指定一次。重复初始化，编译器一般会有提示。
成员被初始化的次序就是定义成员的次序，跟初始化列表中的顺序无关。
3.3 初始化式表达式

初始化式可以是任意表达式
Sales_item(const std::string &book, int cnt, double price): isbn(book), units_sold(cnt), revenue(cnt * price) { }
3.4 类类型的数据成员的初始化式
初始化类类型的成员时，要指定实参并传递给成员类型的一个构造函数，可以使用该类型的任意构造函数。
Sales_item(): isbn(10, '9'), units_sold(0), revenue(0.0) {}

3.5 类对象的数据成员的初始化
在类A的构造函数初始化列表中没有显式提及的每个成员，使用与初始化变量相同的规则来进行初始化。

类类型的数据成员，运行该类型的默认构造函数来初始化。

内置或复合类型的成员的初始值依赖于该类对象的作用域：在局部作用域中不被初始化，在全局作用域中被初始化为0。假设有一个类A，
class A
{
public:
int ia;
B b;
};
A类对象A a;不管a在局部作用域还是全局作用域，b使用B类的默认构造函数来初始化，ia的初始化取决于a的作用域，a在局部作用域，ia不被初始化，a在全局作用域，ia初始化0。

4 默认构造函数

不含形参的构造函数就是默认构造函数。

只要定义一个对象时没有提供初始化式，就使用默认构造函数。如： A a;
为所有形参提供默认实参的构造函数也定义了默认构造函数。例如：

class A
{
public:

A(int a=1,char c =''){}

private:

int ia;
char c1;
};

4.1 合成的默认构造函数

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

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

建议：

如果定义了其他构造函数，也提供一个默认构造函数。

如果类包含内置或复合类型（如 int& 或 string*）的成员，它应该定义自己的构造函数来初始化这些成员。每个构造函数应该为每个内置或复合类型的成员提供初始化。

5 隐式类类型转换
5.1 只含单个形参的构造函数能够实现从形参类型到该类类型的一个隐式转换

class A

{

public:

A(int a)

{

ia =a;

}

bool EqualTo(const A& a)

{

return ia == a.ia;

}

private:

int ia;

};

A a(1);

bool bEq = false;

bEq = a.EqualTo(1);//参数为1，实现从int型到A的隐式转换

5.2抑制由构造函数定义的隐式转换
通过将构造函数声明为 explicit，来防止在需要隐式转换的上下文中使用构造函数：

class A

{

public:

explicit A(int a )

{

ia =a;

}

bool EqualTo(const A& a)

{

return ia == a.ia;

}

private:

int ia;

};

通常，除非有明显的理由想要定义隐式转换，否则，单形参构造函数应该为 explicit。将构造函数设置为 explicit 可以避免错误。

三复制控制

1 复制构造函数
1.1 几个要点

(1) 复制构造函数

复制构造函数是一种特殊构造函数，只有1个形参，该形参（常用 const &修饰）是对该类类型的引用。

class Peopel

{

public:

Peopel();//默认构造函数

Peopel(const Peopel&);//复制构造函数

~Peopel();//析构函数

};

当定义一个新对象并用一个同类型的对象对它进行初始化时，将显式使用复制构造函数。

Peopel a1; Peopel a2 = a1;

当将该类型的对象传递给函数或函数返回该类型的对象时，将隐式使用复制构造函数。

Peopel Func(Peopel b){...}

(2)析构函数

析构函数是构造函数的互补：当对象超出作用域或动态分配的对象被删除时，将自动应用析构函数。

析构函数可用于释放构造对象时或在对象的生命期中所获取的资源。

不管类是否定义了自己的析构函数，编译器都自动执行类中非 static 数据成员的析构函数。
(3) 复制控制

复制构造函数、赋值操作符和析构函数总称为复制控制。编译器自动实现这些操作，但类也可以定义自己的版本。

(4) 两种初始化形式

C++ 支持两种初始化形式：直接初始化和复制初始化。直接初始化将初始化式放在圆括号中，复制初始化使用 = 符号。
对于内置类型，例如int, double等，直接初始化和复制初始化没有区别。
对于类类型：直接初始化直接调用与实参匹配的构造函数；复制初始化先使用指定构造函数创建一个临时对象，然后用复制构造函数将那个临时对象复制到正在创建的对象。直接初始化比复制初始化更快。
(5)形参和返回值

当形参或返回值为类类型时，由该类的复制构造函数进行复制。

(6)初始化容器元素

复制构造函数可用于初始化顺序容器中的元素。例如：
vector<string> svec(5);
编译器首先使用 string 默认构造函数创建一个临时值，然后使用复制构造函数将临时值复制到 svec 的每个元素。
(7)构造函数与数组元素

如果没有为类类型数组提供元素初始化式，则将用默认构造函数初始化每个元素。
如果使用常规的花括号括住的数组初始化列表来提供显式元素初始化式，则使用复制初始化来初始化每个元素。根据指定值创建适当类型的元素，然后用复制构造函数将该值复制到相应元素：
Sales_item primer_eds[] = { string("0-201-16487-6"),
                                 string("0-201-54848-8"),
                                 string("0-201-82470-1"),
                                 Sales_item()
                               };

1.2 合成的复制构造函数

(1)合成的复制构造函数
如果没有定义复制构造函数，编译器就会为我们合成一个。
合成复制构造函数的行为是，执行逐个成员初始化，将新对象初始化为原对象的副本。
逐个成员初始化：合成复制构造函数直接复制内置类型成员的值，类类型成员使用该类的复制构造函数进行复制。
例外：如果一个类具有数组成员，则合成复制构造函数将复制数组。复制数组时合成复制构造函数将复制数组的每一个元素。

1.3 定义自己的复制构造函数

(1) 只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义复制构造函数，也可以复制。

class Peopel

{

public:

std::string name;

unsigned int id;

unsigned int age;

std::string address;

};

(2) 有些类必须对复制对象时发生的事情加以控制。

例如，类有一个数据成员是指针，或者有成员表示在构造函数中分配的其他资源。而另一些类在创建新对象时必须做一些特定工作。这两种情况下，都必须定义自己的复制构造函数。
最好显式或隐式定义默认构造函数和复制构造函数。如果定义了复制构造函数，必须定义默认构造函数。

1.4 禁止复制
有些类需要完全禁止复制。例如，iostream 类就不允许复制。延伸：容器内元素不能为iostream
为了防止复制，类必须显式声明其复制构造函数为 private。

2 赋值操作符
与复制构造函数一样，如果类没有定义自己的赋值操作符，则编译器会合成一个。

(1)重载赋值操作符

Sales_item& operator=(const Sales_item &);
(2)合成赋值操作符

合成赋值操作符会逐个成员赋值：右操作数对象的每个成员赋值给左操作数对象的对应成员。除数组之外，每个成员用所属类型的常规方式进行赋值。对于数组，给每个数组元素赋值。

(3)复制和赋值常一起使用
一般而言，如果类需要复制构造函数，它也会需要赋值操作符。

3 析构函数
构造函数的用途之一是自动获取资源；与之相对的是，析构函数的用途之一是回收资源。除此之外，析构函数可以执行任意类设计者希望在该类对象的使用完毕之后执行的操作。
(1) 何时调用析构函数

撤销（销毁）类对象时会自动调用析构函数。
变量（类对象）在超出作用域时应该自动撤销（销毁）。
动态分配的对象(new A)只有在指向该对象的指针被删除时才撤销（销毁）。
撤销（销毁）一个容器（不管是标准库容器还是内置数组）时，也会运行容器中的类类型元素的析构函数（容器中的元素总是从后往前撤销）。

(2)何时编写显式析构函数
如果类需要定义析构函数，则它也需要定义赋值操作符和复制构造函数，这个规则常称为三法则：如果类需要析构函数，则需要所有这三个复制控制成员。
(3)合成析构函数

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

对于每个类类型的成员，合成析构函数调用该成员的析构函数来撤销对象。

合成析构函数并不删除指针成员所指向的对象。所以，如果有指针成员，一定要定义自己的析构函数来删除指针。

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

四友元

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

友元可以出现在类定义的内部的任何地方。
友元不是授予友元关系的那个类的成员，所以它们不受声明出现部分的访问控制影响。

建议：将友元声明成组地放在类定义的开始或结尾。

1 友元类

class Husband

{

public:

friend class Wife;

private:

double money;//钱是老公私有的，别人不能动，但老婆除外

};

class Wife

{

public:

void Consume(Husband& h)

{

h.money -= 10000;//老婆可以花老公的钱

}

};

Husband h;

Wife w;

w.Consume(h);

2 使其他类的成员函数成为友元

class Husband; //1.声明Husband

class Wife //2.定义Wife类

{

public:

void Consume(Husband& h);

};

class Husband //3.定义Husband类

{

public:

friend void Wife::Consume(Husband& h);//声明Consume函数。

private:

double money;//钱是老公私有的，别人不能动，但老婆除外

};

void Wife::Consume(Husband& h) //4.定义Consume函数。

{

h.money -= 10000;//老婆可以花老公的钱

}

注意类和函数的声明和定义的顺序：

(1)声明类Husband

(2)定义类Wife，声明Consume函数

(3)定义类Husband

(4)定义Consume函数。

五 static 类成员

static 成员，有全局对象的作用，但又不破坏封装。

1 static 成员变量

static 数据成员是与类关联的对象，并不与该类的对象相关联。
static 成员遵循正常的公有／私有访问规则。

2 使用 static 成员而不是全局对象有三个优点。
(1) static 成员的名字是在类的作用域中，因此可以避免与其他类的成员或全局对象名字冲突。
(2) 可以实施封装。static 成员可以是私有成员，而全局对象不可以。
(3) 通过阅读程序容易看出 static 成员是与特定类关联的,这种可见性可清晰地显示程序员的意图。

3 static 成员函数
在类的内部声明函数时需要添加static关键字，但是在类外部定义函数时就不需要了。
因为static 成员是类的组成部分但不是任何对象的组成部分，所以有以下几个特点：
1) static 函数没有 this 指针
2) static 成员函数不能被声明为 const （将成员函数声明为 const 就是承诺不会修改该函数所属的对象）

3) static 成员函数也不能被声明为虚函数

4 static 数据成员
static 数据成员可以声明为任意类型，可以是常量、引用、数组、类类型，等等。
static 数据成员必须在类定义体的外部定义（正好一次）,并且应该在定义时进行初始化。

建议：定义在类的源文件中名，即与类的非内联函数的定义同一个文件中。注意，定义时也要带上类类型+"::"
double Account::interestRate = 0.035;

5 特殊的静态常量整型成员
静态常量整型数据成员可以直接在类的定义体中进行初始化，例如：
static const int period = 30;

当然char 可以转换成整形，也是可以的， static const char bkground = '#';

6 其他
（1）static 数据成员的类型可以是该成员所属的类类型。非 static 成员只能是自身类对象的指针或引用
class Screen

{
public:
// ...
private:
static Screen src1; // ok

Screen *src2; // ok

Screen src3; // error

};
（2）非 static 数据成员不能用作默认实参，static 数据成员可用作默认实参

class Screen

{
public:
Screen& clear(char = bkground);
private:
static const char bkground = '#';//static const整形变量可以在类内部初始化。
};

面向对象编程基于三个基本概念：数据抽象、继承和动态绑定。

1 基类和派生类

1.1 定义基类

在基类中，除了构造函数之外，任意非 static 成员函数都可以是虚函数。

基类通常应将派生类需要重定义的任意函数定义为虚函数。

1.2 访问控制

(1)private 成员
• 通过类对象无法访问类的private成员。
• 在派生类中不能访问基类的private成员。
• private 成员只能在当前类的作用域内访问，类的友元也可以访问类的private 成员。例如，在成员函数中可以访问private 成员，在成员函数中还可以通过自己类的对象来访问类的private 成员。类的作用域包括：类定义的{}之内，类定义之外的成员函数的函数体，形参列表等。

class Base

{

public:

void Test1(Base& b)

{

b.iBase = 0;//有没有问题？

}

private:

int iBase;

};

class Derived : public Base

{

public:

void Test2(Base& b)

{

b.iBase = 0;//有没有问题？

}

void Test3(Derived& d)

{

d.iDerived = 0;//有没有问题？

}

private:

int iDerived;

};

(2)protected 成员
• 通过类对象无法访问protected 成员。
• protected 成员可被public派生类（包括派生类的派生类，向下传递）访问，也就是说在派生类中可以使用基类的protected 成员。
• 派生类只能通过派生类对象访问其基类的 protected 成员，派生类无法访问其基类类型对象的 protected 成员。

1.3 派生类

类派生列表指定了一个或多个基类，具有如下形式：
class classname: access-label base-class
这里 access-label 是 public、protected 或 private，base-class 是已定义的类的名字，类派生列表可以指定多个基类。

一旦函数在基类中声明为虚函数，它就一直为虚函数，派生类无法改变该函数为虚函数这一事实。派生类重定义虚函数时，可以使用 virtual 保留字，也可以不使用。

(1)派生类一般会重定义所继承的虚函数。如果派生类没有重定义某个虚函数，则使用基类中定义的版本。

(2)一般情况下，派生类中虚函数的声明必须与基类中的定义方式完全匹配，例外：返回对基类型A的引用（或指针）的虚函数。派生类中的虚函数可以返回类A的派生类的引用（或指针）。

提示：绝对不要重新定义继承而来的non-virtual函数

因为non-virtual函数是静态绑定的。一个子类对象绑定到一个父类指针，另一个子类对象绑定到一个子类指针，通过父类指针调用该函数，调用的是父类的该函数，而不是子类的函数。例如：

class Base

{

public:

void FuncTest()

{

std::cout << "Base" << std::endl;

}

};

class Derived: public Base

{

public:

void FuncTest()

{

std::cout << "Derived" << std::endl;

}

};

Derived d;

Base* pB = &d;

Derived* pD = &d;

d.FuncTest();//输出“Derived”

pB->FuncTest();//输出“Base”

pD->FuncTest();//输出“Derived”

1.4 non-virtual 和 virtual 函数的调用

(1) 将基类类型的引用或指针绑定到派生类对象，如果调用非虚函数，则无论实际对象是什么类型，都执行基类类型所定义的函数。

class Base

{

public:

void FuncTest()
{
std::cout << "Base" << std::endl;
}

};

class Derived: public Base

{

public:

};

Derived d;

Base* pB = &d;

pB->VirtFunc();//输出“Base”

(2)将基类类型的引用或指针绑定到派生类对象，如果调用虚函数，则直到运行时才能确定调用哪个函数，运行的虚函数是引用所绑定的或指针所指向的对象所属类型定义的版本。

class Base

{

public:

virtual void VirtFunc()

{

std::cout << "Base" << std::endl;

}

};

class Derived: public Base

{

public:

void VirtFunc()

{

std::cout << "Derived" << std::endl;

}

};

Derived d;

Base* pB = &d;

Derived* pD = &d;

pB->VirtFunc();//输出“Derived”

pD->VirtFunc();//输出“Derived”

1.5 虚函数与默认实参
虚函数也可以有默认实参。如果一个调用省略了具有默认值的实参，则所用的值由调用该函数的类型定义，与对象的动态类型无关。通过基类的引用或指针调用虚函数时，默认实参为在基类虚函数声明中指定的值，如果通过派生类的指针或引用调用虚函数，则默认实参是在派生类的版本中声明的值。

提示：绝不重新定义继承而来virtual函数的缺省参数值

不要重新定义继承而来的non-virtual函数，但是可以重新定义一个继承而来的virtual函数。

virtual函数是动态绑定，而该函数的缺省参数值却是静态绑定。C++这么做的就是为了提高运行期效率。

如果子类重新定义了继承而来的virtual函数的缺省参数值，那么使用父类指针指向子类对象，然后使用父类指针来调用该函数，所使用的默认参数仍然是从父类继承而来，而非子类重新定义定义的。例如：

class Base

{

public:

virtual void VirtFunc(string sMsg = "Base")

{

cout << sMsg << endl;

}

};

class Derived:public Base

{

public:

void VirtFunc(string sMsg = "Derived")

{

cout << sMsg << endl;

}

};

Derived d;

d.VirtFunc();//输出"Derived"

Base* pD = &d;

pD->VirtFunc();//输出"Base",而不是"Derived"

为了避免出现上面这种情况，必须将子类中继承而来的virtual函数设计的跟父类一样，也就是有同样的缺省参数值。如果父类修改了，子类也必须跟着同样修改。

替换的设计方案是：设计一个 public non-virtual函数（带有默认参数值）来调用private virtual函数（不带默认参数值）。public non-virtual函数在子类中不能重新定义，但是private virtual函数可以在子类中重新定义。

class Base

{

public:

void Func(string sMsg = "Base")

{

VirtFunc(sMsg);

}

private:

virtual void VirtFunc(string sMsg )

{

cout << sMsg << endl;

}

};

class Derived:public Base

{

private:

virtual void VirtFunc(string sMsg)

{

cout << sMsg << endl;

}

};

D d;

d.Func();//输出"Base"

B* pD = &d;

pD->mf();//输出"Base"

1.6 友元关系与继承
友元关系不能继承:
(1)基类的友元对派生类的成员没有特殊访问权限。
(2)友元类的派生类不能访问授予友元关系的类。

1.7 继承与静态成员
如果基类定义 static 成员，则整个继承层次中只有一个这样的成员。无论从基类派生出多少个派生类，每个 static 成员只有一个实例。
static 成员遵循常规访问控制：如果成员在基类中为 private，则派生类不能访问它。

如果可以访问成员，则既可以通过基类访问 static 成员，也可以通过派生类访问 static 成员。一般而言，既可以使用作用域操作符也可以使用点或箭头成员访问操作符。

2 转换和继承

2.1 派生类到基类的转换
(1)指针或引用

派生类型引用到基类类型引用

派生类型指针到基类类型指针。

反之是不行的。
(2)对象

一般可以使用派生类型的对象对基类类型的对象进行初始化或赋值，但没有从派生类型对象到基类类型对象的直接转换，编译器不会自动将派生类型对象转换为基类类型对象。

3 构造函数和复制控制

3.1派生类构造函数
构造函数和复制控制成员不能继承，每个类定义自己的构造函数和复制控制成员。像任何类一样，如果类不定义自己的默认构造函数和复制控制成员，就将使用合成版本。

派生类的合成默认构造函数，除了初始化派生类的数据成员之外，它还初始化派生类对象的基类部分。基类部分由基类的默认构造函数初始化。
派生类构造函数的初始化列表只能初始化派生类的成员，不能直接初始化继承成员。派生类构造函数只能通过将基类包含在构造函数初始化列表中来间接初始化继承成员。

class People

{

public:

People(std::string s1, int i1) : name("s1"),age(i1)

{

}

private:

std::string name;

int age;

};

class Student: public People

{

public:

Student(std::string s1, int i1,std::string s2) : uniName("s2"),People(s1,i1)

{

}

private:

std::string uniName;//学校名称

};

构造函数初始化列表为类的基类和成员提供初始值，它并不指定初始化的执行次序。首先初始化基类，然后根据声明次序初始化派生类的成员。
一个类只能初始化自己的直接基类（通过将基类包含在构造函数初始化列表中来间接初始化基类）。

3.2 复制控制和继承
只包含类类型或内置类型数据成员、不含指针的类一般可以使用合成操作。

具有指针成员的类一般需要定义自己的复制控制来管理这些成员。

(1) 派生类的复制构造函数
如果派生类定义了自己的复制构造函数，该复制构造函数一般应显式使用基类复制构造函数初始化对象的基类部分：
class Base { /* ... */ };
class Derived: public Base
{
public:
Derived(const Derived& d):Base(d) { /*... */ }
};

(2)派生类赋值操作符
赋值操作符通常与复制构造函数类似：如果派生类定义了自己的赋值操作符，则该操作符必须对基类部分进行显式赋值。
//Base::operator=(const Base&)
Derived &Derived::operator=(const Derived &rhs)
{
        if (this != &rhs) //防止给自己赋值
{
            Base::operator=(rhs); // 调用 Base 类的赋值操作符给基类部分赋值
……//为派生类Derived 的成员赋值
        }
        return *this;
}

(3)派生类析构函数

派生类析构函数不负责撤销基类对象的成员。每个析构函数只负责清除自己的成员。
class Derived: public Base
{
public:
~Derived() {/*... */}

};
(4)虚析构函数
如果层次中基类的析构函数为虚函数，则派生类析构函数也将是虚函数，无论派生类显式定义析构函数还是使用合成析构函数，派生类析构函数都是虚函数。
建议：即使析构函数没有工作要做，继承层次的根类也应该定义一个虚析构函数。

在复制控制成员中，只有析构函数应定义为虚函数，构造函数不能定义为虚函数。

建议：为多态基类声明为virtual析构函数

父类指针指向子类对象，delete父类指针时，如果父类含有non-virtual析构函数，则只有继承自父类的部分被销毁，而子类非继承的部分没有被销毁，也就是说子类对象被部分销毁。解决的办法是，将父类的析构函数定义为virtual析构函数。

class Base

{

public:

Base()

{

// std::cout << "Base的构造函数" << std::endl;

}

~Base()

{

std::cout << "Base的析构函数" << std::endl;

}

};

class Derived : public Base

{

public:

Derived()

{

// std::cout << "Derived的构造函数" << std::endl;

}

~Derived()

{

std::cout << "Derived的析构函数" << std::endl;

}

};

Base* pB = new Derived;

delete pB;//显示“Base的析构函数”

如果把Base的析构函数前面添加virtual，则上面结果输出：

Derived的析构函数

Base的析构函数

注意：

任何class只要带有virtual函数，几乎确定应该也有一个virtual析构函数。一般的，基类应该含有virtual析构函数。基类定义了virtual关键字，子类就不用添加该关键字了。
如果class不含有virtual函数，通常表示它并不打算被用作一个基类，所以就不应该将析构函数定义为virtual的。

4 继承情况下的类作用域

4.1 名字冲突与继承
与基类成员同名的派生类成员将屏蔽对基类成员的直接访问。
可以使用作用域操作符访问被屏蔽的基类成员：
struct Derived : Base
{
int get_base_mem() { return Base::mem; }
};
设计派生类时，只要可能，最好避免与基类成员的名字冲突。

4.2 作用域与成员函数
在基类和派生类中使用同一名字的成员函数，其行为与数据成员一样：在派生类作用域中派生类成员将屏蔽基类成员。即使函数原型不同，基类成员也会被屏蔽。

4.3 重载函数
如果派生类重定义了重载成员，则通过派生类型只能访问派生类中重定义的那些成员。
如果派生类想要通过自身类型来使用重载的版本，那么派生类必须重定义所有的重载版本，但这样会繁琐，可以通过给重载成员提供using 声明来达到简化的目的。
using Base::Func;//注意，将所有基类Base中的Func函数在本类中可见。

4.3 名字查找与继承
(1)首先确定进行函数调用的对象、引用或指针的静态类型。
(2)在该类中查找函数，如果找不到，就在直接基类中查找，如此循着类的继承链往上找，直到找到该函数或者查找完最后一个类。如果不能在类或其相关基类中找到该名字，则调用是错误的。
(3)一旦找到了该名字，就进行常规类型检查，查看如果给定找到的定义，该函数调用是否合法。
(4)假定函数调用合法，编译器就生成代码。如果函数是虚函数且通过引用或指针调用，则编译器生成代码以确定根据对象的动态类型运行哪个函数版本，否则，编译器生成代码直接调用函数。

5 纯虚函数
在函数形参表后面写上 = 0 以指定纯虚函数。该函数为后代类型提供了可以覆盖的接口，但是这个类中的版本决不会调用。
含有（或继承）一个或多个纯虚函数的类是抽象基类。除了作为抽象基类的派生类的对象的组成部分，不能创建抽象类型的对象。

0 0