我们今天带来了C++的基础知识大汇总，当然这是精简版的，但是篇幅也不少，应该说该有的也都有了，建议大家收藏慢慢学习，同时希望对大家的C++学习有所帮助。

, [8 D( E7 T1 \2 M: S7 g9 m3 ~

一 、从”hello world“ 入门C++！

C++总览简介

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

C++ 被认为是一种中级语言，它综合了高级语言和低级语言的特点。

C++ 是由 Bjarne Stroustrup 于 1979 年在新泽西州美利山贝尔实验室开始设计开发的。C++ 进一步扩充和完善了 C 语言，最初命名为带类的C，后来在 1983 年更名为 C++。

C++ 是 C 的一个超集，事实上，任何合法的 C 程序都是合法的 C++ 程序。

注意：使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。

面向对象程序设计

c++最大的亮点就是面向对象程序设计理念的运用。包括面向对象开发的四大特性：

•     封装
•     抽象
•     继承
•     多态
  
  

C++的组成部分

标准的 C++ 由三个重要部分组成：
4 |4 K, G; L1 B. o$ A

•     核心语言，提供了所有构件块，包括变量、数据类型和常量，等等。
•     C++ 标准库，提供了大量的函数，用于操作文件、字符串等。
•     标准模板库（STL），提供了大量的方法，用于操作数据结构等。
  
  . N2 q# h! p. M1 g8 r

C++的标准

对一门编程语言来说，遵循统一的标准是必需的。下面的表格列出了c++标准的发展历史。
/ [$ O8 R2 ]1 L. ~) v/ @

. q1 h& u, `1 ]1 C. Y2 U6 A0 X

[td]

发布时间	文档	通称	备注
2015	ISO/IEC TS 19570:2015	-	用于并行计算的扩展
2015	ISO/IEC TS 18822:2015	-	文件系统
2014	ISO/IEC 14882:2014	C++14	第四个C++标准
2011	ISO/IEC TR 24733:2011	-	十进制浮点数扩展
2011	ISO/IEC 14882:2011	C++11	第三个C++标准
2010	ISO/IEC TR 29124:2010	-	数学函数扩展
2007	ISO/IEC TR 19768:2007	C++TR1	C++技术报告：库扩展
2006	ISO/IEC TR 18015:2006	-	C++性能技术报告
2003	ISO/IEC 14882:2003	C++03	第二个C++标准

C++ 程序结构

让我们看一段简单的代码，可以输出单词 Hello World。

1. <font style="background-color:rgb(255, 255, 255)">
   0 k+ P- A% d% Z- q% i' w* [6 K
2. #include <iostream>
   
3. using namespace std;
   
4. // main() 是程序开始执行的地方
   7 E) P2 I4 C3 M  b0 `
5. int main()
   $ i. O- g% b! l8 D, f2 v
6. {
   ( \( Z8 z) X) H' O0 w; _4 y+ e5 `) W
7. cout << "Hello World"; // 输出 Hello World
   
8. return 0;
   
9. }</font>
   

复制代码

让我们一起来研究一下上面的代码结构：

C++ 语言定义了一些头文件，这些头文件包含了程序中必需的或有用的信息。上面这段程序中，包含了头文件 <iostream>。

下一行 using namespace std; 告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念。

下一行 // main() 是程序开始执行的地方 是一个单行注释。单行注释以 // 开头，在行末结束。

下一行 int main() 是主函数，程序从这里开始执行。

下一行 cout << "Hello World"; 会在屏幕上显示消息 "Hello World"。

下一行 return 0; 终止 main( )函数，并向调用进程返回值 0。

( y2 h/ D5 P, P6 y: h5 s* V

C++ 中的分号 & 语句块

在 C++ 中，分号是语句结束符。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。

7 O1 R  J+ y5 C; k) l

例如：下面就一共有两条语句。

1. <font style="background-color:rgb(255, 255, 255)">
   : j2 D- v# m+ Q8 B
2. x = y;
   
3. y = x+1;</font>
   

复制代码

语句块是一组使用大括号括起来的按逻辑连接的语句。例如：

1. <font style="background-color:rgb(255, 255, 255)">
   2 H- x: @9 |3 c$ O$ J
2. {
   
3. cout << "Hello World"; // 输出 Hello World
   
4. return 0;
   % ~  T2 o; p* Y! q: R
5. }</font>
   . F) V8 _6 t1 t( X0 J$ }4 y

复制代码

2 W- p: n& T2 m5 m% q2 L

C++ 关键字

下表列出了 C++ 中的保留字。这些保留字不能作为常量名、变量名或其他标识符名称。

2 O% C' f4 j4 U) m8 `8 A

[td]

asm	else	new	this
auto	enum	operator	throw
bool	explicit	private	true
break	export	protected	try
case	extern	public	typedef
catch	false	register	typeid
char	float	reinterpret_cast	typename
class	for	return	union
const	friend	short	unsigned
const_cast	goto	signed	using
continue	if	sizeof	virtual
default	inline	static	void
delete	int	static_cast	volatile
do	long	struct	wchar_t
double	mutable	switch	while
dynamic_cast	namespace	template	9 T; ~3 W: S0 U- M: ^, \

3 z8 i8 n4 P! K5 I/ S+ t: N

C++ 标识符

C++ 标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9），不允许改变标识符组成规则。

下面列出几个有效的标识符：

1. 
   6 K. y+ i+ L4 p' m
2. test
   
3. _temp

复制代码

8 |3 z4 N+ V( _

二 、 c++基本数据类型及流控制语句详解

C++ 数组

C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。

数组的声明并不是声明一个个单独的变量，比如 number0、number1、...、number99，而是声明一个数组变量，比如 numbers，然后使用 numbers[0]、numbers[1]、...、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。

所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

' y5 ^. E. S" r& z3 Z

声明数组

在 C++ 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：

• type arrayName [ arraySize ];
  

4 ~' w) B; U9 y& \& Q; b  Q

这叫做一维数组。arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C++ 数据类型。例如，要声明一个类型为 double 的包含 10 个元素的数组 balance，声明语句如下：

• double balance[10];
  

现在 balance 是一个可用的数组，可以容纳 10 个类型为 double 的数字。

初始化数组

在 C++ 中，可以逐个初始化数组，也可以使用一个初始化语句，如下所示：

• double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
  ' _2 U" G0 U  l0 @* x0 {1 m- T

2 y' Z$ t8 w9 F# U

大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果：

• double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
  

将创建一个数组，它与前一个实例中所创建的数组是完全相同的。

下面是一个为数组中某个元素赋值的实例：

• balance[4] = 50.0;
  5 R# x8 h& G' [: M# l9 d

: P6 H. P4 X/ r: \, l! d

上述的语句把数组中第五个元素的值赋为 50.0。所有的数组都是以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。以下是上面所讨论的数组的的图形表示：

访问数组元素

数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。例如：

• double salary = balance[9];
  

! `. Z# [9 ~* K& }% X

上面的语句将把数组中第 10 个元素的值赋给 salary 变量。下面的实例使用了上述的三个概念，即，声明数组、数组赋值、访问数组：

1. 
   1 K  D) \" J2 H$ s
2. #include <iostream>
     Y+ Q& {5 X8 [' V8 Q& i3 y
3. using namespace std;
   
4. 
   
5. #include <iomanip>
   
6. using std::setw;
   / i' ~, C7 x, z  G6 k* c# ]
7. 
   2 w* D( }6 @9 Y" \- w8 V. E
8. int main ()
   9 |+ U( N9 |: i' Z, f& R
9. {
   # |4 a/ w. r* d: I- q8 f( z$ v
10.    int n[ 10 ]; // n 是一个包含 10 个整数的数组
    
11. 
      ?! b1 `: {! K% ~! R
12.    // 初始化数组元素         
    
13.    for ( int i = 0; i < 10; i++ )
    
14.    {
    ' u0 Z: o8 w$ G, x1 o. T. W: ~# ~
15.       n[ i ] = i + 100; // 设置元素 i 为 i + 100
    ) l' T- D$ Q. |) G
16.    }
    
17.    cout << "Element" << setw( 13 ) << "Value" << endl;
    7 \6 q6 x# y: W5 c+ r" Q& l8 F
18. 
    - `2 m) B8 I2 J* T: H
19.    // 输出数组中每个元素的值                     
      }+ ^3 Q+ Y& q0 C/ ^
20.    for ( int j = 0; j < 10; j++ )
    
21.    {
    - i' W+ q# i7 L, n" {
22.       cout << setw( 7 )<< j << setw( 13 ) << n[ j ] << endl;
    
23.    }
    
24. 
    
25.    return 0;
    
26. }
    9 E. v1 {+ p& n, Y7 t

复制代码

C++ 字符串

C++ 提供了以下两种类型的字符串表示形式：

• C 风格字符串
• C++ 引入的 string 类类型
  
  

C 风格字符串

C 风格的字符串起源于 C 语言，并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

下面的声明和初始化创建了一个 "Hello" 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 "Hello" 的字符数多一个。

8 q8 d$ D4 M& ^" X* s( E6 I

• char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
  

' j5 t0 V9 h5 K& r  \$ y7 M6 r

依据数组初始化规则，可以把上面的语句写成以下语句：
$ v; W8 M3 S- }

• char greeting[] = "Hello";
  $ N1 l: L+ c" ]/ C# S: E+ f

- Y% `& O4 I9 C: ?" R: i" u# i

以下是 C/C++ 中定义的字符串的内存表示：
; E" j3 M, ]2 \  u* B# L9 D

其实，不需要把 null 字符放在字符串常量的末尾。C++ 编译器会在初始化数组时，自动把 '\0' 放在字符串的末尾。让我们尝试输出上面的字符串：

实例

1. 
   
2. #include <iostream>
   . I/ T5 n) l' s, r4 j
3. using namespace std;
   
4. int main (){
   " S1 z+ o1 l. D8 y" _
5.    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};   
   / p3 b* S9 i5 p/ L' W: g
6.     cout << "Greeting message: ";  
   6 j2 p) b6 `8 q. O$ }0 Y8 c
7.      cout << greeting << endl;  
   % }) `$ E% n; q" h+ J/ T
8.        return 0;
   
9. }
   

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

• Greeting message: Hello
  ) ~3 W/ t+ p* l8 }( ~* \

C++ 中有大量的函数用来操作以 null 结尾的字符串：supports a wide range of functions that manipulate null-terminated strings:

[td]

序号	函数 & 目的
1	strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
2	strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。
3	strlen(s1); 返回字符串 s1 的长度。
4	strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。
5	strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

下面的实例使用了上述的一些函数：

实例

1. 
   6 U( F# D- a1 w7 |
2. #include <iostream>
   
3. #include <cstring>
   
4. 
   ( j2 W1 v4 y& z' F
5. using namespace std;
   4 O; l5 F- D$ ^' m) w0 @6 a" \
6. 
   * L; v6 I% O+ \# i
7. int main ()
   - y' W. f5 l' m+ f! f
8. {
   
9.    char str1[11] = "Hello";
   
10.    char str2[11] = "World";
    0 ?% `! k7 s# {; P0 ^- B) U' a2 [
11.    char str3[11];
    : W! b' e8 A; F3 @
12.    int  len ;
    
13. 
    
14.    // 复制 str1 到 str3
    ) h/ g/ g7 n9 b- a
15.    strcpy( str3, str1);
    
16.    cout << "strcpy( str3, str1) : " << str3 << endl;
    6 i/ R2 p) a3 t, f) Q6 J
17. 
    
18.    // 连接 str1 和 str2
    - J0 t( c, @! q1 |* v
19.    strcat( str1, str2);
    $ `& Y2 X/ j& l3 u/ G
20.    cout << "strcat( str1, str2): " << str1 << endl;
    
21. 
    * E% k8 L8 {6 K5 A- l
22.    // 连接后，str1 的总长度
    
23.    len = strlen(str1);
    / C- e0 f  |( ~' ?7 R/ p
24.    cout << "strlen(str1) : " << len << endl;
    
25. 
    
26.    return 0;
    
27. }
    : Q& k, U4 j* u$ Y5 a4 Q3 L: r8 L# m

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

• strcpy( str3, str1) : Hellostrcat( str1, str2): HelloWorldstrlen(str1) : 10C++ 中的 String 类
  1 B! M6 k; t+ p- g+ G* y2 W4 j

4 ^- k  t8 F% B8 {7 i0 v% r

C++ 中的 string 类

C++ 标准库提供了 string 类类型，支持上述所有的操作，另外还增加了其他更多的功能。现在让我们先来看看下面这个实例：

实例

1. 
   
2. #include <iostream>
   4 f) J5 {7 p3 F% e1 t
3. #include <string>
   : t2 q5 y3 A$ L/ p
4. 
   . V' e8 @# `$ l) @" L; k
5. using namespace std;
   ) K- K1 M8 T8 e9 _/ y7 i, C
6. 
   ; d$ ]; B; X/ N3 m
7. int main ()
   6 y9 U+ r4 E( N& Y1 k! J
8. {
   
9.    string str1 = "Hello";
   3 u) I) n% K8 l: K
10.    string str2 = "World";
    
11.    string str3;
    
12.    int  len ;
    
13. 
    
14.    // 复制 str1 到 str3
    3 Y. H$ {9 Z, }9 t: B9 K" o
15.    str3 = str1;
    
16.    cout << "str3 : " << str3 << endl;
    7 i+ C/ C/ D- y6 z
17. 
    
18.    // 连接 str1 和 str2
    % Z3 w! R' H  f8 d( m
19.    str3 = str1 + str2;
    
20.    cout << "str1 + str2 : " << str3 << endl;
    
21. 
    
22.    // 连接后，str3 的总长度
    " \, y4 [- f$ g  E6 X, i! K
23.    len = str3.size();
    
24.    cout << "str3.size() :  " << len << endl;
    
25. 
    
26.    return 0;
    , ~; d" b' e4 H6 u+ C5 p
27. }
    

复制代码

# i' }/ ?0 k3 l- h7 ^- y0 f5 a

当上面的代码被编译和执行时，它会产生下列结果：

) Q) k1 D: V; Y' |+ L7 D

1. 
   ! T. ?# ~0 |2 |7 v( u$ |
2. str3 : Hello
   + o: G9 U* Z4 F" H- m8 D& Z2 R
3. str1 + str2 : HelloWorld
   
4. str3.size() : 10
   

复制代码

C++ 循环

有的时候，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。

编程语言提供了允许更为复杂的执行路径的多种控制结构。

循环语句允许我们多次执行一个语句或语句组，下面是大多数编程语言中循环语句的一般形式：

循环类型

C++ 编程语言提供了以下几种循环类型。

循环类型	描述
while 循环	当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
for 循环	多次执行一个语句序列，简化管理循环变量的代码。
do...while 循环	除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
嵌套循环	可以在 while、for 或 do..while 循环内使用一个或多个循环。

循环控制语句

循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁。

C++ 提供了下列的控制语句。

控制语句	描述
break 语句	终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
continue 语句	引起循环跳过主体的剩余部分，立即重新开始测试条件。
goto 语句	将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。

无限循环

如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，可以将某些条件表达式留空来构成一个无限循环。

实例

1. 
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. int main ()
   
6. {
   . P3 M1 a8 G: {
7. 
   3 |+ P  `1 {4 m; x/ Y% P
8.    for( ; ; )
   
9.    {
   
10.       printf("This loop will run forever.\n");
    
11.    }
    * f$ v2 c0 |" `( z
12. 
    # ]. r% X7 N# @9 X4 R
13.    return 0;
    2 u! N' k! \7 i* v
14. }
    7 c- L4 Q( O& X. J# Y& m0 p  k- T& u

复制代码

当条件表达式不存在时，它被假设为真。也可以设置一个初始值和增量表达式，但是一般情况下，C++ 程序员偏向于使用 for(;;) 结构来表示一个无限循环。

注意：可以按 Ctrl + C 键终止一个无限循环。

3 v) Q9 l+ M* e* @* m8 z; H

C++ 判断

判断结构要求程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假时要执行的语句（可选的）。

下面是大多数编程语言中典型的判断结构的一般形式：

判断语句

C++ 编程语言提供了以下类型的判断语句。

[td]

语句	描述
if 语句	一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
if...else 语句	一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句	可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch 语句	一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语句	可以在一个 switch 语句内使用另一个 switch 语句。

* O" W, F, ?7 N

三 、 c++进阶 基本输入输出、指针、引用

C++ 基本的输入输出

今天我们来熟悉一下C++ 编程中最基本和最常见的 I/O 操作。

C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。

I/O 库头文件

下列的头文件在 C++ 编程中很重要。

[td]

头文件	函数和描述
<iostream>	该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。
<iomanip>	该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I/O 有用的服务。
<fstream>	该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。

1 H- c1 l# V% B

标准输出流（cout）

预定义的对象 cout 是 iostream 类的一个实例。cout 对象"连接"到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的，如下所示：

实例

1. 
   6 a* c0 o1 q& ^# h* a! A, D% P
2. #include <iostream>
   
3. 
   
4. using namespace std;
   
5. 
   
6. int main( )
   
7. {
   
8.    char str[] = "Hello C++";
   
9. 
   4 N; L$ A" d- ]3 O5 l% Y
10.    cout << "Value of str is : " << str << endl;
    
11. }

复制代码

* J/ D" t" J9 p2 W, x

当上面的代码被编译和执行时，它会产生下列结果：

• Value of str is : Hello C++
  / p, H/ f3 r  G# v! r7 ]5 {  M5 v' O

C++ 编译器根据要输出变量的数据类型，选择合适的流插入运算符来显示值。<< 运算符被重载来输出内置类型（整型、浮点型、double 型、字符串和指针）的数据项。

流插入运算符 << 在一个语句中可以多次使用，如上面实例中所示，endl 用于在行末添加一个换行符。

标准输入流（cin）

预定义的对象 cin 是 iostream 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。cin 是与流提取运算符 >> 结合使用的，如下所示：

实例

1. 
   
2. #include <iostream>
   , R% C& t4 _1 f6 |
3. 
   
4. using namespace std;
   8 R" }  W/ {0 S5 t
5. 
   3 V0 z( u9 B, X8 y8 L
6. int main( )
   
7. {
   . D9 |% b, E, Q$ M' @; e( }5 T& s
8.    char name[50];
   
9. 
   
10.    cout << "请输入您的名称：";
    
11.    cin >> name;
    , H' L( A; L) V, n. D5 c
12.    cout << "您的名称是：" << name << endl;
    
13. 
    
14. }

复制代码

当上面的代码被编译和执行时，它会提示用户输入名称。当用户输入一个值，并按回车键，就会看到下列结果：

1. 
   
2. 请输入您的名称：cplusplus
   
3. 您的名称是：cplusplus

复制代码

C++ 编译器根据要输入值的数据类型，选择合适的流提取运算符来提取值，并把它存储在给定的变量中。

流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句：

• cin >> name >> age;
  : K$ @; g: g" D2 q& t8 J. P

这相当于下面两个语句：

1. 
   
2. cin >> name;
   
3. cin >> age;
   

复制代码

标准错误流（cerr）

预定义的对象 cerr 是 iostream 类的一个实例。cerr 对象附属到标准错误设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。

cerr 也是与流插入运算符 << 结合使用的，如下所示：

实例

1. 
   
2. #include <iostream>
   
3. 
   
4. using namespace std;
   % C. S/ X! u, Q
5. 
     G  |4 @, V9 ?; @! n
6. int main( )
   8 ^8 X9 Q1 e8 ~& Y
7. {
   
8.    char str[] = "Unable to read....";
   ' n' Y- I$ A, E8 i+ x
9. 
   $ m% S  W, B* u! j( }+ c
10.    cerr << "Error message : " << str << endl;
    5 Z- X% |, M" [+ t
11. }

复制代码

* f" K+ u; V3 c2 r, C- \" x/ W

当上面的代码被编译和执行时，它会产生下列结果：

• Error message : Unable to read....
  3 F7 g, A/ r% a

( ^/ t) Y% |' F, ^4 W* x

标准日志流（clog）

预定义的对象 clog 是 iostream 类的一个实例。clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲在，直到缓冲填满或者缓冲区刷新时才会输出。
+ z$ E0 [; _) {! E0 i: Z6 ^# Z9 H

clog 也是与流插入运算符 << 结合使用的，如下所示：

实例

1. 
   
2. #include <iostream>
   . {/ H; y. B& G/ J6 H( m
3. 
   0 a* C5 u/ X- a5 S+ R% Y' [8 T
4. using namespace std;
   
5. 
   
6. int main( )
   
7. {
   
8.    char str[] = "Unable to read....";
   8 m0 ~7 r8 G& b0 ?
9. 
   : a, E& n* V* H( _5 |6 q2 t& \
10.    clog << "Error message : " << str << endl;
    
11. }

复制代码

" p& D4 l  H( u/ N, o

当上面的代码被编译和执行时，它会产生下列结果：

• Error message : Unable to read....
  ; ^% `1 Q4 M; b" Q7 y' G3 z

通过这些小实例，我们无法区分 cout、cerr 和 clog 的差异，但在编写和执行大型程序时，它们之间的差异就变得非常明显。所以良好的编程实践告诉我们，使用 cerr 流来显示错误消息，而其他的日志消息则使用 clog 流来输出。

C++ 指针

学习 C++ 的指针既简单又有趣。通过指针，可以简化一些 C++ 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。所以，想要成为一名优秀的 C++ 程序员，学习指针是很有必要的。

每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。请看下面的实例，它将输出定义的变量地址：

实例

1. 
   . ~* ?* Z, K: [: F# }
2. #include <iostream>
   $ }' D9 `, l) Y: k+ C: X0 ~# V6 \
3. 
   
4. using namespace std;
   , J3 w3 I# d& H
5. 
   
6. int main ()
   
7. {
   ! n% p( l, h* z/ M
8.    int  var1;
   / ]* c% i. m" x/ h
9.    char var2[10];
   ! P9 j5 X. c1 o6 P! d# l) |
10. 
    
11.    cout << "var1 变量的地址：";
    
12.    cout << &var1 << endl;
    3 V" S8 V# i2 ~7 N
13. 
    3 q( P! z( L  _6 A
14.    cout << "var2 变量的地址：";
    
15.    cout << &var2 << endl;
    
16. 
    8 P7 X6 R6 o) K) P1 M
17.    return 0;
    
18. }

复制代码

2 f& o  |' ~; ?# V! x0 U0 w

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   
2. var1 变量的地址：0xbfebd5c0
   
3. var2 变量的地址：0xbfebd5b6

复制代码

通过上面的实例，我们了解了什么是内存地址以及如何访问它。接下来让我们看看什么是指针。

) l% T' S8 Z: ]1 }' o" W8 O% v* X5 }

什么是指针？

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：

• type *var-name;
  

在这里，type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

1. 
   " t+ G4 d; L8 ?7 R" h
2. int *ip; /* 一个整型的指针 */
   
3. double *dp; /* 一个 double 型的指针 */
   9 c  o9 _5 c/ v; W4 c
4. float *fp; /* 一个浮点型的指针 */
   
5. char *ch; /* 一个字符型的指针 */
   & `$ r3 j& G+ Q' o2 L! ]3 W& i

复制代码

所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

C++ 中使用指针

使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 *来返回位于操作数所指定地址的变量的值。下面的实例涉及到了这些操作：

实例

1. 
   ) j6 _4 o/ O$ x9 X8 b+ b0 [
2. #include <iostream>
   - ]- ^2 G7 y; ~- K: U3 _$ |
3. 
   
4. using namespace std;
   
5. 
   0 H; v6 q3 S! l$ T- Q6 s) u
6. int main ()
   
7. {
   
8.    int  var = 20;   // 实际变量的声明
   
9.    int  *ip;        // 指针变量的声明
   
10. 
    1 ^$ [$ Z, T/ ~; f' r+ a6 i
11.    ip = &var;       // 在指针变量中存储 var 的地址
    ( v7 {4 X: o& E
12. 
    - e- f& B4 J2 E4 D) X( J+ {$ ^
13.    cout << "Value of var variable: ";
    * O) w4 ~( }5 H( M# t3 ]! O
14.    cout << var << endl;
    
15. 
    4 E- D( x# W+ Z2 z
16.    // 输出在指针变量中存储的地址
    
17.    cout << "Address stored in ip variable: ";
    
18.    cout << ip << endl;
    
19. 
    " D5 x; U9 @: K! E5 ~* j
20.    // 访问指针中地址的值
    
21.    cout << "Value of *ip variable: ";
    
22.    cout << *ip << endl;
    
23. 
    8 _2 r/ v. e* Y5 K' j. p7 B: I: N
24.    return 0;
    8 z6 H; h! E. ~$ s
25. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. Value of var variable: 20
   
3. Address stored in ip variable: 0xbfc601ac
   
4. Value of *ip variable: 20</font></font></font>
   

复制代码

% {$ {  h: ^& p

C++ 引用

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

( N; D( X9 L3 n, D3 t# s3 j

C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：

• 不存在空引用。引用必须连接到一块合法的内存。
• 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
• 引用必须在创建时被初始化。指针可以在任何时间被初始化。
  
  9 m  W6 W# V6 |# T2 H4 b

! I" x, M' j8 V5 {, C& }; c

C++ 中创建引用

试想变量名称是变量附属在内存位置中的标签，可以把引用当成是变量附属在内存位置中的第二个标签。因此，可以通过原始变量名称或引用来访问变量的内容。例如：

• int i = 17;
  6 F- j+ L+ t* I: h& Z1 x* a4 `

我们可以为 i 声明引用变量，如下所示：

1. 
   ( v$ v- t/ {- @; K3 y; a( o" \0 {0 u
2. int& r = i;
   ( n* v: a4 R0 J% O6 p9 ?/ C
3. double& s = d;

复制代码

: j8 A8 z. X, {# O' p# J3 D- l4 q

在这些声明中，& 读作引用。因此，第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。下面的实例使用了 int 和 double 引用：

实例

1. 
   
2. #include <iostream>
   * l& A( Y" s% H8 V. D4 n$ D+ h
3. 
   4 z* M8 _" k+ j/ a: l
4. using namespace std;
   
5. 
   # k+ Q' @3 R- ^+ }
6. int main ()
   
7. {
   9 A: Q4 S: ~, ], q3 s
8.    // 声明简单的变量
   
9.    int    i;
   , g0 G6 [9 S0 O
10.    double d;
    
11. 
    
12.    // 声明引用变量
    $ }' T8 e/ `+ {3 K  q3 z
13.    int&    r = i;
    ) h. }6 F! m" ^9 m& N
14.    double& s = d;
    7 f# q: H' |7 Y; x1 R( L
15.    
    # |3 {' b% j8 ?
16.    i = 5;
    6 J6 b' B% t+ |2 ]) a4 N$ a/ |
17.    cout << "Value of i : " << i << endl;
    
18.    cout << "Value of i reference : " << r  << endl;
    ; s/ E  a, t8 Q7 K% w5 R2 [
19. 
    
20.    d = 11.7;
    3 Q* Q' P- W/ a. c& k
21.    cout << "Value of d : " << d << endl;
    
22.    cout << "Value of d reference : " << s  << endl;
    
23.    
    
24.    return 0;
    
25. }

复制代码

) F- r; C+ E, P+ }* _7 z

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   : U  w- G6 Y: o
2. Value of i : 5
   
3. Value of i reference : 5
   5 [! g5 R3 M# _0 `
4. Value of d : 11.7
   
5. Value of d reference : 11.7

复制代码

0 O+ q- E$ e0 l

引用通常用于函数参数列表和函数返回值。下面列出了 C++ 程序员必须清楚的两个与 C++ 引用相关的重要概念：

[td]

概念	描述
把引用作为参数	C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。
把引用作为返回值	可以从 C++ 函数中返回引用，就像返回其他数据类型一样。

7 E% c4 w0 ?1 n

四、 C++ 类与对象初探：继承和重载

C++ 类 & 对象

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。

C++ 类定义

定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如，我们使用关键字 class 定义 Box 数据类型，如下所示：

1. 
   
2. class Box
   & E3 G8 I8 l  i% v0 a/ s' }8 f' Q. O
3. {
   
4.    public:
   * c% s* S9 D( I/ J8 H
5.       double length;   // 盒子的长度
   
6.       double breadth;  // 盒子的宽度
   - Y8 u% b2 K: M# b8 ?- V" L
7.       double height;   // 盒子的高度
   
8. };

复制代码

关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。也可以指定类的成员为 private 或 protected。

% Z8 _/ x" Z! e( H$ o

定义 C++ 对象

类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. Box Box1; // 声明 Box1，类型为 Box Box Box2; // 声明 Box2，类型为 Box
   
3. 对象 Box1 和 Box2 都有它们各自的数据成员。</font></font></font>
   

复制代码

访问数据成员

类的对象的公共数据成员可以使用直接成员访问运算符 (.) 来访问。为了更好地理解这些概念，让我们尝试一下下面的实例：

实例

1. 
   4 |' \% G* G; y/ J/ P1 y5 z1 c
2. #include <iostream>
   " c1 C- y) W  k! {
3. 
   1 e% l- T3 n* Y
4. using namespace std;
   ( W& B' c$ s$ V- _
5. 
   
6. class Box
   1 J5 @2 N+ v5 Z! ~1 b; Y! B* K5 |0 H5 w
7. {
   
8.    public:
   
9.       double length;   // 长度
   2 O- }  v% ]/ s/ N
10.       double breadth;  // 宽度
    - o, m# ]4 U* u9 U4 |+ J" C
11.       double height;   // 高度
      p% I) p9 F; [7 j8 _- s
12. };
    5 D9 H$ u6 N. [
13. 
    7 V; q1 }7 Z7 |# ?, q( w5 ?
14. int main( )
    ' R  M+ j, l0 f, I$ X% b5 f+ {$ j2 w
15. {
    
16.    Box Box1;        // 声明 Box1，类型为 Box
    ; }+ Y8 S# m9 W/ T3 F. J
17.    Box Box2;        // 声明 Box2，类型为 Box
    9 E0 D* H$ v5 u
18.    double volume = 0.0;     // 用于存储体积
    
19. 
    
20.    // box 1 详述
    
21.    Box1.height = 5.0;
      Q. J  H$ u) C+ Z) W
22.    Box1.length = 6.0;
      D2 p- `! B+ E. m) o. z4 y
23.    Box1.breadth = 7.0;
    , @2 l( G& |" w3 s' N: [0 o
24. 
    
25.    // box 2 详述
    
26.    Box2.height = 10.0;
    
27.    Box2.length = 12.0;
    : F( E: z- B5 J# E9 t2 b
28.    Box2.breadth = 13.0;
    
29. 
    ( i7 _8 Y9 Y- m. F2 r# ]# K
30.    // box 1 的体积
    . `0 k  p# s6 c+ M: u: r
31.    volume = Box1.height * Box1.length * Box1.breadth;
    : ^2 a1 I: J/ _' p3 Y" [' y
32.    cout << "Box1 的体积：" << volume <<endl;
    : P+ c% R! C3 m
33. 
    
34.    // box 2 的体积
    
35.    volume = Box2.height * Box2.length * Box2.breadth;
    
36.    cout << "Box2 的体积：" << volume <<endl;
    
37.    return 0;
    
38. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   
2. Box1 的体积：210
     H4 C: g* M5 A$ e/ z7 u( z- J
3. Box2 的体积：1560

复制代码

需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。

8 r+ Q1 K! F- D# D! m; ~) ~

C++ 继承

9 s( O/ U: Q# D2 n7 J1 F

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。

继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

• class derived-class: access-specifier base-class
  

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

假设有一个基类 Shape，Rectangle 是它的派生类，如下所示：

实例

1. 
   ; e7 d2 q5 V) {) h
2. #include <iostream>
   . v' g' b0 P) x5 _. X
3. 
   0 M) C( {# p6 l+ ^: [( a$ |2 k* E
4. using namespace std;
   
5. 
   
6. // 基类
   7 o# R7 \: y$ w7 @
7. class Shape
   
8. {
   
9.    public:
   
10.       void setWidth(int w)
    
11. {
    % L0 P% z3 `1 Q8 A% @  }
12.          width = w;
    
13.       }
    
14.       void setHeight(int h)
    
15. {
    ' C! C; ~6 X* P7 p0 d
16.          height = h;
    
17.       }
    
18.    protected:
    + m2 m5 D5 v. H# ]& n, I) b' F4 D
19.       int width;
    
20.       int height;
    & V  W% R0 c1 _" P( {4 p
21. };
    . c1 D% v1 m2 N& P* ~3 s
22. 
    % j2 v6 `; c" X7 {4 _' w
23. // 派生类
    
24. class Rectangle: public Shape
    $ `# @5 _! O' c" K- }
25. {
    9 E+ P. c. k; A+ y; Z' A! _
26.    public:
    & K# I9 E( w& |* [$ L  E
27.       int getArea()
    
28. {
    & ?! U( j1 w& O$ d
29.          return (width * height);
    
30.       }
    - |9 o5 i! B# R  l
31. };
    
32. 
    / r* I# g4 e1 q8 ~" W% I! l$ \
33. int main(void)
    8 a' j" d+ e2 l1 u  {6 S3 t" f
34. {
    
35.    Rectangle Rect;
    ) p+ X7 I4 O/ ?1 s) n7 D6 v
36. 
    
37.    Rect.setWidth(5);
    " }  X1 |5 f& e; E$ A- B
38.    Rect.setHeight(7);
    
39. 
    
40.    // 输出对象的面积
    
41.    cout << "Total area: " << Rect.getArea() << endl;
    
42. 
    9 ]* p' [. G$ f' g5 F4 Q0 M
43.    return 0;
    9 S, ^" ^4 ^) l" [- Q
44. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

• Total area: 35
  

访问控制和继承

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

我们可以根据访问权限总结出不同的访问类型，如下所示：

[td]

访问	public	protected	private
同一个类	yes	yes	yes
派生类	yes	yes	no
外部的类	yes	no	no

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

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

+ U# e3 R" |! z7 p

继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

• 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）：当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
  
  $ A1 X* l$ D' r2 l7 T+ Q- W% T! ^

3 V+ w0 _+ h2 @( B9 Z0 ^7 p+ J

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

1. 
   
2. class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
   
3. {
   
4. <派生类类体>
   7 a7 I, K/ Z! M. N6 L
5. };

复制代码

& Y  w: _5 z  s! X0 P3 ^

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。现在让我们一起看看下面的实例：

实例

1. 
   8 w7 y( T2 }& _
2. #include <iostream>
   
3. 
   
4. using namespace std;
   0 S* |( K9 c& M7 ?: F
5. 
   4 x/ L8 g% j& h6 L  a; ]
6. // 基类 Shape
   
7. class Shape
   
8. {
   
9.    public:
   : }- g3 T9 J& ?) V1 |
10.       void setWidth(int w)
    + D3 I( T) V/ z6 {
11. {
    " `  B' `; V0 v3 M% L. |
12.          width = w;
    / h+ t% b6 m5 ]( Z
13.       }
    ! u. B1 m+ \2 h  k/ w/ |
14.       void setHeight(int h)
    5 K, G9 ]& g+ n7 u2 Z
15. {
    
16.          height = h;
    
17.       }
    : p8 S3 B6 T4 v1 m( E
18.    protected:
    
19.       int width;
    
20.       int height;
    
21. };
    
22. 
    
23. // 基类 PaintCost
    ( {- p  s6 N2 r% t/ h6 P
24. class PaintCost
    
25. {
    
26.    public:
    8 n$ C2 k/ u) e" ~3 C3 P
27.       int getCost(int area)
    
28. {
    9 ?" A( q/ P2 `5 y( ^2 |) p
29.          return area * 70;
    
30.       }
    4 V& ^& w8 g1 E% I( `$ p- ^7 q
31. };
    
32. 
    1 N" ]( C6 k2 U) j6 Q
33. // 派生类
    
34. class Rectangle: public Shape, public PaintCost
    , J0 H5 P2 A* y
35. {
    ; u3 w. Q/ c, O: [2 z
36.    public:
    , x1 P( {9 t+ R# @; N7 ?! [7 P
37.       int getArea()
    
38. {
    
39.          return (width * height);
    
40.       }
    
41. };
    
42. 
    
43. int main(void)
    % k, x9 n  `6 s
44. {
    
45.    Rectangle Rect;
    
46.    int area;
    $ V! ~, h2 ?! |; \
47. 
    
48.    Rect.setWidth(5);
    : q+ t; e- c7 h# A: q
49.    Rect.setHeight(7);
    
50. 
    1 \& @8 A# F6 \% J! Z8 u" g3 z
51.    area = Rect.getArea();
    
52.    
    
53.    // 输出对象的面积
    
54.    cout << "Total area: " << Rect.getArea() << endl;
    
55. 
    5 M% M* u: l: k5 N) ^& V) c" z3 G
56.    // 输出总花费
    
57.    cout << "Total paint cost: $" << Rect.getCost(area) << endl;
    0 q) h" p' N/ {! `5 |- Q) D) ~
58. 
    
59.    return 0;
    ( U. }9 A: c! S$ J
60. }

复制代码

3 Q4 f! X2 T( z: D$ }

当上面的代码被编译和执行时，它会产生下列结果：

1. 
     x- l6 i% X9 P$ q# ?0 o
2. Total area: 35
   
3. Total paint cost: $2450

复制代码

& y, N8 Z: t* p- z0 s( e  C

C++ 重载运算符和重载函数

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

7 e) M# D8 U$ L# G# k6 G) x

C++ 中的函数重载

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。

下面的实例中，同名函数 print() 被用于输出不同的数据类型：

实例

1. 
   1 i8 O. u/ C: L) p7 w& {
2. #include <iostream>
   ) q) G& }& c  B0 ?2 d
3. using namespace std;
   
4. 
   
5. class printData
   
6. {
   
7.    public:
   
8.       void print(int i) {
   
9.         cout << "整数为: " << i << endl;
   
10.       }
    
11. 
    
12.       void print(double  f) {
    
13.         cout << "浮点数为: " << f << endl;
    
14.       }
    
15. 
    
16.       void print(char c[]) {
    
17.         cout << "字符串为: " << c << endl;
    # m. n- v: ^; W
18.       }
    
19. };
    2 t, w; g5 Y) M$ C0 \9 ~! _
20. 
    
21. int main(void)
    8 O& V3 j- O! p5 [% Z- @% d7 ^
22. {
    ; ]+ A  |; O" A: W# K# h8 i
23.    printData pd;
    
24. 
    % {" }  r2 y5 j% {4 u8 H- O
25.    // 输出整数
    
26.    pd.print(5);
    
27.    // 输出浮点数
    
28.    pd.print(500.263);
    
29.    // 输出字符串
    9 T9 J% G( r- R
30.    char c[] = "Hello C++";
    
31.    pd.print(c);
    9 b* T- s9 r. x8 N
32. 
    ) j$ F7 T" [! W  S9 t
33.    return 0;
    9 }  L% e! G2 M! o( h1 {  _
34. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   
2. 整数为: 5
   7 B9 w! }5 H  `% a7 F
3. 浮点数为: 500.263
   
4. 字符串为: Hello C++

复制代码

* K, P7 g6 a" F  b6 x0 y2 _

C++ 中的运算符重载

您可以重定义或重载大部分 C++ 内置的运算符。这样，您就能使用自定义类型的运算符。

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

• Box operator+(const Box&);
  

声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，如下所示：

• Box operator+(const Box&, const Box&);
  + ^* t2 G& V4 ]

下面的实例使用成员函数演示了运算符重载的概念。在这里，对象作为参数进行传递，对象的属性使用 this 运算符进行访问，如下所示：

实例

1. 
   
2. #include <iostream>
   4 r. x$ J$ J0 f# u2 B0 @
3. using namespace std;
   % t8 Z" m8 _+ F2 s
4. 
   
5. class Box
   ) A$ S& l  S' j6 O" ^) w; s9 v1 o
6. {
   4 m4 ?! Q  Y+ o7 `
7.    public:
   ) n% A4 P6 x$ }+ ?3 x- W/ s
8. 
   3 ]0 _, K0 d/ n& {9 G
9.       double getVolume(void)
   7 c7 e) o3 _* A
10. {
    
11.          return length * breadth * height;
    * b' S4 n- Z5 X9 U7 e
12.       }
    + n& \9 g7 o* J8 i9 @, r$ Y
13.       void setLength( double len )
    
14. {
    $ }  w3 G, x- I$ F& |/ T
15.           length = len;
    % [% h8 o$ ^% [7 @3 v! u2 U
16.       }
    
17. 
    
18.       void setBreadth( double bre )
    1 T( j! {+ F. f5 s% c& V4 s/ ^
19. {
    
20.           breadth = bre;
    
21.       }
    $ X0 t% r2 c* Q! i
22. 
    4 @( b7 Y7 k3 T" b& l% ~9 d1 x( [
23.       void setHeight( double hei )
    
24. {
    - r2 `! E' N+ ^% D" l, k
25.           height = hei;
    
26.       }
    - M6 G9 l* S: E- \+ l$ N
27.       // 重载 + 运算符，用于把两个 Box 对象相加
    : w- e7 ]% k7 w% x+ a) L
28.       Box operator+(const Box& b)
    # w& K6 H; @) T. J# p( U7 h$ g  p# K# ^
29.       {
    
30.          Box box;
    
31.          box.length = this->length + b.length;
    
32.          box.breadth = this->breadth + b.breadth;
    
33.          box.height = this->height + b.height;
    
34.          return box;
    + O) p2 }2 I! m1 y: ^- W
35.       }
    ) u3 P: P* ?4 b8 m: b
36.    private:
    
37.       double length;      // 长度
    % B1 x: E6 G( O- x- ?6 p
38.       double breadth;     // 宽度
    1 Y6 ~5 Y6 d4 E6 M, q; I
39.       double height;      // 高度
      d7 X- g" ~$ U$ D6 E+ b6 J
40. };
      t4 ~$ R8 N, [
41. // 程序的主函数
    
42. int main( )
    
43. {
    
44.    Box Box1;                // 声明 Box1，类型为 Box
    8 ], @3 \; m" i0 U+ v: d# r
45.    Box Box2;                // 声明 Box2，类型为 Box
    
46.    Box Box3;                // 声明 Box3，类型为 Box
    
47.    double volume = 0.0;     // 把体积存储在该变量中
    - a6 h% `9 B; V
48. 
    ( v# W5 i+ y% `  X
49.    // Box1 详述
    2 K) @+ _3 d+ ~# d
50.    Box1.setLength(6.0);
    
51.    Box1.setBreadth(7.0);
    + L2 Y4 d4 s  b6 m& p+ ?+ x
52.    Box1.setHeight(5.0);
    . @" O, O/ ^. G, O6 N6 e
53. 
    5 f8 f" y5 ^& v- ]  U9 `
54.    // Box2 详述
    
55.    Box2.setLength(12.0);
    . d9 U9 [/ O1 P1 U) i, ^
56.    Box2.setBreadth(13.0);
    1 R0 B* @( a. a
57.    Box2.setHeight(10.0);
    1 w4 z; X8 G) u4 d# @  O
58. 
    
59.    // Box1 的体积
    
60.    volume = Box1.getVolume();
    
61.    cout << "Volume of Box1 : " << volume <<endl;
    % I4 I" `/ y4 g% |
62. 
    / j& t7 p( s3 L& o0 R, v4 E
63.    // Box2 的体积
    
64.    volume = Box2.getVolume();
    ) P9 t) ]' A3 ]* Z8 ~9 ^
65.    cout << "Volume of Box2 : " << volume <<endl;
    
66. 
    - W1 N! Z9 e, i. P0 ?6 I7 s
67.    // 把两个对象相加，得到 Box3
    
68.    Box3 = Box1 + Box2;
    
69. 
    
70.    // Box3 的体积
    
71.    volume = Box3.getVolume();
    
72.    cout << "Volume of Box3 : " << volume <<endl;
    + d& A' x0 e% n; |
73. 
    
74.    return 0;
    + {/ i5 I% u  F4 F1 F1 W
75. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   % ?( V$ k, Q: Q9 k6 M
2. Volume of Box1 : 210
   8 n8 a# b2 u2 P5 h8 O
3. Volume of Box2 : 1560
   7 ^: X, ]' X  Z7 q
4. Volume of Box3 : 5400</font></font></font>
   

复制代码

6 a2 i6 X( n: `+ A& P

五 、C++进阶 多态和数据抽象

C++ 多态

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

下面的实例中，基类 Shape 被派生为两个类，如下所示：

实例

1. 
   3 _' D0 I1 C0 T% Z/ y, J% ]$ o* `8 F
2. #include <iostream>
   
3. using namespace std;
   / z1 w5 M, L% P; s/ b+ }' J1 x. h
4. 
   0 E' s& L4 k- F+ c7 n( R: X
5. class Shape {
   
6.    protected:
   
7.       int width, height;
   : H1 P5 f7 H& k% [# z8 D5 I8 i$ R
8.    public:
   , U" U/ d6 E$ j9 J( u
9.       Shape( int a=0, int b=0)
   
10.       {
    : [3 [/ R# H" ~, g7 m
11.          width = a;
    
12.          height = b;
    4 U) x$ |; Y& M1 E
13.       }
    7 j' g% w) H" o+ {
14.       int area()
    # o2 {' l8 a+ f5 _4 P6 u
15. {
    4 n2 ]* W. g* b0 z  f
16.          cout << "Parent class area :" <<endl;
    3 a8 [2 R+ W( P$ M$ s, S% I
17.          return 0;
    
18.       }
    $ U& @; I9 f* D2 |
19. };
    3 L& Z- P0 ^, a' h/ `
20. class Rectangle: public Shape{
    7 o( P) K7 Y" u: {/ D1 [2 `
21.    public:
    
22.       Rectangle( int a=0, int b=0):Shape(a, b) { }
    8 j0 v% ]) |" N& J3 O
23.       int area ()
    : N: C6 C/ x' e% P# j
24. {
    / x6 e. V, c. j7 @- e* r
25.          cout << "Rectangle class area :" <<endl;
    
26.          return (width * height);
    
27.       }
    # r: D% c( z0 e  T
28. };
    
29. class Triangle: public Shape{
    
30.    public:
    ) e2 v1 R2 I3 H8 ~0 r
31.       Triangle( int a=0, int b=0):Shape(a, b) { }
    2 F1 o6 t. _3 `! R+ _
32.       int area ()
    0 e! |( k% b" s- f8 y) V
33. {
    
34.          cout << "Triangle class area :" <<endl;
    
35.          return (width * height / 2);
    0 j3 _* M" f& f5 a: A
36.       }
    ) n0 j; h+ B4 a
37. };
    ; i- [/ ?8 E2 E. ^% j) T  c8 |1 C
38. // 程序的主函数
    
39. int main( )
    
40. {
    4 B: C% F! t: f& m
41.    Shape *shape;
    
42.    Rectangle rec(10,7);
    
43.    Triangle  tri(10,5);
    
44. 
    
45.    // 存储矩形的地址
    
46.    shape = &rec;
    
47.    // 调用矩形的求面积函数 area
    9 i; h4 z7 O$ h
48.    shape->area();
    0 W5 S* J1 G- \; Y
49. 
    
50.    // 存储三角形的地址
    1 S/ w- T& l  v( y, V
51.    shape = &tri;
    
52.    // 调用三角形的求面积函数 area
    & V( {2 X! v: O
53.    shape->area();
    
54.    
    
55.    return 0;
    
56. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   0 h  ?1 X4 w$ c8 u
2. Parent class area
   
3. Parent class area

复制代码

导致错误输出的原因是，调用函数 area() 被编译器设置为基类中的版本，这就是所谓的静态多态，或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。

但现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示：

1. 
   # o' a) t7 v0 J9 J/ z' |% [
2. class Shape {
   
3.    protected:
   0 w: W* J- u- t+ j6 \) G
4.       int width, height;
   / M' ~1 w- Z9 a
5.    public:
   6 K' u- N) _1 a+ |, @) X) Z
6.       Shape( int a=0, int b=0)
   
7.       {
   
8.          width = a;
   
9.          height = b;
   9 R( ^- |) k; O8 ?
10.       }
    
11.       virtual int area()
    
12. {
    
13.          cout << "Parent class area :" <<endl;
    
14.          return 0;
    2 V, {, ?* \3 i* M5 O# X
15.       }
    
16. };

复制代码

修改后，当编译和执行前面的实例代码时，它会产生以下结果：

1. 
   
2. Rectangle class area
   
3. Triangle class area

复制代码

此时，编译器看的是指针的内容，而不是它的类型。因此，由于 tri 和 rec 类的对象的地址存储在 *shape 中，所以会调用各自的 area() 函数。

正如大家所看到的，每个子类都有一个函数 area() 的独立实现。这就是多态的一般使用方式。有了多态，就可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。

虚函数

虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

纯虚函数

大家可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是大家在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

我们可以把基类中的虚函数 area() 改写如下：

1. 
   9 ^5 F9 K& Y% `9 o7 m. u: L4 g
2. class Shape {
   1 Q/ h6 O6 \( D5 P9 Y
3.    protected:
   
4.       int width, height;
   + F4 k3 m' w; p5 e5 `' `  A
5.    public:
   # E" I2 @) O! z3 ~( R, c* X
6.       Shape( int a=0, int b=0)
   
7.       {
   # `( n3 T; j: ?6 a- N
8.          width = a;
   
9.          height = b;
   
10.       }
    + E- t% z7 Z; v+ \* H# J9 O
11.       // pure virtual function
    
12.       virtual int area() = 0;
    5 n" K- y% z  Z" V
13. };

复制代码

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

C++ 数据抽象

数据抽象是指，只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。

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

让我们举一个现实生活中的真实例子，比如一台电视机，可以打开和关闭、切换频道、调整音量、添加外部组件（如喇叭、录像机、DVD 播放器），但是我们不知道它的内部实现细节，也就是说，我们并不知道它是如何通过缆线接收信号，如何转换信号，并最终显示在屏幕上。

因此，我们可以说电视把它的内部实现和外部接口分离开了，我们无需知道它的内部实现原理，直接通过它的外部接口（比如电源按钮、遥控器、声量控制器）就可以操控电视。

现在，让我们言归正传，就 C++ 编程而言，C++ 类为数据抽象提供了可能。它们向外界提供了大量用于操作对象数据的公共方法，也就是说，外界实际上并不清楚类的内部实现。

例如，程序可以调用 sort() 函数，而不需要知道函数中排序数据所用到的算法。实际上，函数排序的底层实现会因库的版本不同而有所差异，只要接口不变，函数调用就可以照常工作。

在 C++ 中，我们使用类来定义我们自己的抽象数据类型（ADT）。可以使用类 iostream 的 cout 对象来输出数据到标准输出，如下所示：

实例

1. 
   , G: J, u( |$ z6 b, x+ M
2. #include <iostream>
   
3. using namespace std;
   " R; Q3 N1 Y: b* H' z
4. 
   ! b1 x$ d0 c- @! s. X) E- c
5. int main( )
   $ @# R% K  Y% z& y
6. {
   
7.    cout << "Hello C++" <<endl;
   
8.    return 0;
   / y6 ^, d+ q$ I2 }& L0 P, |
9. }

复制代码

在这里，暂时不需要理解 cout 是如何在用户的屏幕上显示文本。只需要知道公共接口即可，cout 的底层实现可以自由改变。

访问标签强制抽象

在 C++ 中，我们使用访问标签来定义类的抽象接口。一个类可以包含零个或多个访问标签：

• 使用公共标签定义的成员都可以访问该程序的所有部分。一个类型的数据抽象视图是由它的公共成员来定义的。
• 使用私有标签定义的成员无法访问到使用类的代码。私有部分对使用类型的代码隐藏了实现细节。
  
  7 @9 d$ V) P# E! c

访问标签出现的频率没有限制。每个访问标签指定了紧随其后的成员定义的访问级别。指定的访问级别会一直有效，直到遇到下一个访问标签或者遇到类主体的关闭右括号为止。

数据抽象的好处

数据抽象有两个重要的优势：

• 类的内部受到保护，不会因无意的用户级错误导致对象状态受损。
• 类实现可能随着时间的推移而发生变化，以便应对不断变化的需求，或者应对那些要求不改变用户级代码的错误报告。
  
  1 K- r! D. x1 |- s$ I

如果只在类的私有部分定义数据成员，编写该类的作者就可以随意更改数据。如果实现发生改变，则只需要检查类的代码，看看这个改变会导致哪些影响。

如果数据是公有的，则任何直接访问旧表示形式的数据成员的函数都可能受到影响。

数据抽象的实例

C++ 程序中，任何带有公有和私有成员的类都可以作为数据抽象的实例。请看下面的实例：

实例

1. 
   
2. #include <iostream>
   3 U& k$ ?! y+ [% P7 F9 K
3. using namespace std;
   
4. 
   
5. class Adder{
   4 D* a+ f3 e/ S( H& t6 ^
6.    public:
   
7.       // 构造函数
   ( n! e& }+ |5 w" C6 a' Q& e
8.       Adder(int i = 0)
   0 `  T2 X  f1 n- b
9.       {
   - ~, i2 j/ b8 w8 G+ N
10.         total = i;
    0 G5 e5 Z8 S8 L+ f& R9 f
11.       }
    
12.       // 对外的接口
    
13.       void addNum(int number)
    7 D0 G2 J4 Z7 U0 C7 {1 L# f9 S
14. {
    
15.           total += number;
    
16.       }
    * n7 F1 m9 d# ^5 D
17.       // 对外的接口
    ( [4 K* w7 g8 x/ L3 y/ d
18.       int getTotal()
    
19. {
    
20.           return total;
    
21.       };
    
22.    private:
    
23.       // 对外隐藏的数据
    # G$ J1 g! ^) G+ w
24.       int total;
    ' `# _& J2 s% {. `
25. };
    
26. int main( )
    
27. {
    
28.    Adder a;
    
29.    
    
30.    a.addNum(10);
    
31.    a.addNum(20);
    
32.    a.addNum(30);
    # U4 }6 c& [  f8 y
33. 
    ( h/ b1 a& Z3 `7 \9 b
34.    cout << "Total " << a.getTotal() <<endl;
    1 X1 o$ I8 l( i8 T
35.    return 0;
    
36. }

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

• Total 60
  9 i" B2 X6 `* M$ C% T

上面的类把数字相加，并返回总和。公有成员 addNum 和 getTotal 是对外的接口，用户需要知道它们以便使用类。私有成员 total 是用户不需要了解的，但又是类能正常工作所必需的。

; _8 c4 ]& d9 v! N0 W: x, p+ v" S

C++ 数据封装

所有的 C++ 程序都有以下两个基本要素：

• 程序语句（代码）：这是程序中执行动作的部分，它们被称为函数。
• 程序数据：数据是程序的信息，会受到程序函数的影响。
  
  0 s, P3 z! y7 K+ j: @( {

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。

数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。

C++ 通过创建类来支持封装和数据隐藏（public、protected、private）。我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。默认情况下，在类中定义的所有项目都是私有的。例如：

1. 
   
2. class Box
   8 o. `7 E( w' ]8 Q) d* f
3. {
   1 x* }* |0 r) g4 K0 E& R& H0 Q- H
4.    public:
   7 S. A  @6 i5 A; K- L  D
5.       double getVolume(void)
   3 n- B& r9 D) X
6.       {
   
7.          return length * breadth * height;
   
8.       }
   
9.    private:
   , w. g9 }: b5 G3 U' M7 z+ r6 j
10.       double length;      // 长度
    + @8 i" V2 D1 x# `) k
11.       double breadth;     // 宽度
    
12.       double height;      // 高度
    % w5 M# B; S0 G2 e: D4 r5 t7 W
13. };

复制代码

$ Z6 |; M1 F( H' y

变量 length、breadth 和 height 都是私有的（private）。这意味着它们只能被 Box 类中的其他成员访问，而不能被程序中其他部分访问。这是实现封装的一种方式。

为了使类中的成员变成公有的（即，程序中的其他部分也能访问），必须在这些成员前使用 public 关键字进行声明。所有定义在 public 标识符后边的变量或函数可以被程序中所有其他的函数访问。

把一个类定义为另一个类的友元类，会暴露实现细节，从而降低了封装性。理想的做法是尽可能地对外隐藏每个类的实现细节。

; e: x. L- ]! y: L

数据封装的实例

C++ 程序中，任何带有公有和私有成员的类都可以作为数据封装和数据抽象的实例。请看下面的实例：

实例

1. 
   : n9 w! P2 L( G: n
2. #include <iostream>
   , U5 M$ M  }+ ^2 u" W0 ~' t$ ^6 a
3. using namespace std;
   
4. 
   
5. class Adder{
   
6.    public:
   
7.       // 构造函数
   ' q$ n7 n  \1 U! H& d7 j3 \
8.       Adder(int i = 0)
   
9.       {
   # u& r  {4 ~7 P
10.         total = i;
    
11.       }
    
12.       // 对外的接口
    8 K6 X6 L4 r: \
13.       void addNum(int number)
    
14. {
    4 G" u  `5 T6 b. [, m' [/ J2 ]
15.           total += number;
    
16.       }
    
17.       // 对外的接口
    - X9 I; W; z' ~/ P" x* k
18.       int getTotal()
    ! Q1 s9 j: ^7 l5 L
19. {
    
20.           return total;
    
21.       };
    6 q5 _3 B3 g* {0 }0 e0 ^0 B' o
22.    private:
      T1 P  U, l0 I
23.       // 对外隐藏的数据
    
24.       int total;
    
25. };
    
26. int main( )
    
27. {
    9 p, u8 b2 v: V5 S  w
28.    Adder a;
    
29.    
    . Z+ J6 k7 p0 U1 Q$ ~
30.    a.addNum(10);
    0 O- l2 z" T# b% g, p% O, p- l: D5 G
31.    a.addNum(20);
    
32.    a.addNum(30);
    4 q6 X: y( g$ S9 N  v1 J& P
33. 
    + r. Q0 r. j* d
34.    cout << "Total " << a.getTotal() <<endl;
    
35.    return 0;
    
36. }
    

复制代码

当上面的代码被编译和执行时，它会产生下列结果：

• Total 60
  % H, }  J3 L5 M3 v8 `

上面的类把数字相加，并返回总和。公有成员 addNum 和 getTotal 是对外的接口，用户需要知道它们以便使用类。私有成员 total 是对外隐藏的，用户不需要了解它，但它又是类能正常工作所必需的。

! T3 Q- H7 v0 Y

六、c++进阶 模板和stl入门

C++ 模板

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。

模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。

每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。

您可以使用模板来定义函数和类，接下来让我们一起来看看如何使用。

函数模板

模板函数定义的一般形式如下所示：

1. 
   / e& w) [. r8 _8 Y6 _. B
2. template <class type> ret-type func-name(parameter list)
   
3. {
   
4. // 函数的主体
   ( b6 ~7 U$ l$ Q  T0 q
5. }

复制代码

在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。
  B* E; S9 L% J

下面是函数模板的实例，返回两个数中的最大值：

实例

1. 
   6 S2 n1 O- V! b. P* u( e
2. #include <iostream>
   
3. #include <string>
   : Y4 M5 _3 H9 n- d) }$ d
4. 
   
5. using namespace std;
   1 a. I0 S7 V. p) _
6. 
   " X' G# f4 N; b! ?& P* E
7. template <typename T>
   % L7 |' _! q& D# @9 D1 D( q1 {% _
8. inline T const& Max (T const& a, T const& b)
   7 |' A* Q9 c0 }) |& I' z; u
9. {
   
10.     return a < b ? b:a;
    
11. }
    * x8 B; c8 r0 ?! o  T: v5 K* L% H
12. int main ()
    5 u/ W/ v8 |6 v& v5 F( @  a; K6 a& r
13. {
    1 M  S- Y0 v' z9 O- s: ^7 w6 H
14. 
    
15.     int i = 39;
    
16.     int j = 20;
    / g( M0 I! [; b" f+ R$ z
17.     cout << "Max(i, j): " << Max(i, j) << endl;
    
18. 
    : t% V/ ~1 j' n  z7 I) f
19.     double f1 = 13.5;
    
20.     double f2 = 20.7;
    : e1 o4 R8 D1 O$ Z% [
21.     cout << "Max(f1, f2): " << Max(f1, f2) << endl;
    * [$ ?$ V/ @6 V! C+ `& b2 ?
22. 
    5 n" h* }2 a" w1 Z! I1 _
23.     string s1 = "Hello";
    
24.     string s2 = "World";
    
25.     cout << "Max(s1, s2): " << Max(s1, s2) << endl;
    
26. 
    
27.    return 0;
    
28. }

复制代码

) Z( B5 `# y- P8 m' s5 D( m( b+ {

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   
2. Max(i, j): 39
   
3. Max(f1, f2): 20.7
   $ ^4 o2 A/ q& T0 g& [/ e8 m
4. Max(s1, s2): World类模板

复制代码

正如我们定义函数模板一样，我们也可以定义类模板。泛型类声明的一般形式如下所示：

1. 
   + o9 W' ?& B  J8 B7 \% w# k, d- ]
2. template <class type> class class-name {
   3 C$ q% f. `6 J+ m
3. .
   ! K1 N7 `8 a9 x- A; p
4. .
   
5. .
   ! ?. j3 N- M* a+ h
6. }

复制代码

在这里，type 是占位符类型名称，可以在类被实例化的时候进行指定。您可以使用一个逗号分隔的列表来定义多个泛型数据类型。

下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作：

实例

1. 
   
2. #include <iostream>
   
3. #include <vector>
   
4. #include <cstdlib>
   ; h- K! ]6 X& N* k& q) i& T
5. #include <string>
   
6. #include <stdexcept>
   - t% ^7 D- V2 m& O6 t: E
7. 
   
8. using namespace std;
   ! e5 O2 g( b6 W3 I
9. 
     H6 q1 |& V7 p8 i9 E$ h. e# N9 [
10. template <class T>
    
11. class Stack {
    
12.   private:
    ! ]; H8 c) ^7 U- U/ ?) y
13.     vector<T> elems;     // 元素
    . K2 k& X7 M2 S9 L2 e
14. 
    
15.   public:
    
16.     void push(T const&);  // 入栈
      D1 u/ F  t0 D( \1 a2 y
17.     void pop();               // 出栈
    
18.     T top() const;            // 返回栈顶元素
    
19.     bool empty() const{       // 如果为空则返回真。
    
20.         return elems.empty();
    
21.     }
    
22. };
    
23. 
    
24. template <class T>
    
25. void Stack<T>::push (T const& elem)
    6 J1 M5 a- {$ O
26. {
    . h6 o# B% ^; t" p0 R- I& P2 ?
27.     // 追加传入元素的副本
    9 G( d$ f  C# j2 ~! U; h" Q
28.     elems.push_back(elem);   
    
29. }
    
30. 
    2 u+ ^& e1 a3 C2 }7 |* T5 Y
31. template <class T>
    
32. void Stack<T>::pop ()
    
33. {
    8 B4 n, u% K8 n& e7 G. A
34.     if (elems.empty()) {
    ' D1 H1 E8 s6 @% f" R2 n
35.         throw out_of_range("Stack<>::pop(): empty stack");
    ( Z6 l! R# Y# R! E3 [) r  }
36.     }
    
37.     // 删除最后一个元素
    
38.     elems.pop_back();         
    ' c9 K2 x3 I9 K
39. }
    % S1 M$ v( z6 i! @: Q
40. 
    ' ?" e" f1 d9 w4 Y3 _& z1 D
41. template <class T>
    ; I5 I4 {4 ^' I) D
42. T Stack<T>::top () const
    
43. {
    & p# G5 G1 n8 {( I
44.     if (elems.empty()) {
    
45.         throw out_of_range("Stack<>::top(): empty stack");
    ; i. x# s) T, g+ k& p+ _% v2 ]+ Y6 X
46.     }
    
47.     // 返回最后一个元素的副本
    
48.     return elems.back();      
    * Y  `9 y5 o  P) p' L
49. }
    
50. 
    
51. int main()
    
52. {
    
53.     try {
    
54.         Stack<int>         intStack;  // int 类型的栈
    
55.         Stack<string> stringStack;    // string 类型的栈
    
56. 
    3 w2 i. f2 u! E5 O0 }  G) S
57.         // 操作 int 类型的栈
    % n. w4 I" }4 m5 d
58.         intStack.push(7);
    
59.         cout << intStack.top() <<endl;
    ( x8 q+ u* |/ A6 O3 |, e
60. 
    ) X( m+ N* S& E  G4 P; u/ T% f' O3 B/ u0 m
61.         // 操作 string 类型的栈
    ' e6 g) Y: h  E! H7 l: A
62.         stringStack.push("hello");
    
63.         cout << stringStack.top() << std::endl;
    
64.         stringStack.pop();
    $ {" m$ J9 d. T$ X
65.         stringStack.pop();
    
66.     }
    0 f( T6 r6 [2 v0 k
67.     catch (exception const& ex) {
    $ _4 F* }6 J( f3 g
68.         cerr << "Exception: " << ex.what() <<endl;
    # C: [8 J) u1 ]4 r8 z' u# h) ?* m( t
69.         return -1;
    
70.     }
    
71. }

复制代码

* l3 m5 [+ q& B5 c# f1 F! N% e

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   
2. 7
   
3. hello
   
4. Exception: Stack<>::pop(): empty stack

复制代码

& S' `! c# Z# I) T2 z% Y

* r' ~5 `( ~* O. d  a, |

C++ STL 入门

上面我们已经了解了 C++ 模板的概念。C++ STL（标准模板库）是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现多种流行和常用的算法和数据结构，如向量、链表、队列、栈。

C++ 标准模板库的核心包括以下三个组件：

组件

[td]

描述	+ h0 g9 E8 L% T
容器（Containers）	容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。
算法（Algorithms）	算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。
迭代器（iterators）	迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。

这三个组件都带有丰富的预定义函数，帮助我们通过简单的方式处理复杂的任务。

下面的程序演示了向量容器（一个 C++ 标准的模板），它与数组十分相似，唯一不同的是，向量在需要扩展大小的时候，会自动处理它自己的存储需求：

实例

1. 
   
2. #include <iostream>
   2 U5 @5 N/ ^7 ~, `- I2 b
3. #include <vector>
   
4. using namespace std;
   2 B# X# ]& D5 a/ }
5. 
   : f% [# D4 Y1 p6 E$ t& |: k* O
6. int main()
     ?$ B. f- ^5 _/ ~6 k1 ?
7. {
   1 W5 x6 w% N! R5 b
8.    // 创建一个向量存储 int
   % @6 i, A2 I# D( J, b: o
9.    vector<int> vec;
   / c6 U2 t1 h$ d, Q- \: d, L& `
10.    int i;
    
11. 
    
12.    // 显示 vec 的原始大小
    2 a1 s1 `- Q1 l# X$ V9 m6 E
13.    cout << "vector size = " << vec.size() << endl;
    
14. 
    5 S2 F9 b" H/ P4 Z7 j. d
15.    // 推入 5 个值到向量中
    
16.    for(i = 0; i < 5; i++){
    
17.       vec.push_back(i);
    7 _8 L2 x& K  S- O. ~; G
18.    }
    
19. 
    ! ?, K" {( Q- W; f* o1 V, Z; x; K/ z
20.    // 显示 vec 扩展后的大小
    & ~  K. F9 F9 \
21.    cout << "extended vector size = " << vec.size() << endl;
    
22. 
    4 X6 Q  N7 n" ~9 a) b
23.    // 访问向量中的 5 个值
    
24.    for(i = 0; i < 5; i++){
    
25.       cout << "value of vec [" << i << "] = " << vec[i] << endl;
    $ G% a7 _/ r9 ?' E6 `, T2 K, h
26.    }
    ' k' E+ |) f) Y8 t+ `. ~
27. 
    ) F( G3 D8 V2 `8 Y4 a
28.    // 使用迭代器 iterator 访问值
    
29.    vector<int>::iterator v = vec.begin();
    
30.    while( v != vec.end()) {
    
31.       cout << "value of v = " << *v << endl;
    ( M8 k: Z, y+ h% u7 O: H0 K) O0 a
32.       v++;
    ! H0 Y* s% w# m, G# N
33.    }
    
34. 
    4 S. d1 A+ g% p. ?
35.    return 0;
    
36. }

复制代码

) X, e# U. X; ?$ ~

当上面的代码被编译和执行时，它会产生下列结果：

1. 
   
2. vector size = 0
     h! o% p6 A4 C7 T
3. extended vector size = 5
   9 o3 t- ^+ \- i! b) _% U
4. value of vec [0] = 0
   3 a3 P0 ?% C/ \
5. value of vec [1] = 1
   ; a0 m0 S! v' N) D, s; h  E
6. value of vec [2] = 2
   
7. value of vec [3] = 3
   
8. value of vec [4] = 4
   
9. value of v = 0
   ; N5 }6 z: {* \2 |6 z# U2 c6 @
10. value of v = 1
    
11. value of v = 2
    
12. value of v = 3
    
13. value of v = 4

复制代码

  [* X  w7 l5 G; v5 a7 t

关于上面实例中所使用的各种函数，有几点要注意：

• push_back( ) 成员函数在向量的末尾插入值，如果有必要会扩展向量的大小。
• size( ) 函数显示向量的大小。
• begin( ) 函数返回一个指向向量开头的迭代器。
• end( ) 函数返回一个指向向量末尾的迭代器。
  
  8 _. Z# q& C9 C# r$ Z