CPlusPlus入门

本资源名为“CPlusPlus入门”，系统性地介绍了有关C 编程语言的入门知识。希望此资源能帮助C 编程初学者入门，本资源旨在培养C 编程兴趣。

CPlusPlus入门

• 本资源名为“CPlusPlus入门”，希望此资源能帮助C++编程初学者入门，本资源旨在培养C++编程兴趣。 C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。
• C++开始
  • C++百度百科
    • 官网
      • 参考手册
        • 教程
  • 本资源作者 袁宵
• C++绪论
  • C++是什么
    • C++是在C语言的基础上开发的一种面向对象编程语言，应用广泛。C++支持多种编程范式：面向对象编程、泛型编程和过程化编程。 其编程领域众广，常用于系统开发，引擎开发等应用领域，是最受广大程序员受用的最强大编程语言之一,支持：类、封装、重载、继承、模版等特性。
    • C++基本内容
      • C++基本内容：类、封装、重载、继承、模版
    • C++与C的关系
      • c++在c的基础上增添类，C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。
    • 语言特点
      • 支持数据封装和数据隐藏 在C++中，类是支持数据封装的工具，对象则是数据封装的实现。C++通过建立用户定义类支持数据封装和数据隐藏。 在面向对象的程序设计中，将数据和对该数据进行合法操作的函数封装在一起作为一个类的定义。对象被说明为具有一个给定类的变量。每个给定类的对象包含这个类所规定的若干私有成员、公有成员及保护成员。完好定义的类一旦建立，就可看成完全封装的实体，可以作为一个整体单元使用。类的实际内部工作隐藏起来，使用完好定义的类的用户不需要知道类是如何工作的，只要知道如何使用它即可。 支持继承和重用 在C++现有类的基础上可以声明新类型，这就是继承和重用的思想。通过继承和重用可以更有效地组织程序结构，明确类间关系，并且充分利用已有的类来完成更复杂、深入的开发。新定义的类为子类，成为派生类。它可以从父类那里继承所有非私有的属性和方法，作为自己的成员。 支持多态性 采用多态性为每个类指定表现行为。多态性形成由父类和它们的子类组成的一个树型结构。在这个树中的每个子类可以接收一个或多个具有相同名字的消息。当一个消息被这个树中一个类的一个对象接收时，这个对象动态地决定给予子类对象的消息的某种用法。多态性的这一特性允许使用高级抽象。 继承性和多态性的组合，可以轻易地生成一系列虽然类似但独一无二的对象。由于继承性，这些对象共享许多相似的特征。由于多态性，一个对象可有独特的表现方式，而另一个对象有另一种表现方式。
  • C++参考资料
    • C++参考手册
    • W3Cschool C++教程
    • C++ Primer 、C++ Primer Plus
• C++程序基础
  • 基本语法
    • C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。
      • C++ 基本语法 C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。现在让我们简要地看一下什么是类、对象，方法、即时变量。 对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。 类 - 类可以定义为描述对象行为/状态的模板/蓝图。 方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。 即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。
    • 程序结构
      • C++ 程序结构 让我们看一段简单的代码，可以输出单词 Hello World。 #include <iostream> using namespace std; // main() 是程序开始执行的地方 int main() { cout << "Hello World"; // 输出 Hello World return 0; } 接下来我们讲解一下上面这段程序： C++ 语言定义了一些头文件，这些头文件包含了程序中必需的或有用的信息。上面这段程序中，包含了头文件 <iostream>。 行 using namespace std; 告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念。 下一行 // main() 是程序开始执行的地方 是一个单行注释。单行注释以 // 开头，在行末结束。 下一行 int main() 是主函数，程序从这里开始执行。 下一行 cout << "Hello World"; 会在屏幕上显示消息 "Hello World"。 下一行 return 0; 终止 main( )函数，并向调用进程返回值 0。
    • 注释
      • C++ 注释 程序的注释是解释性语句，您可以在 C++ 代码中包含注释，这将提高源代码的可读性。所有的编程语言都允许某种形式的注释。 C++ 支持单行注释和多行注释。注释中的所有字符会被 C++ 编译器忽略。 C++ 注释以 /* 开始，以 */ 终止。例如： /* 这是注释 */ /* C++ 注释也可以 * 跨行 */ 注释也能以 // 开始，直到行末为止。例如： #include using namespace std; main() { cout << "Hello World"; // 输出 Hello World return 0; } 当上面的代码被编译时，编译器会忽略 // prints Hello World，最后会产生以下结果： Hello World 在 /* 和 */ 注释内部，// 字符没有特殊的含义。在 // 注释内，/* 和 */ 字符也没有特殊的含义。因此，您可以在一种注释内嵌套另一种注释。例如： /* 用于输出 Hello World 的注释 cout << "Hello World"; // 输出 Hello World */
      • 单行注释：// 单行注释内容
      • 多行注释：/* 多行注释内容 */
  • 变量与常量
    • 变量
      • C++ 变量类型 变量其实只不过是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。 变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C++ 是大小写敏感的。 基本类型，以及各种其他类型的变量，比如枚举、指针、数组、引用、数据结构、类等等
      • 定义与声明
        • 变量定义：type variable_list;
          • C++ 中的变量定义 变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示： type variable_list; 在这里，type 必须是一个有效的 C++ 数据类型，可以是 char、w_char、int、float、double、bool 或任何用户自定义的对象，variable_list 可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明： int i, j, k; char c, ch; float f, salary; double d; 行 int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。 变量可以在声明的时候被初始化（指定一个初始值）。初始化器由一个等号，后跟一个常量表达式组成，如下所示： type variable_name = value; 下面列举几个实例： extern int d = 3, f = 5; // d 和 f 的声明 int d = 3, f = 5; // 定义并初始化 d 和 f byte z = 22; // 定义并初始化 z char x = 'x'; // 变量 x 的值为 'x' 不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。
        • 变量声明：extern
          • C++ 中的变量声明 变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量定义。 当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。 实例 尝试下面的实例，其中，变量在头部就已经被声明，但它们是在主函数内被定义和初始化的： #include <iostream> using namespace std; // 变量声明 extern int a, b; extern int c; extern float f; int main () { // 变量定义 int a, b; int c; float f; // 实际初始化 a = 10; b = 20; c = a + b; cout << c << endl ; f = 70.0/3.0; cout << f << endl ; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 30 23.3333 同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。例如： // 函数声明 int func(); int main() { // 函数调用 int i = func(); } // 函数定义 int func() { return 0; }
        • 定义与声明的关系
          • 定义包含了声明，但是声明不包含定义，如 int a = 0; //定义并声明了变量 a extern int a; //只是声明了有一个变量 a 存在，具体 a 在哪定义的，需要编译器编译的时候去找。 函数也是类似，定义的时候同时声明。但如果只是声明，编译器只知道有这么个函数，具体函数怎么定义的要编译器去找。 void fun1(); //函数声明 void fun1(){ //函数定义 cout<<"fun1"<<endl; }
      • 左值与右值
        • C++ 中的左值（Lvalues）和右值（Rvalues） C++ 中有两种类型的表达式： 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。 变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句： int g = 20; 但是下面这个就不是一个有效的语句，会生成编译时错误： 10 = 20;
      • 变量的作用域
        • C++ 变量作用域 作用域是程序的一个区域，一般来说有三个地方可以声明变量： 在函数或一个代码块内部声明的变量，称为局部变量。 在函数参数的定义中声明的变量，称为形式参数。 在所有函数外部声明的变量，称为全局变量。
        • 局部变量
          • 局部变量 在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用。下面的实例使用了局部变量： #include <iostream> using namespace std; int main () { // 局部变量声明 int a, b; int c; // 实际初始化 a = 10; b = 20; c = a + b; cout << c; return 0; }
        • 全局变量
          • 全局变量 在所有函数外部定义的变量（通常是在程序的头部），称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。 全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的。下面的实例使用了全局变量和局部变量： #include <iostream> using namespace std; // 全局变量声明 int g; int main () { // 局部变量声明 int a, b; // 实际初始化 a = 10; b = 20; g = a + b; cout << g; return 0; } 在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。下面是一个实例： #include <iostream> using namespace std; // 全局变量声明 int g = 20; int main () { // 局部变量声明 int g = 10; cout << g; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 10
        • 变量初始化
          • 初始化局部变量和全局变量 当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值： 数据类型 初始化默认值 int 0 char '\0' float 0 double 0 pointer NULL 正确地初始化变量是一个良好的编程习惯，否则有时候程序可能会产生意想不到的结果。
      • 变量、变量名与地址的区别
        • 变量：用来标识(identify)一块内存区域，这块区域的值一般是可以更改的，这就是它“变”的由来，但是我们可以通过使用如const等一些修饰符号来限定这一内存区域的操作特性(characteristic)，即变量的操作特性。用const修饰的使变量不能更改的就和常量一样的变量叫做常变量。 变量名：是一个标识符(identifier)，用来指代一块内存区域，即变量，使用变量使我们操作内存以区域(area)，以块(block)为单位，提高了方便性。 你的机器代码中，是不会出现变量名的；变量名是给我们程序员操作内存来使用的。 对于编译器，它会搜集我们的变量名，比如我们定义了一个全局的int a;那么编译器都为我们做了什么呢？ 它会为程序预留4个字节的空间（假设在32位平台），并把我们的变量名“a”保存进符号表，并用这个符号表的索引对应实际的空间。如果下面出现b = a;那么它就会根据符号表找到变量的真正的物理位置，取得它的值，赋给b。 这是写编译器需要做的，我们需要建立符号表。但是实际在汇编层次上，操作的都是地址而已，不存在任何名称了。 指针名、数组名、函数名、变量名、类名、结构名与地址的关系 指针名、数组名、函数名就是地址，它们分别表示指针所指向元素的地址、数组的首地址和函数的入口地址。 变量名虽然不直接表示地址，但可用取地址符号&来获得它所代表的变量的存放地址。因为在定义变量的同时会分配给它相应的空间。 但类和结构只有事例化时才为它分配空间，从而不能用取地址符号&来获得类名或结构名的地址。
    • 常量
      • C++ 常量 常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。 常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。 常量就像是常规的变量，只不过常量的值在定义后不能进行修改。
      • 基本内置类型常量
        • 整数、浮点数、布尔、字符、字符串常量
          • 1. 整数常量 整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。 下面列举几个整数常量的实例： 212 // 合法的 215u // 合法的 0xFeeL // 合法的 078 // 非法的：8 不是八进制的数字 032UU // 非法的：不能重复后缀 以下是各种类型的整数常量的实例： 85 // 十进制 0213 // 八进制 0x4b // 十六进制 30 // 整数 30u // 无符号整数 30l // 长整数 30ul // 无符号长整数 2. 浮点常量 浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。当使用小数形式表示时，必须包含小数点、指数，或同时包含两者。当使用指数形式表示时，必须包含整数部分、小数部分，或同时包含两者。带符号的指数是用 e 或 E 引入的。 下面列举几个浮点常量的实例： 3.14159 // 合法的 314159E-5L // 合法的 510E // 非法的：不完整的指数 210f // 非法的：没有小数或指数 .e55 // 非法的：缺少整数或分数 3. 布尔常量 布尔常量共有两个，它们都是标准的 C++ 关键字： true 值代表真。 false 值代表假。 我们不应把 true 的值看成 1，把 false 的值看成 0。 4. 字符常量 字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L'x'），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 'x'），此时它可以存储在 char 类型的简单变量中。 字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\t'），或一个通用的字符（例如 '\u02C0'）。 在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码： 转义序列 含义 \\ \ 字符 \' ' 字符 \" " 字符 \? ? 字符 \a 警报铃声 \b 退格键 \f 换页符 \n 换行符 \r 回车 \t 水平制表符 \v 垂直制表符 \ooo 一到三位的八进制数 \xhh . . . 一个或多个数字的十六进制数 5. 字符串常量 字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。可以使用空格做分隔符，把一个很长的字符串常量进行分行。 下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。 "hello, dear" "hello, \ dear" "hello, " "d" "ear"
      • 自定义常量
        • #define
          • #define 预处理器 下面是使用 #define 预处理器定义常量的形式： #define identifier value 具体请看下面的实例： #include <iostream> using namespace std; #define LENGTH 10 #define WIDTH 5 #define NEWLINE '\n' int main() { int area; area = LENGTH * WIDTH; cout << area; cout << NEWLINE; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 50
        • 关键字const
          • const 关键字 您可以使用 const 前缀声明指定类型的常量，如下所示： const type variable = value; 具体请看下面的实例： #include <iostream> using namespace std; int main() { const int LENGTH = 10; const int WIDTH = 5; const char NEWLINE = '\n'; int area; area = LENGTH * WIDTH; cout << area; cout << NEWLINE; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 50 请注意，把常量定义为大写字母形式，是一个很好的编程实践。
      • 常量又称为字面量
  • 数据类型
    • C++ 数据类型 使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留一些空间。 您可能需要存储各种数据类型（比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。
    • 基本类型对应的变量和常量
      • 整型
        • 整数常量
          • 整数常量是不带小数的数值，用来表示正负数。例2—2中Ox55、0x55ff、1000000都是c++语言的整数常量。 c++语言的整数常量有三种形式：十进制、八进制、十六迸制。 （1）十进制整数是由不以0开头的0～9的数字组成的数据。 （2）八进制整数是由以0开头的0～7的数字组成的数据。 （3）十六进制整数是由以0x或0x开头的0～9的数字及A～F的字母(大小写字母均可)组成的数据。 例如： 0，63，83是十进制数。 00，077，0123是八进制数。 0x0，Ox0，0x53，0x53，0x3f，0x3f是十六进制数。 整数常量的取值范围是有限的，它的大小取决于此类整型数的类型，与所使用的进制形式无关。
        • 整型变量类型
          • 整型变量类型有byte，short，int，long四种说明符，它们都是有符号整型变量类型。 （1）byte类型。 byte类型说明一个带符号的8位整型变量。由于不同的机器对多字节数据的存储方式不同，可能是从低字节向高字节存储，也可能是从高字节向低字节存储。这样，在分析网络协议或文件格式时，为了解决不同机器上的字节存储顺序问题，用byte类型来表示数据是合适的。 （2）short类型。 short类型说明一个带符号的16位整型变量。short类型限制了数据的存储应为先高字节，后低字节。 （3）int类型。 int类型说明一个带符号的32位整型变量。int类型是一种最丰富、最有效的类型。它最常用于计数、数组访问和整数运算。 （4）long类型。 long类型说明一个带符号的64位整型变量。对于大型计算，常常会遇到很大的整数，并超出int所表示的范围，这时要使用long类型。
      • 浮点型
        • 浮点数常量
          • 浮点数是带有小数的十进制数，可用一般表示法或科学记数法表示。0.23f、0.7e-3都是c++语言的浮点数常量。 （1）一般表示法：十进制整数+小数点+十进制小数。 （2）科学记数法：十进制整数+小数点+十进制小数+E（或e）+正负号+指数。 例如：3.14159，0.567，9777.12是一般表示法形式，1.234e5，4.90867e-2是科学记数法形式。 c++语言的浮点数常量在机器中有单精度和双精度之分。单精度以32位形式存放，用f/F做后缀标记(可以省略)；双精度则以64位形式存放。当一个浮点数常量没有特别指定精度时，则它为双精度浮点数常量。
        • 浮点变量类型
          • 浮点变量也称实数变量，用于需要精确到小数的函数运算中，有float和double两种类型说明符。 （1）float类型。 float类型是一个位数为32位的单精度浮点数。它具有运行速度较快，占用空间较少的特点。 （2）double类型。 double类型是一个位数为64的双精度浮点数。双精度数在某些具有优化和高速运算能力的现代处理机上运算比单精度数快。双精度类型double比单精度类型float具有更高的精度和更大表示范围，常常使用。
      • 字符型
        • 字符型常量
          • 字符型常量是指由单引号括起来的单个字符。 例如：’a’，’A’，’z’，‘$’，’?’。 注意：’a’和’A’是两个不同的字符常量。 除了以上形式的字符常量外，c++语言还允许使用一种以“\”开头的特殊形式的字符常量。这种字符常量称为转义字符，用来表示一些不可显示的或有特殊意义的字符。
        • 字符型变量
          • 字符型变量的类型说明符为char，它在机器中占8位，其范围为0～255。 注意：字符型变量只能存放一个字符，不能存放多个字符，例如：char a='am'; 这样定义赋值是错误的。
      • 布尔型
        • 布尔常量
          • 布尔常量只有两个值：“true”和“false”，表示“真”和“假”，均为关键词，在机器中位长为8位。
        • 布尔型变量
          • 布尔型变量的类型说明符为booI，用来表示逻辑值。
    • 七种基本类型
      • 数据类型指明变量或表达式的状态和行为，数据类型决定了数的取值范围和允许执行的运算符集。 c++语言数据类型可以分为两大类：基本类型和引用类型。基本类型是指不能再分解的数据类型，其数据在函数的调用中是以传值方式工作的；引用类型有时也称复合类型，它是可以分解为基本类型的数据类型，其数据在函数调用中是以传址方式来工作的。
      • 布尔型、字符型、整形、浮点型、双浮点型、无类型、宽字符型
        • 基本的内置类型 C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型： 类型 关键字 布尔型 bool 字符型 char 整型 int 浮点型 float 双浮点型 double 无类型 void 宽字符型 wchar_t
      • 数值类型范围
        • 下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。 注意：不同系统会有所差异。 类型 位 范围 char 1 个字节 -128 到 127 或者 0 到 255 unsigned char 1 个字节 0 到 255 signed char 1 个字节 -128 到 127 int 4 个字节 -2147483648 到 2147483647 unsigned int 4 个字节 0 到 4294967295 signed int 4 个字节 -2147483648 到 2147483647 short int 2 个字节 -32768 到 32767 unsigned short int 2 个字节 0 到 65,535 signed short int 2 个字节 -32768 到 32767 long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 signed long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 unsigned long int 8 个字节 0 to 18,446,744,073,709,551,615 float 4 个字节 +/- 3.4e +/- 38 (~7 个数字) double 8 个字节 +/- 1.7e +/- 308 (~15 个数字) long double 16 个字节 +/- 1.7e +/- 308 (~15 个数字) wchar_t 2 或 4 个字节 1 个宽字符 从上表可得知，变量的大小会根据编译器和所使用的电脑而有所不同。 下面实例会输出您电脑上各种数据类型的大小。 #include <iostream> using namespace std; int main() { cout << "Size of char : " << sizeof(char) << endl; cout << "Size of int : " << sizeof(int) << endl; cout << "Size of short int : " << sizeof(short int) << endl; cout << "Size of long int : " << sizeof(long int) << endl; cout << "Size of float : " << sizeof(float) << endl; cout << "Size of double : " << sizeof(double) << endl; cout << "Size of wchar_t : " << sizeof(wchar_t) << endl; return 0; } 本实例使用了 endl，这将在每一行后插入一个换行符，<< 运算符用于向屏幕传多个值。我们也使用 sizeof() 函数来获取各种数据类型的大小。 当上面的代码被编译和执行时，它会产生以下的结果，结果会根据所使用的计算机而有所不同： Size of char : 1 Size of int : 4 Size of short int : 2 Size of long int : 4 Size of float : 4 Size of double : 8 Size of wchar_t : 4
    • 类型修饰符：signed、unsigned、short、long
    • 类型限定符：const、volatile、restrict
      • C++ 中的类型限定符 类型限定符提供了变量的额外信息。 限定符 含义 const const 类型的对象在程序执行期间不能被修改改变。 volatile 修饰符 volatile 告诉编译器，变量的值可能以程序未明确指定的方式被改变。 restrict 由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。
    • 枚举类型
      • 枚举类型 枚举类型声明一个可选的类型名称和一组标识符，用来作为该类型的值。其带有零个或多个标识符可以被用来作为该类型的值。每个枚举数是一个枚举类型的常数。 创建枚举，需要使用关键字 enum。枚举类型的一般形式为： enum enum-name { list of names } var-list; 在这里，enum-name 是枚举类型的名称。名称列表 { list of names } 是用逗号分隔的。 例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 "blue"。 enum color { red, green, blue } c; c = blue; 默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。 enum color { red, green=5, blue }; 在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1。
  • 运算
    • 运算符
      • 内置6种类型的运算符
        • 算数、关系、逻辑、位、赋值、杂项运算符
          • 1. 算术运算符 下表显示了 C++ 支持的所有算术运算符。 假设变量 A 的值为 10，变量 B 的值为 20，则： 运算符 描述 实例 + 把两个操作数相加 A + B 将得到 30 - 从第一个操作数中减去第二个操作数 A - B 将得到 -10 * 把两个操作数相乘 A * B 将得到 200 / 分子除以分母 B / A 将得到 2 % 取模运算符，整除后的余数 B % A 将得到 0 ++ 自增运算符，整数值增加 1 A++ 将得到 11 -- 自减运算符，整数值减少 1 A-- 将得到 9 2. 关系运算符 下表显示了 C++ 支持的所有关系运算符。 假设变量 A 的值为 10，变量 B 的值为 20，则： 运算符 描述 实例 == 检查两个操作数的值是否相等，如果相等则条件为真。 (A == B) 不为真。 != 检查两个操作数的值是否相等，如果不相等则条件为真。 (A != B) 为真。 > 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (A > B) 不为真。 < 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (A < B) 为真。 >= 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 (A >= B) 不为真。 <= 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 (A <= B) 为真。 3. 逻辑运算符 下表显示了 C++ 支持的所有关系逻辑运算符。 假设变量 A 的值为 1，变量 B 的值为 0，则： 运算符 描述 实例 && 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 (A && B) 为假。 || 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (A || B) 为真。 ! 称为逻辑非运算符。用来逆转操作数的逻辑状态。 !(A && B) 为真。 4. 位运算符 位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示： p q p & q p | q p ^ q 0 0 0 0 0 0 1 0 1 1 1 1 1 1 0 1 0 0 1 1 假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示： A = 0011 1100 B = 0000 1101 A&B = 0000 1100 下表显示了 C++ 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则： 运算符 描述 实例 & 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 (A & B) 将得到 12，即为 0000 1100 | 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 (A | B) 将得到 61，即为 0011 1101 ^ 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 (A ^ B) 将得到 49，即为 0011 0001 ~ 二进制补码运算符是一元运算符，具有"翻转"位效果。 (~A ) 将得到 -61，即为 1100 0011，2 的补码形式，带符号的二进制数。 << 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 A << 2 将得到 240，即为 1111 0000 >> 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 A >> 2 将得到 15，即为 0000 1111 5. 赋值运算符 下表列出了 C++ 支持的赋值运算符： 运算符 描述 实例 = 简单的赋值运算符，把右边操作数的值赋给左边操作数 C = A + B 将把 A + B 的值赋给 C += 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 C += A 相当于 C = C + A -= 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 C -= A 相当于 C = C - A *= 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 C *= A 相当于 C = C * A /= 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 C /= A 相当于 C = C / A %= 求模且赋值运算符，求两个操作数的模赋值给左边操作数 C %= A 相当于 C = C % A <<= 左移且赋值运算符 C <<= 2 等同于 C = C << 2 >>= 右移且赋值运算符 C >>= 2 等同于 C = C >> 2 &= 按位与且赋值运算符 C &= 2 等同于 C = C & 2 ^= 按位异或且赋值运算符 C ^= 2 等同于 C = C ^ 2 |= 按位或且赋值运算符 C |= 2 等同于 C = C | 2 6. 杂项运算符 下表列出了 C++ 支持的其他一些重要的运算符。 运算符 描述 sizeof sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。 Condition ? X : Y 条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。 , 逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。 .（点）和 ->（箭头） 成员运算符用于引用类、结构和共用体的成员。 Cast 强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。 & 指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。 * 指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。 -> 指向结构体成员运算符，用处是使用一个指向结构体或对象的指针访问其内成员。
      • 运算符优先级
        • C++ 中的运算符优先级 运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。 例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。 下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。 类别 运算符 结合性 后缀 () [] -> . ++ - - 从左到右 一元 + - ! ~ ++ - - (type)* & sizeof 从右到左 乘除 * / % 从左到右 加减 + - 从左到右 移位 << >> 从左到右 关系 < <= > >= 从左到右 相等 == != 从左到右 位与 AND & 从左到右 位异或 XOR ^ 从左到右 位或 OR | 从左到右 逻辑与 AND && 从左到右 逻辑或 OR || 从左到右 条件 ?: 从右到左 赋值 = += -= *= /= %=>>= <<= &= ^= |= 从右到左 逗号 , 从左到右
    • 数学运算
      • C++ 数学运算 在 C++ 中，除了可以创建各种函数，还包含了各种有用的函数供您使用。这些函数写在标准 C 和 C++ 库中，叫做内置函数。您可以在程序中引用这些函数。C++ 内置了丰富的数学函数，可对各种数字进行运算。下表列出了 C++ 中一些有用的内置的数学函数。 为了利用这些函数，您需要引用数学头文件 <cmath>。 序号 函数 & 描述 1 double cos(double); 该函数返回弧度角（double 型）的余弦。 2 double sin(double); 该函数返回弧度角（double 型）的正弦。 3 double tan(double); 该函数返回弧度角（double 型）的正切。 4 double log(double); 该函数返回参数的自然对数。 5 double pow(double, double); 假设第一个参数为 x，第二个参数为 y，则该函数返回 x 的 y 次方。 6 double hypot(double, double); 该函数返回两个参数的平方总和的平方根，也就是说，参数为一个直角三角形的两个直角边，函数会返回斜边的长度。 7 double sqrt(double); 该函数返回参数的平方根。 8 int abs(int); 该函数返回整数的绝对值。 9 double fabs(double); 该函数返回任意一个十进制数的绝对值。 10 double floor(double); 该函数返回一个小于或等于传入参数的最大整数。 下面是一个关于数学运算的简单实例： #include <iostream> #include <cmath> using namespace std; int main () { // 数字定义 short s = 10; int i = -1000; long l = 100000; float f = 230.47; double d = 200.374; // 数学运算 cout << "sin(d) :" << sin(d) << endl; cout << "abs(i) :" << abs(i) << endl; cout << "floor(d) :" << floor(d) << endl; cout << "sqrt(f) :" << sqrt(f) << endl; cout << "pow( d, 2) :" << pow(d, 2) << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： sign(d) :-0.634939 abs(i) :1000 floor(d) :200 sqrt(f) :15.1812 pow( d, 2 ) :40149.7
      • 随机数
        • C++ 随机数 在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。 下面是一个关于生成随机数的简单实例。实例中使用了 time() 函数来获取系统时间的秒数，通过调用 rand() 函数来生成随机数： #include <iostream> #include <ctime> #include <cstdlib> using namespace std; int main () { int i,j; // 设置种子 srand( (unsigned)time( NULL ) ); /* 生成 10 个随机数 */ for( i = 0; i < 10; i++ ) { // 生成实际的随机数 j= rand(); cout <<"随机数： " << j << endl; } return 0; }
  • 流程控制
    • 输入输出
      • C++ 标准库提供了一组丰富的输入/输出功能。 C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。
      • I/O 库头文件
        • I/O 库头文件 下列的头文件在 C++ 编程中很重要。 头文件 函数和描述 <iostream> 该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。 <iomanip> 该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I/O 有用的服务。 <fstream> 该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。
        • <iostream>
          • 标准输入流（cin）
            • 标准输入流（cin） 预定义的对象 cin 是 istream 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。cin 是与流提取运算符 >> 结合使用的，如下所示： #include <iostream> using namespace std; int main( ) { char name[50]; cout << "请输入您的名称： "; cin >> name; cout << "您的名称是： " << name << endl; } 当上面的代码被编译和执行时，它会提示用户输入名称。当用户输入一个值，并按回车键，就会看到下列结果： 请输入您的名称： cplusplus 您的名称是： cplusplus C++ 编译器根据要输入值的数据类型，选择合适的流提取运算符来提取值，并把它存储在给定的变量中。 流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句： cin >> name >> age; 这相当于下面两个语句： cin >> name; cin >> age;
          • 标准输出流（cout）
            • 标准输出流（cout） 预定义的对象 cout 是 ostream 类的一个实例。cout 对象"连接"到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的，如下所示： #include <iostream> using namespace std; int main( ) { char str[] = "Hello C++"; cout << "Value of str is : " << str << endl; } 当上面的代码被编译和执行时，它会产生下列结果： Value of str is : Hello C++ C++ 编译器根据要输出变量的数据类型，选择合适的流插入运算符来显示值。<< 运算符被重载来输出内置类型（整型、浮点型、double 型、字符串和指针）的数据项。 流插入运算符 << 在一个语句中可以多次使用，如上面实例中所示，endl 用于在行末添加一个换行符。
          • 标准错误流（cerr）
            • 标准错误流（cerr） 预定义的对象 cerr 是 ostream 类的一个实例。cerr 对象附属到标准错误设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。 cerr 也是与流插入运算符 << 结合使用的，如下所示： #include <iostream> using namespace std; int main( ) { char str[] = "Unable to read...."; cerr << "Error message : " << str << endl; } 当上面的代码被编译和执行时，它会产生下列结果： Error message : Unable to read....
          • 标准日志流（clog）
            • 标准日志流（clog） 预定义的对象 clog 是 ostream 类的一个实例。clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区中，直到缓冲填满或者缓冲区刷新时才会输出。 clog 也是与流插入运算符 << 结合使用的，如下所示： #include <iostream> using namespace std; int main( ) { char str[] = "Unable to read...."; clog << "Error message : " << str << endl; } 当上面的代码被编译和执行时，它会产生下列结果： Error message : Unable to read....
    • 循环
      • 循环类型
        • while循环
          • C++ while 循环 只要给定的条件为真，while 循环语句会重复执行一个目标语句。 语法 C++ 中 while 循环的语法： while(condition) { statement(s); } 在这里，statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。当条件为假时，程序流将继续执行紧接着循环的下一条语句。 实例 #include <iostream> using namespace std; int main () { // 局部变量声明 int a = 10; // while 循环执行 while( a < 20 ) { cout << "a 的值：" << a << endl; a++; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： a 的值： 10 a 的值： 11 a 的值： 12 a 的值： 13 a 的值： 14 a 的值： 15 a 的值： 16 a 的值： 17 a 的值： 18 a 的值： 19
        • for循环
          • C++ for 循环 for 循环允许您编写一个执行特定次数的循环的重复控制结构。 语法 C++ 中 for 循环的语法： for ( init; condition; increment ) { statement(s); } 下面是 for 循环的控制流： init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。 接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。 在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。 条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。 实例 #include <iostream> using namespace std; int main () { // for 循环执行 for( int a = 10; a < 20; a = a + 1 ) { cout << "a 的值：" << a << endl; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： a 的值： 10 a 的值： 11 a 的值： 12 a 的值： 13 a 的值： 14 a 的值： 15 a 的值： 16 a 的值： 17 a 的值： 18 a 的值： 19
        • do while循环
          • C++ do…while 循环 不像 for 和 while 循环，它们是在循环头部测试循环条件。do...while 循环是在循环的尾部检查它的条件。 do...while 循环与 while 循环类似，但是 do...while 循环会确保至少执行一次循环。 语法 C++ 中 do...while 循环的语法： do { statement(s); }while( condition ); 请注意，条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。 如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。 实例 #include <iostream> using namespace std; int main () { // 局部变量声明 int a = 10; // do 循环执行 do { cout << "a 的值：" << a << endl; a = a + 1; }while( a < 20 ); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： a 的值： 10 a 的值： 11 a 的值： 12 a 的值： 13 a 的值： 14 a 的值： 15 a 的值： 16 a 的值： 17 a 的值： 18 a 的值： 19
        • 嵌套循环
          • 无限循环
            • 无限循环 如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。 #include <iostream> using namespace std; int main () { for( ; ; ) { printf("This loop will run forever.\n"); } return 0; } 当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，C++ 程序员偏向于使用 for(;;) 结构来表示一个无限循环。 注意：您可以按 Ctrl + C 键终止一个无限循环。
      • 循环控制语句
        • break：跳出当前循环
          • C++ 中 break 语句有以下两种用法： 当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。 它可用于终止 switch 语句中的一个 case。 如果您使用的是嵌套循环（即一个循环内嵌套另一个循环），break 语句会停止执行最内层的循环，然后开始执行该块之后的下一行代码。 语法 C++ 中 break 语句的语法： break;
        • continue：提前结束本次循环，直接继续执行下次循环
          • C++ 中的 continue 语句有点像 break 语句。但它不是强迫终止，continue 会跳过当前循环中的代码，强迫开始下一次循环。 对于 for 循环，continue 语句会导致执行条件测试和循环增量部分。对于 while 和 do...while 循环，continue 语句会导致程序控制回到条件测试上。 语法 C++ 中 continue 语句的语法： continue;
    • 判断
      • if判断
        • if
          • C++ if 语句 一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 语法 C++ 中 if 语句的语法： if(boolean_expression) { // 如果布尔表达式为真将执行的语句 } 如果布尔表达式为 true，则 if 语句内的代码块将被执行。如果布尔表达式为 false，则 if 语句结束后的第一组代码（闭括号后）将被执行。C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。 实例 #include <iostream> using namespace std; int main () { // 局部变量声明 int a = 10; // 使用 if 语句检查布尔条件 if( a < 20 ) { // 如果条件为真，则输出下面的语句 cout << "a 小于 20" << endl; } cout << "a 的值是 " << a << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： a 小于 20 a 的值是 10
        • if...else
          • C++ if...else 语句 一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。 语法 C++ 中 if...else 语句的语法： if(boolean_expression) { // 如果布尔表达式为真将执行的语句 } else { // 如果布尔表达式为假将执行的语句 } 如果布尔表达式为 true，则执行 if 块内的代码。如果布尔表达式为 false，则执行 else 块内的代码。 实例 #include <iostream> using namespace std; int main () { // 局部变量声明 int a = 100; // 检查布尔条件 if( a < 20 ) { // 如果条件为真，则输出下面的语句 cout << "a 小于 20" << endl; } else { // 如果条件为假，则输出下面的语句 cout << "a 大于 20" << endl; } cout << "a 的值是 " << a << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： a 大于 20 a 的值是 100
        • if...else if...else
          • if...else if...else 语句 一个 if 语句后可跟一个可选的 else if...else 语句，这可用于测试多种条件。 当使用 if...else if...else 语句时，以下几点需要注意： 一个 if 后可跟零个或一个 else，else 必须在所有 else if 之后。 一个 if 后可跟零个或多个 else if，else if 必须在 else 之前。 一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。 语法 C++ 中的 if...else if...else 语句的语法： if(boolean_expression 1) { // 当布尔表达式 1 为真时执行 } else if( boolean_expression 2) { // 当布尔表达式 2 为真时执行 } else if( boolean_expression 3) { // 当布尔表达式 3 为真时执行 } else { // 当上面条件都不为真时执行 } 实例 #include <iostream> using namespace std; int main () { // 局部变量声明 int a = 100; // 检查布尔条件 if( a == 10 ) { // 如果 if 条件为真，则输出下面的语句 cout << "a 的值是 10" << endl; } else if( a == 20 ) { // 如果 else if 条件为真，则输出下面的语句 cout << "a 的值是 20" << endl; } else if( a == 30 ) { // 如果 else if 条件为真，则输出下面的语句 cout << "a 的值是 30" << endl; } else { // 如果上面条件都不为真，则输出下面的语句 cout << "没有匹配的值" << endl; } cout << "a 的准确值是 " << a << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 没有匹配的值 a 的准确值是 100
      • switch判断
        • C++ switch 语句 一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。 语法 C++ 中 switch 语句的语法： switch(expression){ case constant-expression : statement(s); break; // 可选的 case constant-expression : statement(s); break; // 可选的 // 您可以有任意数量的 case 语句 default : // 可选的 statement(s); } switch 语句必须遵循下面的规则： switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。 case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。 不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。 一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。 实例 #include <iostream> using namespace std; int main () { // 局部变量声明 char grade = 'D'; switch(grade) { case 'A' : cout << "很棒！" << endl; break; case 'B' : case 'C' : cout << "做得好" << endl; break; case 'D' : cout << "您通过了" << endl; break; case 'F' : cout << "最好再试一下" << endl; break; default : cout << "无效的成绩" << endl; } cout << "您的成绩是 " << grade << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 您通过了 您的成绩是 D
      • 条件运算符 ? :
        • C++ 条件运算符 ? : Exp1 ? Exp2 : Exp3; 其中，Exp1、Exp2 和 Exp3 是表达式。请注意冒号的使用和位置。? : 表达式的值取决于 Exp1 的计算结果。如果 Exp1 为真，则计算 Exp2 的值，且 Exp2 的计算结果则为整个 ? : 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，且 Exp3 的计算结果则为整个 ? : 表达式的值。 ? 被称为三元运算符，因为它需要三个操作数，可以用来代替如下所示的 if-else 语句： if(condition){ var = X; }else{ var = Y; } 例如，请看下面这段代码： if(y < 10){ var = 30; }else{ var = 40; } 上面的代码可以写成以下语句： var = (y < 10) ? 30 : 40; 在这里，如果 y 小于 10，则 var 被赋值为 30，如果 y 不小于 10，则 var 被赋值为 40。请看下面的实例： #include <iostream> using namespace std; int main () { // 局部变量声明 int x, y = 10; x = (y < 10) ? 30 : 40; cout << "value of x: " << x << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： value of x: 40
      • 嵌套判断
  • 函数
    • 函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。 您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。 函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。 C++ 标准库提供了大量的程序可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。 函数还有很多叫法，比如方法、子例程或程序，等等。
    • 定义函数
      • 定义函数 C++ 中的函数定义的一般形式如下： return_type function_name( parameter list ) { body of the function } 在 C++ 中，函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分： 返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。 函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。 参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。 函数主体：函数主体包含一组定义函数执行任务的语句。 实例 以下是 max() 函数的源代码。该函数有两个参数 num1 和 num2，会返回这两个数中较大的那个数： // 函数返回两个数中较大的那个数 int max(int num1, int num2) { // 局部变量声明 int result; if (num1 > num2) result = num1; else result = num2; return result; }
    • 函数声明
      • 函数声明 函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。 函数声明包括以下几个部分： return_type function_name( parameter list ); 针对上面定义的函数 max()，以下是函数声明： int max(int num1, int num2); 在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明： int max(int, int); 当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。
    • 调用函数
      • 调用函数 创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。 当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。 调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如： #include <iostream> using namespace std; // 函数声明 int max(int num1, int num2); int main () { // 局部变量声明 int a = 100; int b = 200; int ret; // 调用函数来获取最大值 ret = max(a, b); cout << "Max value is : " << ret << endl; return 0; } // 函数返回两个数中较大的那个数 int max(int num1, int num2) { // 局部变量声明 int result; if (num1 > num2) result = num1; else result = num2; return result; } 把 max() 函数和 main() 函数放一块，编译源代码。当运行最后的可执行文件时，会产生下列结果： Max value is : 200
    • 函数参数
      • 参数分类
        • 形式参数
          • 形式参数：是在定义函数名和函数体的时候使用的参数，目的是用来接收调用该函数时传入的参数，简称“形参”。
        • 实际参数
          • 实际参数：在主调函数中调用一个函数时，函数名后面括号中的参数称为“实际参数”，简称“实参”。
      • 参数传递方式
        • 如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。 形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。 当调用函数时，有3种向函数传递参数的方式： 调用类型 描述 传值调用 该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。 指针调用 该方法把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 引用调用 引用就是实参的别名，引用的所有引用的操作直接等同于实参的操作。 默认情况下，C++ 使用传值调用来传递参数。
        • 值传递
          • 传值调用
            • C++ 传值调用 向函数传递参数的传值调用方法，把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。 默认情况下，C++ 使用传值调用方法来传递参数。一般来说，这意味着函数内的代码不会改变用于调用函数的实际参数。函数 swap() 定义如下： // 函数定义 void swap(int x, int y) { int temp; temp = x; /* 保存 x 的值 */ x = y; /* 把 y 赋值给 x */ y = temp; /* 把 x 赋值给 y */ return; } 现在，让我们通过传递实际参数来调用函数 swap()： #include <iostream> using namespace std; // 函数声明 void swap(int x, int y); int main () { // 局部变量声明 int a = 100; int b = 200; cout << "交换前，a 的值：" << a << endl; cout << "交换前，b 的值：" << b << endl; // 调用函数来交换值 swap(a, b); cout << "交换后，a 的值：" << a << endl; cout << "交换后，b 的值：" << b << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 交换前，a 的值： 100 交换前，b 的值： 200 交换后，a 的值： 100 交换后，b 的值： 200 上面的实例表明了，虽然在函数内改变了 a 和 b 的值，但是实际上 a 和 b 的值没有发生变化。
          • 指针调用
            • C++ 指针调用 向函数传递参数的指针调用方法，把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 按指针传递值，参数指针被传递给函数，就像传递其他值给函数一样。因此相应地，在下面的函数 swap() 中，您需要声明函数参数为指针类型，该函数用于交换参数所指向的两个整数变量的值。 // 函数定义 void swap(int *x, int *y) { int temp; temp = *x; /* 保存地址 x 的值 */ *x = *y; /* 把 y 赋值给 x */ *y = temp; /* 把 x 赋值给 y */ return; } 如需了解 C++ 中指针的更多细节，请访问 C++ 指针 章节。 现在，让我们通过指针传值来调用函数 swap()： #include <iostream> using namespace std; // 函数声明 void swap(int *x, int *y); int main () { // 局部变量声明 int a = 100; int b = 200; cout << "交换前，a 的值：" << a << endl; cout << "交换前，b 的值：" << b << endl; /* 调用函数来交换值 * &a 表示指向 a 的指针，即变量 a 的地址 * &b 表示指向 b 的指针，即变量 b 的地址 */ swap(&a, &b); cout << "交换后，a 的值：" << a << endl; cout << "交换后，b 的值：" << b << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 交换前，a 的值： 100 交换前，b 的值： 200 交换后，a 的值： 200 交换后，b 的值： 100
        • 引用调用
          • 当使用引用变量作为形参时，它将变为实参列表中相应变量的别名，对形参进行的任何更改都将真正更改正在调用它的函数中的变量。当以这种方式将数据传递给形参时，该实参被称为按引用传递。 引用变量的定义方法和常规变量类似，但是其数据类型和名称之间有一个 & 符号。例如，以下函数定义使形参 refVar 成为引用变量： void doubleNum(int& refVar) { refVar *= 2; } 注意，变量 refVar 被称为“对 int 的引用”。 该函数将 refVar 乘以 2，因为 refVar 是引用变量，所以该操作实际上将对作为实参传递给函数的变量执行。 ------- 引用调用-百度百科 引用调用（reference）是C++特有的概念，它是程序设计语言发展的产物。C++提供的引用应用于函数既满足使用时的简单方便，又保证执行的效率。C和C++的函数调用的主要区别是C++中使用了引用调用。 引用调用是函数传递参数的一种方式，使用引用调用，可以在子函数中对形参所做的更改对主函数中的实参有效。 引用可以看成是一种特殊类型的变量可以被认为是另一个变量的别名，就好比人的绰号一样，虽然名字不同， 但所指向的人是一样的，所以引用还与指针有类似的地方。 举例如下： int i,j; int &ri=i; //建立一个int型的引用ri，并将其初始化为变量i的一个别名 j=10; ri=j; //相当于i=j； 需要注意的是： 声明一个引用时，必须同时对它进行初始化，使它指向一个已经存在的对象。 一旦一个引用被初始化后，就不能改为指向其它对象（也就是说，一个引用从它诞生之时起，就必须确定是哪个变量的别名，而且始终只能作为这个变量的别名不能另作他用） 引用也可以作为形参，作为形参时候，情况稍有不同，这是因为，形参的初始化不在类型说明时候进行，而是在执行主调函数的调用表达式时 ，才为形参分配内存空间，同时用实参来初始化形参。这样引用类型的形参就通过形实结合，成为实参的一个别名，对形参的任何操作也就会直接作用于实参。
        • 引用与指针的区别与联系
          • 1. 概念 　　指针从本质上讲是一个变量，变量的值是另一个变量的地址，指针在逻辑上是独立的，它可以被改变的，包括指针变量的值（所指向的地址）和指针变量的值对应的内存中的数据（所指向地址中所存放的数据）。 　　引用从本质上讲是一个别名，是另一个变量的同义词，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化（先有这个变量，这个实物，这个实物才能有别名），而且其引用的对象在其整个生命周期中不能被改变，即自始至终只能依附于同一个变量（初始化的时候代表的是谁的别名，就一直是谁的别名，不能变）。 2. C++中的指针参数传递和引用参数传递 　　指针参数传递本质上是值传递，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，会在栈中开辟内存空间以存放由主调函数传递进来的实参值，从而形成了实参的一个副本（替身）。值传递的特点是，被调函数对形式参数的任何操作都是作为局部变量进行的，不会影响主调函数的实参变量的值（形参指针变了，实参指针不会变）。 　　引用参数传递过程中，被调函数的形式参数也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参（本体）的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量（根据别名找到主调函数中的本体）。因此，被调函数对形参的任何操作都会影响主调函数中的实参变量。 　　引用传递和指针传递是不同的，虽然他们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将应用不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量（地址），那就得使用指向指针的指针或者指针引用。 　　从编译的角度来讲，程序在编译时分别将指针和引用添加到符号表上，符号表中记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值（与实参名字不同，地址相同）。符号表生成之后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），而引用对象则不能修改。 3. 总结 相同点： 　　都是地址的概念 不同点： 　　指针是一个实体（替身）；引用只是一个别名（本体的另一个名字） 　　引用只能在定义时被初始化一次，之后不可改变，即“从一而终”；指针可以修改，即“见异思迁”； 　　引用不能为空（有本体，才有别名）；指针可以为空； 　　sizeof 引用，得到的是所指向变量的大小；sizeof 指针，得到的是指针的大小； 　　指针 ++，是指指针的地址自增；引用++是指所指变量自增； 　　引用是类型安全的，引用过程会进行类型检查；指针不会进行安全检查；
      • 默认参数
        • 当您定义一个函数，您可以为参数列表中后边的每一个参数指定默认值。当调用函数时，如果实际参数的值留空，则使用这个默认值。 这是通过在函数定义中使用赋值运算符来为参数赋值的。调用函数时，如果未传递参数的值，则会使用默认值，如果指定了值，则会忽略默认值，使用传递的值。请看下面的实例： #include <iostream> using namespace std; int sum(int a, int b=20) { int result; result = a + b; return (result); } int main () { // 局部变量声明 int a = 100; int b = 200; int result; // 调用函数来添加值 result = sum(a, b); cout << "Total value is :" << result << endl; // 再次调用函数 result = sum(a); cout << "Total value is :" << result << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Total value is :300 Total value is :120
  • 数组
    • C++ 数组 C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。
    • 一维数组
      • 初始化数组
        • 初始化数组 在 C++ 中，您可以逐个初始化数组，也可以使用一个初始化语句，如下所示： double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0}; 大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。 如果您省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果： double balance[] = {1000.0, 2.0, 3.4, 17.0, 50.0}; 您将创建一个数组，它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例： balance[4] = 50.0; 上述的语句把数组中第五个元素的值赋为 50.0。所有的数组都是以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。
      • 访问数组
        • 访问数组元素 数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。例如： double salary = balance[9]; 上面的语句将把数组中第 10 个元素的值赋给 salary 变量。
      • 声明数组
        • 声明数组 在 C++ 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示： type arrayName [ arraySize ]; 这叫做一维数组。arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C++ 数据类型。例如，要声明一个类型为 double 的包含 10 个元素的数组 balance，声明语句如下： double balance[10]; 现在 balance 是一个可用的数组，可以容纳 10 个类型为 double 的数字。
      • 传递数组给函数
        • C++ 传递数组给函数 C++ 不允许向函数传递一个完整的数组作为参数，但是，您可以通过指定不带索引的数组名来传递一个指向数组的指针。 如果您想要在函数中传递一个一维数组作为参数，您必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。同样地，您也可以传递一个多维数组作为形式参数。 形式参数是一个指针：void myFunction(int *param) 形式参数是一个已定义大小的数组：void myFunction(int param[10]) 形式参数是一个未定义大小的数组：void myFunction(int param[]) 就函数而言，数组的长度是无关紧要的，因为 C++ 不会对形式参数执行边界检查。
      • 从函数返回数组
        • C++ 从函数返回数组 C++ 不允许返回一个完整的数组作为函数的参数。但是，您可以通过指定不带索引的数组名来返回一个指向数组的指针。 如果您想要从函数返回一个一维数组，您必须声明一个返回指针的函数，如下：int * myFunction() 另外，C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。 现在，让我们来看下面的函数，它会生成 10 个随机数，并使用数组来返回它们，具体如下： #include <iostream> #include <ctime> using namespace std; // 要生成和返回随机数的函数 int * getRandom( ) { static int r[10]; // 设置种子 srand( (unsigned)time( NULL ) ); for (int i = 0; i < 10; ++i) { r[i] = rand(); cout << r[i] << endl; } return r; } // 要调用上面定义函数的主函数 int main () { // 一个指向整数的指针 int *p; p = getRandom(); for ( int i = 0; i < 10; i++ ) { cout << "*(p + " << i << ") : "; cout << *(p + i) << endl; } return 0; }
    • 多维数组
      • C++ 多维数组 C++ 支持多维数组。多维数组声明的一般形式如下： type name[size1][size2]...[sizeN]; 例如，下面的声明创建了一个三维 5 . 10 . 4 整型数组： int threedim[5][10][4];
      • 二维数组
        • 二维数组 多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。声明一个 x 行 y 列的二维整型数组，形式如下： type arrayName [ x ][ y ]; 其中，type 可以是任意有效的 C++ 数据类型，arrayName 是一个有效的 C++ 标识符。 初始化二维数组 多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。 int a[3][4] = { {0, 1, 2, 3} , /* 初始化索引号为 0 的行 */ {4, 5, 6, 7} , /* 初始化索引号为 1 的行 */ {8, 9, 10, 11} /* 初始化索引号为 2 的行 */ }; 内部嵌套的括号是可选的，下面的初始化与上面是等同的： int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11}; 访问二维数组元素 二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如： int val = a[2][3]; 上面的语句将获取数组中第 3 行第 4 个元素。您可以通过上面的示意图来进行验证。让我们来看看下面的程序，我们将使用嵌套循环来处理二维数组： #include <iostream> using namespace std; int main () { // 一个带有 5 行 2 列的数组 int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}}; // 输出数组中每个元素的值 for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 2; j++ ) { cout << "a[" << i << "][" << j << "]: "; cout << a[i][j]<< endl; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： a[0][0]: 0 a[0][1]: 0 a[1][0]: 1 a[1][1]: 2 a[2][0]: 2 a[2][1]: 4 a[3][0]: 3 a[3][1]: 6 a[4][0]: 4 a[4][1]: 8
        • 指向二维数组的指针（数组指针）
          • 若a是一个二维数组a[M][N]，p是一个指向二维数组的指针(*p)[M]，那么有如下结论： a+i == p+i a[i] == p[i] == *(a+i) == *(p+i) a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j) 结论的推导过程 二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例： int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解，a 的分布像一个矩阵： 0 1 2 3 4 5 6 7 8 9 10 11 但在内存中，a 的分布是一维线性的，整个数组占用一块连续的内存。二维数组是按行排列的，也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4) = 48 个字节。允许把一个二维数组分解成多个一维数组来处理。对于数组 a，它可以分解成三个一维数组，即 a[0]、a[1]、a[2]。每一个一维数组又包含了 4 个元素，例如 a[0] 包含 a[0][0]、a[0][1]、a[0][2]、a[0][3]。 为了更好的理解指针和二维数组的关系，我们先来定义一个指向 a 的指针变量 p： int (*p)[4] = a; 括号中的*表明 p 是一个指针，它指向一个数组，数组的类型为int [4]，这正是 a 所包含的每个一维数组的类型。 [ ]的优先级高于*，( )是必须要加的，如果写作int *p[4]，那么应该理解为int *(p[4])，p 就成了一个指针数组，而不是二维数组指针。 对指针进行加法（减法）运算时，它前进（后退）的步长与它指向的数据类型有关，p 指向的数据类型是int [4]，那么p+1就前进 4×4 = 16 个字节，p-1就后退 16 个字节，这正好是数组 a 所包含的每个一维数组的长度。也就是说，p+1会使得指针指向二维数组的下一行，p-1会使得指针指向数组的上一行。 数组名 a 在表达式中也会被转换为和 p 等价的指针！ 下面我们就来探索一下如何使用指针 p 来访问二维数组中的每个元素。按照上面的定义： 1) p指向数组 a 的开头，也即第 0 行；p+1前进一行，指向第 1 行。 2) *(p+1)表示取地址上的数据，也就是整个第 1 行数据。注意是一行数据，是多个数据，不是第 1 行中的第 0 个元素，下面的运行结果有力地证明了这一点： #include <stdio.h> int main(){ int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; int (*p)[4] = a; printf("%d\n", sizeof(*(p+1))); return 0; } 运行结果： 16 3) *(p+1)+1表示第 1 行第 1 个元素的地址。如何理解呢？ *(p+1)单独使用时表示的是第 1 行数据，放在表达式中会被转换为第 1 行数据的首地址，也就是第 1 行第 0 个元素的地址，因为使用整行数据没有实际的含义，编译器遇到这种情况都会转换为指向该行第 0 个元素的指针；就像一维数组的名字，在定义时或者和 sizeof、& 一起使用时才表示整个数组，出现在表达式中就会被转换为指向数组第 0 个元素的指针。 4) *(*(p+1)+1)表示第 1 行第 1 个元素的值。很明显，增加一个 * 表示取地址上的数据。 根据上面的结论，可以很容易推出以下的等价关系： a+i == p+i a[i] == p[i] == *(a+i) == *(p+i) a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j) 【实例】使用指针遍历二维数组 #include <stdio.h> int main(){ int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11}; int(*p)[4]; int i,j; p=a; for(i=0; i<3; i++){ for(j=0; j<4; j++) printf("%2d ",*(*(p+i)+j)); printf("\n"); } return 0; } 运行结果： 0 1 2 3 4 5 6 7 8 9 10 11
    • 杂项
      • arr、arr[0]、&arr[0]和&arr区别
        • int main() { int arr[10] = {0}; printf("数组元素首地址 ：%d\n",arr); //数组元素首地址 2293280 printf("数组首地址 ：%d\n",&arr); //数组首地址 2293280 printf("数组元素首地址+1 ：%d\n",arr+1); //数组元素首地址 2293284 printf("数组首地址+1 ：%d\n",&arr+1); //数组首地址 2293320 return 0; } arr、arr[0]、&arr[0]和&arr区别 arr：数组名，同时也表示数组第一个元素的首字节地址，是一个常量值。 arr[0]：数组一个元素，可以进行读写操作。 &arr[0]：等价于arr,是一个地址常量，只能作为右值。 &arr：数组首地址，其值与arr想等，但含义完全不同。&arr,是将整个数组作为一个新的数组类型，&arr就是这个类型对应内存空间的首地址。 所以，上述代码中，arr和&arr输出都为2293280，但是arr+1 输出为2293284，即在2293280基础上增加了4个字节（1×sizeof(int)）。&arr+1输出为2293320，在2293280基础上增加了40个字节（10×sizeof(int)）。
  • 字符串
    • C 风格字符串
      • C 风格的字符串起源于 C 语言，并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 '' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。 char greeting[] = "Hello"; 等价于 char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; C++ 中有大量的函数用来操作以 null 结尾的字符串： 序号 函数 目的 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 的第一次出现的位置。 #include <cstring> //需要引用<cstring>这个头文件
    • C++ 中的 String 类
      • C++ 中的 String 类 C++ 标准库提供了 string 类类型，支持上述所有的操作，另外还增加了其他更多的功能。我们将学习 C++ 标准库中的这个类，现在让我们先来看看下面这个实例： 现在您可能还无法透彻地理解这个实例，因为到目前为止我们还没有讨论类和对象。所以现在您可以只是粗略地看下这个实例，等理解了面向对象的概念之后再回头来理解这个实例。 #include <iostream> #include <string> using namespace std; int main () { string str1 = "Hello"; string str2 = "World"; string str3; int len ; // 复制 str1 到 str3 str3 = str1; cout << "str3 : " << str3 << endl; // 连接 str1 和 str2 str3 = str1 + str2; cout << "str1 + str2 : " << str3 << endl; // 连接后，str3 的总长度 len = str3.size(); cout << "str3.size() : " << len << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： str3 : Hello str1 + str2 : HelloWorld str3.size() : 10
  • 结构体
    • 定义
      • 定义结构 为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下： struct [structure tag] { member definition; member definition; ... member definition; } [one or more structure variables]; structure tag 是可选的，每个 member definition 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在结构定义的末尾，最后一个分号之前，您可以指定一个或多个结构变量，这是可选的。下面是声明 Book 结构的方式： struct Books { char title[50]; char author[50]; char subject[100]; int book_id; }book;
      • typedef 关键字
        • typedef 关键字 下面是一种更简单的定义结构的方式，您可以为创建的类型取一个"别名"。例如： typedef struct { char title[50]; char author[50]; char subject[100]; int book_id; }Books; 现在，您可以直接使用 Books 来定义 Books 类型的变量，而不需要使用 struct 关键字。下面是实例： Books Book1, Book2; 您可以使用 typedef 关键字来定义非结构类型，如下所示： typedef long int *pint32; pint32 x, y, z; x, y 和 z 都是指向长整型 long int 的指针。
    • 作用
      • C/C++ 数组允许定义可存储相同类型数据项的变量，但是结构是 C++ 中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。 结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性： Title Author Subject Book ID
    • 访问结构体成员
      • 成员访问运算符.
        • 访问结构成员 为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法： #include <iostream> #include <cstring> using namespace std; struct Books { char title[50]; char author[50]; char subject[100]; int book_id; }; int main( ) { struct Books Book1; // 声明 Book1，类型为 Book struct Books Book2; // 声明 Book2，类型为 Book // Book1 详述 strcpy( Book1.title, "Learn C++ Programming"); strcpy( Book1.author, "Chand Miyan"); strcpy( Book1.subject, "C++ Programming"); Book1.book_id = 6495407; // Book2 详述 strcpy( Book2.title, "Telecom Billing"); strcpy( Book2.author, "Yakit Singha"); strcpy( Book2.subject, "Telecom"); Book2.book_id = 6495700; // 输出 Book1 信息 cout << "Book 1 title : " << Book1.title <<endl; cout << "Book 1 author : " << Book1.author <<endl; cout << "Book 1 subject : " << Book1.subject <<endl; cout << "Book 1 id : " << Book1.book_id <<endl; // 输出 Book2 信息 cout << "Book 2 title : " << Book2.title <<endl; cout << "Book 2 author : " << Book2.author <<endl; cout << "Book 2 subject : " << Book2.subject <<endl; cout << "Book 2 id : " << Book2.book_id <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Book 1 title : Learn C++ Programming Book 1 author : Chand Miyan Book 1 subject : C++ Programming Book 1 id : 6495407 Book 2 title : Telecom Billing Book 2 author : Yakit Singha Book 2 subject : Telecom Book 2 id : 6495700
      • 指向结构的指针
        • 指向结构的指针 您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示： struct Books *struct_pointer; 现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示： struct_pointer = &Book1; 为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示： struct_pointer->title; #include <iostream> #include <cstring> using namespace std; void printBook( struct Books *book ); struct Books { char title[50]; char author[50]; char subject[100]; int book_id; }; int main( ) { struct Books Book1; // 声明 Book1，类型为 Book struct Books Book2; // 声明 Book2，类型为 Book */ // Book1 详述 strcpy( Book1.title, "Learn C++ Programming"); strcpy( Book1.author, "Chand Miyan"); strcpy( Book1.subject, "C++ Programming"); Book1.book_id = 6495407; // Book2 详述 strcpy( Book2.title, "Telecom Billing"); strcpy( Book2.author, "Yakit Singha"); strcpy( Book2.subject, "Telecom"); Book2.book_id = 6495700; // 通过传 Book1 的地址来输出 Book1 信息 printBook( &Book1 ); // 通过传 Book2 的地址来输出 Book2 信息 printBook( &Book2 ); return 0; } // 该函数以结构指针作为参数 void printBook( struct Books *book ) { cout << "Book title : " << book->title <<endl; cout << "Book author : " << book->author <<endl; cout << "Book subject : " << book->subject <<endl; cout << "Book id : " << book->book_id <<endl; } 当上面的代码被编译和执行时，它会产生下列结果： Book title : Learn C++ Programming Book author : Chand Miyan Book subject : C++ Programming Book id : 6495407 Book title : Telecom Billing Book author : Yakit Singha Book subject : Telecom Book id : 6495700
    • 结构作为函数参数
      • 结构作为函数参数 您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。您可以使用上面实例中的方式来访问结构变量： #include <iostream> #include <cstring> using namespace std; void printBook( struct Books book ); struct Books { char title[50]; char author[50]; char subject[100]; int book_id; }; int main( ) { struct Books Book1; // 声明 Book1，类型为 Book struct Books Book2; // 声明 Book2，类型为 Book // Book1 详述 strcpy( Book1.title, "Learn C++ Programming"); strcpy( Book1.author, "Chand Miyan"); strcpy( Book1.subject, "C++ Programming"); Book1.book_id = 6495407; // Book2 详述 strcpy( Book2.title, "Telecom Billing"); strcpy( Book2.author, "Yakit Singha"); strcpy( Book2.subject, "Telecom"); Book2.book_id = 6495700; // 输出 Book1 信息 printBook( Book1 ); // 输出 Book2 信息 printBook( Book2 ); return 0; } void printBook( struct Books book ) { cout << "Book title : " << book.title <<endl; cout << "Book author : " << book.author <<endl; cout << "Book subject : " << book.subject <<endl; cout << "Book id : " << book.book_id <<endl; } 当上面的代码被编译和执行时，它会产生下列结果： Book title : Learn C++ Programming Book author : Chand Miyan Book subject : C++ Programming Book id : 6495407 Book title : Telecom Billing Book author : Yakit Singha Book subject : Telecom Book id : 6495700
    • 杂项
      • 结构体与数组的区别
        • 结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型。第二，相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型（而结构体是），数组名称是常量指针，所以不可以做为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。
  • 指针
    • 指针是一种保存变量地址的变量。
    • 定义
      • 什么是指针？ 指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为： type *var-name; 在这里，type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明： int *ip; /* 一个整型的指针 */ double *dp; /* 一个 double 型的指针 */ float *fp; /* 一个浮点型的指针 */ char *ch /* 一个字符型的指针 */ 所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。
      • 声明初始化指针
        • 声明并初始化一个指针 指针其实就是一个变量，指针的声明方式与一般的变量声明方式没太大区别： int *p; // 声明一个 int 类型的指针 p char *p // 声明一个 char 类型的指针 p int *arr[10] // 声明一个指针数组，该数组有10个元素，其中每个元素都是一个指向 int 类型对象的指针 int (*arr)[10] // 声明一个数组指针，该指针指向一个 int 类型的一维数组 int **p; // 声明一个指针 p ，该指针指向一个 int 类型的指针 　　 指针的声明比普通变量的声明多了一个一元运算符 “*”。运算符 “*” 是间接寻址或者间接引用运算符。当它作用于指针时，将访问指针所指向的对象。在上述的声明中： p 是一个指针，保存着一个地址，该地址指向内存中的一个变量； *p 则会访问这个地址所指向的变量。 声明一个指针变量并不会自动分配任何内存。在对指针进行间接访问之前，指针必须进行初始化：或是使他指向现有的内存，或者给他动态分配内存，否则我们并不知道指针指向哪儿，这将是一个很严重的问题，稍后会讨论这个问题。初始化操作如下： /* 方法1：使指针指向现有的内存 */ int x = 1; int *p = &x;　　// 指针 p 被初始化，指向变量 x ，其中取地址符 & 用于产生操作数内存地址 /* 方法2：动态分配内存给指针 */ int *p; p = (int *)malloc(sizeof(int) * 10);　　　　// malloc 函数用于动态分配内存 free(p);　　　　// free 函数用于释放一块已经分配的内存，常与 malloc 函数一起使用，要使用这两个函数需要头文件 stdlib.h 指针的初始化实际上就是给指针一个合法的地址，让程序能够清楚地知道指针指向哪儿。 未初始化和非法的指针 　　 如果一个指针没有被初始化，那么程序就不知道它指向哪里。它可能指向一个非法地址，这时，程序会报错，在 Linux 上，错误类型是 Segmentation fault（core dumped），提醒我们段违例或内存错误。它也可能指向一个合法地址，实际上，这种情况更严重，你的程序或许能正常运行，但是这个没有被初始化的指针所指向的那个位置的值将会被修改，而你并无意去修改它。 NULL指针 　　NULL 指针是一个特殊的指针变量，表示不指向任何东西。可以通过给一个指针赋一个零值来生成一个 NULL 指针。 复制代码 #include "stdio.h" int main(){ int *p = NULL; printf("p的地址为%d\n",p); return 0; } /*************** * 程序输出： * p的地址为0 ***************/ 　　可以看到指针指向内存地址0。在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是为操作系统保留的。但是，内存地址 0 有一个特别重要的意义，它表明改指针不指向一个可访问的内存位置。
        • 间接值运算符*
          • *运算符被称为间接值或解除引用
        • 地址运算符&
    • 指针的运算
      • 算数运算：++、--、+、-
        • C++ 指针的算术运算 指针是一个用数值表示的地址。因此，您可以对指针执行算术运算。可以对指针进行四种算术运算：++、--、+、-。 假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，让我们对该指针执行下列的算术运算： ptr++ 在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 个字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。如果 ptr 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。 递增一个指针 我们喜欢在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，因为数组是一个常量指针。下面的程序递增变量指针，以便顺序访问数组中的每一个元素： #include <iostream> using namespace std; const int MAX = 3; int main () { int var[MAX] = {10, 100, 200}; int *ptr; // 指针中的数组地址 ptr = var; for (int i = 0; i < MAX; i++) { cout << "Address of var[" << i << "] = "; cout << ptr << endl; cout << "Value of var[" << i << "] = "; cout << *ptr << endl; // 移动到下一个位置 ptr++; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Address of var[0] = 0xbfa088b0 Value of var[0] = 10 Address of var[1] = 0xbfa088b4 Value of var[1] = 100 Address of var[2] = 0xbfa088b8 Value of var[2] = 200 递减一个指针 同样地，对指针进行递减运算，即把值减去其数据类型的字节数，如下所示： #include <iostream> using namespace std; const int MAX = 3; int main () { int var[MAX] = {10, 100, 200}; int *ptr; // 指针中最后一个元素的地址 ptr = &var[MAX-1]; for (int i = MAX; i > 0; i--) { cout << "Address of var[" << i << "] = "; cout << ptr << endl; cout << "Value of var[" << i << "] = "; cout << *ptr << endl; // 移动到下一个位置 ptr--; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Address of var[3] = 0xbfdb70f8 Value of var[3] = 200 Address of var[2] = 0xbfdb70f4 Value of var[2] = 100 Address of var[1] = 0xbfdb70f0 Value of var[1] = 10
      • 关系运算
        • 指针的比较 指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。 下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX - 1]，则把变量指针进行递增： #include <iostream> using namespace std; const int MAX = 3; int main () { int var[MAX] = {10, 100, 200}; int *ptr; // 指针中第一个元素的地址 ptr = var; int i = 0; while ( ptr <= &var[MAX - 1] ) { cout << "Address of var[" << i << "] = "; cout << ptr << endl; cout << "Value of var[" << i << "] = "; cout << *ptr << endl; // 指向上一个位置 ptr++; i++; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Address of var[0] = 0xbfce42d0 Value of var[0] = 10 Address of var[1] = 0xbfce42d4 Value of var[1] = 100 Address of var[2] = 0xbfce42d8 Value of var[2] = 200
    • 指针的应用
      • 指针与数组
        • 通过指针理解数组的取值操作符[]
          • #include <iostream> using namespace std; // 通过指针理解数组的取值操作符[] int main() { int a[3][4] = { {1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12} }; // 定义并初始化一个3行4列的二维数组a int(*p)[4]; // 定义一个指向含有四个int元素的数组的指针p （数组指针） p = a; // 赋值，将二维数组a的首地址赋值给指针p cout << p + 1 << endl; // p + 1是指针，指向下一行含有四个int元素的数组 cout << *(p + 1) << endl; // *(p + 1)是数组，取出p指向下一行含有四个int元素的数组 cout << &*(*(p + 1) + 0) << endl; // &*(*(p + 1) + 0)是数组元素的地址， 先取出p指向下一行含有四个int元素的数组的第0个元素，再取其地址 cout << *(*(p + 1) + 0) << endl; // *(*(p + 1) + 0)是数组元素的值 cout << &a[1] << endl; // 等价于 p + 1 cout << a[1] << endl;// 等价于 *(p + 1) cout << &a[1][0] << endl; // 等价于 &*(*(p + 1) + 0) cout << a[1][0] << endl; // 等价于 *(*(p + 1) + 0) //总结 /* a[M] == *(p + M) a[M][N] == *(*(p + M) + N) */ return 0; }
        • 指针数组和二维数组指针的区别
          • 指针数组与数组指针区别 指针数组和二维数组指针在定义时非常相似，只是括号的位置不同： int *(p1[5]); //指针数组，可以去掉括号直接写作 int *p1[5]; int (*p2)[5]; //二维数组指针，不能去掉括号 指针数组和二维数组指针有着本质上的区别：指针数组是一个数组，只是每个元素保存的都是指针，以上面的 p1 为例，在32位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针，它指向一个二维数组，以上面的 p2 为例，它占用 4 个字节的内存。 指针数组 指针是一个变量，而数组是用于存储变量的容器，因此，指针也可以像其他变量一样存储在数组中，也就是指针数组。 指针数组是一个数组，数组中的每一个元素都是指针。声明一个指针数组的方法如下： int *p[10]; // 声明一个指针数组，该数组有10个元素，其中每个元素都是一个指向int类型的指针 　　 在上述声明中，由于 [] 的优先级比 * 高，故 p 先与 [] 结合，成为一个数组 p[]；再由 int * 指明这是一个 int 类型的指针数组，数组中的元素都是 int 类型的指针。数组的第 i 个元素是 *p[i]，而 p[i] 是一个指针。由于指针数组中存放着多个指针，操作灵活，在一些需要操作大量数据的程序中使用，可以使程序更灵活快速。 数组指针 数组指针是一个指针，它指向一个数组。声明一个数组指针的方法如下： int (*p)[10]; // 声明一个数组指针 p ，该指针指向一个数组 由于 () 的优先级最高，所以 p 是一个指针，指向一个 int 类型的一维数组，这个一维数组的长度是 10，这也是指针 p 的步长。也就是说，执行 p+1 时，p 要跨过 n 个 int 型数据的长度。数组指针与二维数组联系密切，可以用数组指针来指向一个二维数组，如下： #include "stdio.h" int main(){ int arr[2][3] = {1,2,3,4,5,6}; // 定义一个二维数组并初始化 int (*p)[3]; // 定义一个数组指针，指针指向一个含有3个元素的一维数组 p = arr; // 将二维数组的首地址赋给 p，此时 p 指向 arr[0] 或 &arr[0][0] printf("%d\n",(*p)[0]);　　　　　　　　　　　　 // 输出结果为 1 p++;　　　　　　　　　　　　　　　　　　　　　　　　 // 对 p 进行算术运算，此时 p 将指向二维数组的下一行的首地址，即 &arr[1][0] printf("%d\n",(*p)[1]); // 输出结果为5 return 0; }
      • 指针与结构
        • 结构 结构是一个或多个变量的集合，这些变量可能为不同的类型，为了处理的方便而将这些变量组织在一个名字之下。由于结构将一组相关的变量看做一个单元而不是各自独立的实体，因此结构有助于组织复杂的数据，特别是在大型的程序中。 访问结构体的成员的方法 使用 结构名.成员 的方式来访问结构中的成员 使用指向结构体对象的指针->的方式来访问结构中的成员 例子 #include <iostream> using namespace std; typedef struct { char name[10]; int age; int score; }message; int main() { message mess = { "tongye",23,83 }; message* p = &mess; cout << p->name << "\t" << mess.name << endl; cout << p->age << "\t" << mess.age << endl; return 0; }
        • 直接成员访问操作符.
        • 间接成员访问操作符->
      • 指针与函数
        • 指针作为函数的参数
          • 指针作为函数的参数 传值调用的好处是是被调函数不会改变调用函数传过来的值，可以放心修改。但是有时候需要被调函数回传一个值给调用函数，这样的话，传值调用就无法做到。为了解决这个问题，可以使用传指针调用。指针参数使得被调函数能够访问和修改主调函数中对象的值。用一个例子来说明： #include "stdio.h" void swap1(int a,int b)　　　　　　 // 参数为普通的 int 变量 { 　　int temp; 　　temp = a; 　　a = b; 　　b = temp; } void swap2(int *a,int *b)　　　　　　// 参数为指针，接受调用函数传递过来的变量地址作为参数，对所指地址处的内容进行操作 { 　　int temp;　　　　 // 最终结果是，地址本身并没有改变，但是这一地址所对应的内存段中的内容发生了变化，即x,y的值发生了变化 　　temp = *a; 　　*a = *b; 　　*b = temp; } int main() { 　　int x = 1,y = 2; 　　swap1(x,y); // 将 x,y 的值本身作为参数传递给了被调函数 　　printf("%d %5d\n",x,y); // 输出结果为：1 2 　　swap(&x,&y); // 将 x,y 的地址作为参数传递给了被调函数，传递过去的也是一个值，与传值调用不冲突 　　printf("%d %5d\n",x,y); // 输出结果为：2 1 　　return 0; }
        • 指向函数的指针
          • 指向函数的指针 在C语言中，函数本身不是变量，但是可以定义指向函数的指针，也称作函数指针，函数指针指向函数的入口地址。这种类型的指针可以被赋值、存放在数组中、传递给函数以及作为函数的返回值等等。 声明一个函数指针的方法如下： 返回值类型 （* 指针变量名）（[形参列表]）; int (*pointer)(int *,int *); // 声明一个函数指针 　　 上述代码声明了一个函数指针 pointer ，该指针指向一个函数，函数具有两个 int * 类型的参数，且返回值类型为 int。下面的代码演示了函数指针的用法： #include "stdio.h" #include "string.h" int str_comp(const char *m,const char *n); // 声明一个函数 str_comp，该函数有两个 const char 类型的指针，函数的返回值为 int 类型 void comp(char *a,char *b,int (*prr)(const char *,const char*)); // 声明一个函数 comp ,注意该函数的第三个参数，是一个函数指针 int main() { char str1[20]; // 声明一个字符数组 char str2[20]; int (*p)(const char *,const char *) = str_comp;　　　　　　　　　　　 // 声明并初始化一个函数指针，该指针所指向的函数有两个 const char 类型的指针，且返回值为 int 类型 gets(str1); // 使用 gets() 函数从 I/O 读取一行字符串 gets(str2); comp(str1,str2,p); // 函数指针 p 作为参数传给 comp 函数 return 0; } int str_comp(const char *m,const char *n) { 　　 // 库函数 strcmp 用于比较两个字符串，其原型是： int strcmp(const char *s1,const char *s2); if(strcmp(m,n) == 0) return 0; else return 1; } /* 函数 comp 接受一个函数指针作为它的第三个参数 */ void comp(char *a,char *b,int (*prr)(const char *,const char*)) { if((*prr)(a,b) == 0) printf("str1 = str2\n"); else printf("str1 != str2\n"); } 这段代码的功能是从键盘读取两行字符串（长度不超过20），判断二者是否相等。 注意，声明一个函数指针时，() 不能漏掉，否则： int *p(void *,void*); 这表明 p 是一个函数，该函数返回一个指向 int 类型的指针。
      • 指针与类
    • 杂项
      • C语言--指针详解
  • 引用
    • 引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。 变量是可以保存数据的内存位置的名称。当使用变量时，实际上就是访问存储在分配给它的内存位置的数据。引用变量是变量的另一个别名，它没有自己的存储数据的内存位置，它访问的是另一个变量的内存位置。对引用变量作出的任何更改，实际上都是对它所引用的变量内存位置中存储数据的更改。 当使用引用变量作为形参时，它将变为实参列表中相应变量的别名，对形参进行的任何更改都将真正更改正在调用它的函数中的变量。当以这种方式将数据传递给形参时，该实参被称为按引用传递。
    • 定义
      • 引用简介 引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。 引用的声明方法：类型标识符 &引用名=目标变量名； 【例1】： int a; int &ra=a; //定义引用ra，它是变量a的引用，即别名 说明： （1）&在此不是求地址运算，而是起标识作用。 （2）类型标识符是指目标变量的类型。 （3）声明引用时，必须同时对其进行初始化。 （4）引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。 （5）声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。故：对引用求地址，就是对目标变量求地址。&ra与&a相等。 也可以这么的解释，所谓的引用（Reference），就是给对象取一个别名，使用该别名的时候可以取该对象。换句话说，是使新对象和原对象公用一个地址。这样，无论对哪个对象进行修改，其实都是对同一个地址的内容进行修改，因而原对象和新对象（规范的说，是对象和它的引用）总的来说具有相同的值。
    • 引用的应用
      • 把引用作为参数
        • C++ 把引用作为参数 下面的实例使用了引用来实现引用调用函数。 #include <iostream> using namespace std; // 函数声明 void swap(int& x, int& y); int main () { // 局部变量声明 int a = 100; int b = 200; cout << "交换前，a 的值：" << a << endl; cout << "交换前，b 的值：" << b << endl; /* 调用函数来交换值 */ swap(a, b); cout << "交换后，a 的值：" << a << endl; cout << "交换前，b 的值：" << b << endl; return 0; } // 函数定义 void swap(int& x, int& y) { int temp; temp = x; /* 保存地址 x 的值 */ x = y; /* 把 y 赋值给 x */ y = temp; /* 把 x 赋值给 y */ return; } 当上面的代码被编译和执行时，它会产生下列结果： 交换前，a 的值： 100 交换前，b 的值： 200 交换后，a 的值： 200 交换后，b 的值： 100
      • 把引用作为返回值
        • C++ 把引用作为返回值 通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似。 当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。例如，请看下面这个简单的程序： #include <iostream> #include <ctime> using namespace std; double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0}; double& setValues( int i ) { return vals[i]; // 返回第 i 个元素的引用 } // 要调用上面定义函数的主函数 int main () { cout << "改变前的值" << endl; for ( int i = 0; i < 5; i++ ) { cout << "vals[" << i << "] = "; cout << vals[i] << endl; } setValues(1) = 20.23; // 改变第 2 个元素 setValues(3) = 70.8; // 改变第 4 个元素 cout << "改变后的值" << endl; for ( int i = 0; i < 5; i++ ) { cout << "vals[" << i << "] = "; cout << vals[i] << endl; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 改变前的值 vals[0] = 10.1 vals[1] = 12.6 vals[2] = 33.1 vals[3] = 24.1 vals[4] = 50 改变后的值 vals[0] = 10.1 vals[1] = 20.23 vals[2] = 33.1 vals[3] = 70.8 vals[4] = 50 当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。 int& func() { int q; //! return q; // 在编译时发生错误 static int x; return x; // 安全，x 在函数作用域外依然是有效的 }
    • 杂项
      • 引用与指针的区别
        • 引用 vs 指针 引用很容易与指针混淆，它们之间有三个主要的不同： 不存在空引用。引用必须连接到一块合法的内存。 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。 引用必须在创建时被初始化。指针可以在任何时间被初始化。
  • 存储类
    • 作用：存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。
    • 存储类种类：auto、register、static、extern、mutable关键字
      • 1. auto 存储类 auto 存储类是所有局部变量默认的存储类。 { int mount; auto int month; } 上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。 2. register 存储类 register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。 { register int miles; } 寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。 3. static 存储类 static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。 static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。 在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。 #include <iostream> // 函数声明 void func(void); static int count = 10; /* 全局变量 */ int main() { while(count--) { func(); } return 0; } // 函数定义 void func( void ) { static int i = 5; // 局部静态变量 i++; std::cout << "变量 i 为 " << i ; std::cout << " , 变量 count 为 " << count << std::endl; } 当上面的代码被编译和执行时，它会产生下列结果： 变量 i 为 6 , 变量 count 为 9 变量 i 为 7 , 变量 count 为 8 变量 i 为 8 , 变量 count 为 7 变量 i 为 9 , 变量 count 为 6 变量 i 为 10 , 变量 count 为 5 变量 i 为 11 , 变量 count 为 4 变量 i 为 12 , 变量 count 为 3 变量 i 为 13 , 变量 count 为 2 变量 i 为 14 , 变量 count 为 1 变量 i 为 15 , 变量 count 为 0 4. extern 存储类 extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。 当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。 extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示： 第一个文件：main.cpp #include <iostream> int count ; extern void write_extern(); main() { count = 5; write_extern(); } 第二个文件：support.cpp #include <iostream> extern int count; void write_extern(void) { std::cout << "Count is " << count << std::endl; } 在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。现在 ，编译这两个文件，如下所示： $g++ main.cpp support.cpp -o write 这会产生 write 可执行程序，尝试执行 write，它会产生下列结果： $ ./write Count is 5 5. mutable 存储类 mutable 说明符仅适用于类的对象，它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。
• 面相对象
  • 定义
    • 面向对象(Object Oriented)是软件开发方法。 面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。 面向对象具有三大特点（封装，继承，多态）缺一不可。
    • 基本概念
      • 对象的含义是指具体的某一个事物，即在现实生活中能够看得见摸得着的事物。在面向对象程序设计中，对象所指的是计算机系统中的某一个成分。在面向对象程序设计中，对象包含两个含义，其中一个是数据，另外一个是动作。对象则是数据和动作的结合体。对象不仅能够进行操作，同时还能够及时记录下操作结果。 方法是指对象能够进行的操作，方法同时还有另外一个名称，叫做函数。方法是类中的定义函数，其具体的作用就是对对象进行描述操作。 继承简单地说就是一种层次模型，这种层次模型能够被重用。层次结构的上层具有通用性，但是下层结构则具有特殊性。在继承的过程中类则可以从最顶层的部分继承一些方法和变量。类除了可以继承以外同时还能够进行修改或者添加。通过这样的方式能够有效提高工作效率。在这里举一个例子，当类X继承了类Y后，此时的类X则是一个派生类，而类Y属于一个基类。继承是从一般演绎到特殊的过程，可以减少知识表示的冗余内容，知识库的维护和修正都非常方便。更有利于衍生复杂的系统。 类是具有相同特性（数据元素）和行为（功能）的对象的抽象。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。 类映射的每一个对象都具有这些数据和操作方法，类的继承具有层次性和结构性，高层次对象封装复杂行为，具体细节对该层次知识保持透明，可以减小问题求解的复杂度。 封装是将数据和代码捆绑到一起，对象的某些数据和代码可以是私有的，不能被外界访问，以此实现对数据和代码不同级别的访问权限。防止了程序相互依赖性而带来的变动影响，面向对象的封装比传统语言的封装更为清晰、更为有力。有效实现了两个目标：对数据和行为的包装和信息隐藏。 多态是指不同事物具有不同表现形式的能力。多态机制使具有不同内部结构的对象可以共享相同的外部接口，通过这种方式减少代码的复杂度。一个接口，多种方式。 动态绑定指的是将一个过程调用与相应代码链接起来的行为。动态绑定是指与给定的过程调用相关联的代码只有在运行期才可知的一种绑定，它是多态实现的具体形式。 消息传递：对象之间需要相互沟通，沟通的途径就是对象之间收发信息。消息内容包括接收消息的对象的标识，需要调用的函数的标识，以及必要的信息。消息传递的概念使得对现实世界的描述更容易。 面向对象的方法就是利用抽象、封装等机制，借助于对象、类、继承、消息传递等概念进行软件系统构造的软件开发方法。
    • 开发方法：统一建模语言UML
      • 统一建模语言(Unified Modeling Language，UML)是一种为面向对象系统的产品进行说明、可视化和编制文档的一种标准语言，是非专利的第三代建模和规约语言。UML使用面向对象设计的建模工具，但独立于任何具体程序设计语言。
    • 易混概念
      • “面向对象”和“基于对象”
        • 面向对象的三大特点（封装，继承，多态）缺一不可。通常“基于对象”是使用对象，但是无法利用现有的对象模板产生新的对象类型，继而产生新的对象，也就是说“基于对象”没有继承的特点。而“多态”表示为父类类型的子类对象实例，没有了继承的概念也就无从谈论“多态”。很多流行技术都是基于对象的，它们使用一些封装好的对象，调用对象的方法，设置对象的属性。但是它们无法让程序员派生新对象类型。他们只能使用现有对象的方法和属性。所以当你判断一个新的技术是否是面向对象的时候，通常可以使用后两个特性来加以判断。“面向对象”和“基于对象”都实现了“封装”的概念，但是面向对象实现了“继承和多态”，而“基于对象”没有实现这些，的确很饶口。
      • “面向过程”和“面向对象”
        • 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。 可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。 如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。 可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。
  • 类与对象
    • 定义
      • C++ 类 & 对象 C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。 C++ 类定义 定义一个类，本质上是定义一个数据类型的蓝图。它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。 类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如，我们使用关键字 class 定义 Box 数据类型，如下所示： class Box { public: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box }; 关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。您也可以指定类的成员为 private 或 protected，这个我们稍后会进行讲解。 定义 C++ 对象 类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象： Box Box1; // 声明 Box1，类型为 Box Box Box2; // 声明 Box2，类型为 Box 对象 Box1 和 Box2 都有它们各自的数据成员。 访问数据成员 类的对象的公共数据成员可以使用直接成员访问运算符 (.) 来访问。为了更好地理解这些概念，让我们尝试一下下面的实例： #include <iostream> using namespace std; class Box { public: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; int main( ) { Box Box1; // 声明 Box1，类型为 Box Box Box2; // 声明 Box2，类型为 Box double volume = 0.0; // 用于存储体积 // box 1 详述 Box1.height = 5.0; Box1.length = 6.0; Box1.breadth = 7.0; // box 2 详述 Box2.height = 10.0; Box2.length = 12.0; Box2.breadth = 13.0; // box 1 的体积 volume = Box1.height * Box1.length * Box1.breadth; cout << "Box1 的体积：" << volume <<endl; // box 2 的体积 volume = Box2.height * Box2.length * Box2.breadth; cout << "Box2 的体积：" << volume <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Box1 的体积：210 Box2 的体积：1560 需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。
      • 成员运算符
        • 点运算符.
        • 箭头运算符->
          • 指向类的指针
            • C++ 中指向类的指针 一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。与所有的指针一样，您必须在使用指针之前，对指针进行初始化。 下面的实例有助于更好地理解指向类的指针的概念： #include <iostream> using namespace std; class Box { public: // 构造函数定义 Box(double l=2.0, double b=2.0, double h=2.0) { cout <<"Constructor called." << endl; length = l; breadth = b; height = h; } double Volume() { return length * breadth * height; } private: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box }; int main(void) { Box Box1(3.3, 1.2, 1.5); // Declare box1 Box Box2(8.5, 6.0, 2.0); // Declare box2 Box *ptrBox; // Declare pointer to a class. // 保存第一个对象的地址 ptrBox = &Box1; // 现在尝试使用成员访问运算符来访问成员 cout << "Volume of Box1: " << ptrBox->Volume() << endl; // 保存第二个对象的地址 ptrBox = &Box2; // 现在尝试使用成员访问运算符来访问成员 cout << "Volume of Box2: " << ptrBox->Volume() << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Constructor called. Constructor called. Volume of Box1: 5.94 Volume of Box2: 102
          • this指针
            • C++ 中的 this 指针 在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。友元函数没有 this 指针，因为友元不是类的成员。只有成员函数才有 this 指针。 下面的实例有助于更好地理解 this 指针的概念： #include <iostream> using namespace std; class Box { public: // 构造函数定义 Box(double l=2.0, double b=2.0, double h=2.0) { cout <<"Constructor called." << endl; length = l; breadth = b; height = h; } double Volume() { return length * breadth * height; } int compare(Box box) { return this->Volume() > box.Volume(); } private: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box }; int main(void) { Box Box1(3.3, 1.2, 1.5); // Declare box1 Box Box2(8.5, 6.0, 2.0); // Declare box2 if(Box1.compare(Box2)) { cout << "Box2 is smaller than Box1" <<endl; } else { cout << "Box2 is equal to or larger than Box1" <<endl; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Constructor called. Constructor called. Box2 is equal to or larger than Box1
    • 类成员函数
      • C++ 类成员函数 类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。 让我们看看之前定义的类 Box，现在我们要使用成员函数来访问类的成员，而不是直接访问这些类的成员： class Box { public: double length; // 长度 double breadth; // 宽度 double height; // 高度 double getVolume(void);// 返回体积 }; 成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。所以您可以按照如下方式定义 Volume() 函数： class Box { public: double length; // 长度 double breadth; // 宽度 double height; // 高度 double getVolume(void) { return length * breadth * height; } }; 您也可以在类的外部使用范围解析运算符 :: 定义该函数，如下所示： double Box::getVolume(void) { return length * breadth * height; } 在这里，需要强调一点，在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据，如下所示： Box myBox; // 创建一个对象 myBox.getVolume(); // 调用该对象的成员函数 让我们使用上面提到的概念来设置和获取类中不同的成员的值： #include <iostream> using namespace std; class Box { public: double length; // 长度 double breadth; // 宽度 double height; // 高度 // 成员函数声明 double getVolume(void); void setLength( double len ); void setBreadth( double bre ); void setHeight( double hei ); }; // 成员函数定义 double Box::getVolume(void) { return length * breadth * height; } void Box::setLength( double len ) { length = len; } void Box::setBreadth( double bre ) { breadth = bre; } void Box::setHeight( double hei ) { height = hei; } // 程序的主函数 int main( ) { Box Box1; // 声明 Box1，类型为 Box Box Box2; // 声明 Box2，类型为 Box double volume = 0.0; // 用于存储体积 // box 1 详述 Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0); // box 2 详述 Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0); // box 1 的体积 volume = Box1.getVolume(); cout << "Box1 的体积：" << volume <<endl; // box 2 的体积 volume = Box2.getVolume(); cout << "Box2 的体积：" << volume <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Box1 的体积： 210 Box2 的体积： 1560
      • 范围解析运算符 ::
    • 访问修饰符：public、private、protected
      • C++ 类访问修饰符 数据隐藏是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问说明符。 一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。 class Base { public: // public members go here protected: // protected members go here private: // private members go here }; 公有（public）成员 公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值，如下所示： #include <iostream> using namespace std; class Line { public: double length; void setLength( double len ); double getLength( void ); }; // 成员函数定义 double Line::getLength(void) { return length ; } void Line::setLength( double len ) { length = len; } // 程序的主函数 int main( ) { Line line; // 设置长度 line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl; // 不使用成员函数设置长度 line.length = 10.0; // OK: 因为 length 是公有的 cout << "Length of line : " << line.length <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Length of line : 6 Length of line : 10 私有（private）成员 私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。 默认情况下，类的所有成员都是私有的。例如在下面的类中，width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，类的成员将被假定为私有成员： class Box { double width; public: double length; void setWidth( double wid ); double getWidth( void ); }; 实际操作中，我们一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数，如下所示： #include <iostream> using namespace std; class Box { public: double length; void setWidth( double wid ); double getWidth( void ); private: double width; }; // 成员函数定义 double Box::getWidth(void) { return width ; } void Box::setWidth( double wid ) { width = wid; } // 程序的主函数 int main( ) { Box box; // 不使用成员函数设置长度 box.length = 10.0; // OK: 因为 length 是公有的 cout << "Length of box : " << box.length <<endl; // 不使用成员函数设置宽度 // box.width = 10.0; // Error: 因为 width 是私有的 box.setWidth(10.0); // 使用成员函数设置宽度 cout << "Width of box : " << box.getWidth() <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Length of box : 10 Width of box : 10 保护（protected）成员 保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。 现在您可以看到下面的实例中，我们从父类 Box 派生了一个子类 smallBox。 下面的实例与前面的实例类似，在这里 width 成员可被派生类 smallBox 的任何成员函数访问。 #include <iostream> using namespace std; class Box { protected: double width; }; class SmallBox:Box // SmallBox 是派生类 { public: void setSmallWidth( double wid ); double getSmallWidth( void ); }; // 子类的成员函数 double SmallBox::getSmallWidth(void) { return width ; } void SmallBox::setSmallWidth( double wid ) { width = wid; } // 程序的主函数 int main( ) { SmallBox box; // 使用成员函数设置宽度 box.setSmallWidth(5.0); cout << "Width of box : "<< box.getSmallWidth() << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Width of box : 5
    • 构造函数与析构函数
      • C++ 类构造函数 & 析构函数 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。 构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。 下面的实例有助于更好地理解构造函数的概念： #include <iostream> using namespace std; class Line { public: void setLength( double len ); double getLength( void ); Line(); // 这是构造函数 private: double length; }; // 成员函数定义，包括构造函数 Line::Line(void) { cout << "Object is being created" << endl; } void Line::setLength( double len ) { length = len; } double Line::getLength( void ) { return length; } // 程序的主函数 int main( ) { Line line; // 设置长度 line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Object is being created Length of line : 6 带参数的构造函数 默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示： #include <iostream> using namespace std; class Line { public: void setLength( double len ); double getLength( void ); Line(double len); // 这是构造函数 private: double length; }; // 成员函数定义，包括构造函数 Line::Line( double len) { cout << "Object is being created, length = " << len << endl; length = len; } void Line::setLength( double len ) { length = len; } double Line::getLength( void ) { return length; } // 程序的主函数 int main( ) { Line line(10.0); // 获取默认设置的长度 cout << "Length of line : " << line.getLength() <<endl; // 再次设置长度 line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Object is being created, length = 10 Length of line : 10 Length of line : 6 使用初始化列表来初始化字段 Line::Line( double len): length(len) { cout << "Object is being created, length = " << len << endl; } 上面的语法等同于如下语法： Line::Line( double len) { cout << "Object is being created, length = " << len << endl; length = len; } 假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示： C::C( double a, double b, double c): X(a), Y(b), Z(c) { .... } 类的析构函数 类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。 析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。 下面的实例有助于更好地理解析构函数的概念： #include <iostream> using namespace std; class Line { public: void setLength( double len ); double getLength( void ); Line(); // 这是构造函数声明 ~Line(); // 这是析构函数声明 private: double length; }; // 成员函数定义，包括构造函数 Line::Line(void) { cout << "Object is being created" << endl; } Line::~Line(void) { cout << "Object is being deleted" << endl; } void Line::setLength( double len ) { length = len; } double Line::getLength( void ) { return length; } // 程序的主函数 int main( ) { Line line; // 设置长度 line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Object is being created Length of line : 6 Object is being deleted
      • 构造函数初始化列表
        • C++ 构造函数初始化列表 构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。例如： 复制代码 class A { public: int a; float b; A(): a(0),b(9.9) {} //构造函数初始化列表 }; class A { public: int a; float b; A() //构造函数内部赋值 { a = 0; b = 9.9; } }; 上面的例子中两个构造函数的效果是一样的。使用初始化列表的构造函数是显示地初始化类的成员；而没有使用初始化列表的构造函数是对类的成员赋值，并没有显示地初始化。 初始化列表的构造函数和内部赋值的构造函数对内置类型的成员没有什么大的区别，像上面的任一个构造函数都可以。 用构造函数的初始化列表来进行初始化，写法方便、简练，尤其当需要初始化的数据成员较多时更显其优越性。对非内置类型成员变量，推荐使用类构造函数初始化列表。 但有的时候必须用带有初始化列表的构造函数： （1）没有默认构造函数的成员类对象； （2）const成员或引用类型的成员。 构造函数中有着比我们所看见的还要多的细节，构造函数可以调用其它的构造函数来初始化对象中的基类对象和成员对象的构造函数。 类的数据成员中的其它类对象，若该成员类型是没有默认构造函数，则必须进行显示初始化，因为编译器会隐式调用成员类型的默认构造函数，而它又没有默认构造函数，则编译器尝试使用默认构造函数将会失败。 例： 复制代码 class A { public: A (int x) { i = x; // 无默认构造函数 } private: int i; }; class B { public: B(int y) { j = y; // error C2512: “A”: 没有合适的默认构造函数可用 } private: A a; int j; }; int main( ) { B b(5); return 0; } B类数据成员中有一个A类对象a，创建B类对象时，要先创建其成员对象a；A类有一个参数化大的构造函数，则编译器不会提供默认无参数的构造函数，因此a无法创建。 对成员对象正确的初始化方法是通过显示方式进行，B的构造函数应该写成： B(int y, int z) : a(z) { j = y; } B b(5,10); 构造函数初始化列表是初始化常数据成员和引用成员的唯一方式。因为const对象或引用类型只能初始化，不能对他们赋值。 class A { public: A (int x,int y) : c(x),j(y) // 构造函数初始化列表 { i = -1; } private: int i; const int c; int& j; }; int main( ) { int m; A a(5,m); return 0; } 若不通过初始化列表来对常数据成员和引用成员进行初始化： class A { public: A (int x) // 构造函数初始化列表 { i = -1; c = 5; j = x; } private: int i; const int c; // error C2758: “A::c”: 必须在构造函数基/成员初始值设定项列表中初始化 int& j; // error C2758: “A::j”: 必须在构造函数基/成员初始值设定项列表中初始化 }; 缺省情况下，在构造函数的被执行前，对象中的所有成员都已经被它们的缺省构造函数初始化了。当类中某个数据成员本身也是一个类对象时，我们应该避免使用赋值操作来对该成员进行初始化： class Person { private: string name; public: Person(string& n) { name = n; } } 虽然这样的构造函数也能达到正确的结果，但这样写效率并不高。当一个Person对象创建时，string类成员对象name先会被缺省构造函数进行初始化，然后在Person类构造函数中，它的值又会因赋值操作而在改变一次。我们可以通过初始化列表来显示地对name进行初始化，这样便将上边的两步（初始化和赋值）合并到一个步骤中了。 class Person { private: string name; public: Person(string& n): name(n){} }
      • 拷贝构造函数
        • C++ 拷贝构造函数 拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于： 通过使用另一个同类型的对象来初始化新创建的对象。 复制对象把它作为参数传递给函数。 复制对象，并从函数返回这个对象。 如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下： classname (const classname &obj) { // 构造函数的主体 } 在这里，obj 是一个对象引用，该对象是用于初始化另一个对象的。 例子1：复制对象把它作为参数传递给函数 #include <iostream> using namespace std; class Line { public: int getLength( void ); Line( int len ); // 简单的构造函数 Line( const Line &obj); // 拷贝构造函数 ~Line(); // 析构函数 private: int *ptr; }; // 成员函数定义，包括构造函数 Line::Line(int len) { cout << "Normal constructor allocating ptr" << endl; // 为指针分配内存 ptr = new int; *ptr = len; } Line::Line(const Line &obj) { cout << "Copy constructor allocating ptr." << endl; ptr = new int; *ptr = *obj.ptr; // copy the value } Line::~Line(void) { cout << "Freeing memory!" << endl; delete ptr; } int Line::getLength( void ) { return *ptr; } void display(Line obj) { cout << "Length of line : " << obj.getLength() <<endl; } // 程序的主函数 int main( ) { Line line(10); display(line); return 0; } 当上面的代码被编译和执行时，它会产生下列结果（思考每一行怎么出来）： Normal constructor allocating ptr Copy constructor allocating ptr. Length of line : 10 Freeing memory! Freeing memory! 例子2：通过使用另一个同类型的对象来初始化新创建的对象 #include <iostream> using namespace std; class Line { public: int getLength( void ); Line( int len ); // 简单的构造函数 Line( const Line &obj); // 拷贝构造函数 ~Line(); // 析构函数 private: int *ptr; }; // 成员函数定义，包括构造函数 Line::Line(int len) { cout << "Normal constructor allocating ptr" << endl; // 为指针分配内存 ptr = new int; *ptr = len; } Line::Line(const Line &obj) { cout << "Copy constructor allocating ptr." << endl; ptr = new int; *ptr = *obj.ptr; // copy the value } Line::~Line(void) { cout << "Freeing memory!" << endl; delete ptr; } int Line::getLength( void ) { return *ptr; } void display(Line obj) { cout << "Length of line : " << obj.getLength() <<endl; } // 程序的主函数 int main( ) { Line line1(10); Line line2 = line1; // 这里也调用了拷贝构造函数 display(line1); display(line2); return 0; } 当上面的代码被编译和执行时，它会产生下列结果（思考每一行怎么出来）： Normal constructor allocating ptr Copy constructor allocating ptr. Copy constructor allocating ptr. Length of line : 10 Freeing memory! Copy constructor allocating ptr. Length of line : 10 Freeing memory! Freeing memory! Freeing memory!
      • 构造函数与析构函数的调用顺序
        • 在C++中有一个很重要的法则：使用构造函数创建对象的顺序与使用析构函数释放对象的顺序相反。 例子 #include<iostream> using namespace std; //创建一个汽车类 class Car { public: //构造函数 Car(short, int); //析构函数 ~Car(); void move(); private: short speed; int num; }; Car::Car(short s, int n) { speed = s; num = n; cout << "创建第" << num << "辆车，速度是" << speed << " 米/秒" << endl; } Car::~Car() { cout << "销毁掉第 " << num << "辆车" << endl; } void Car::move() { cout << "第 " << num << "辆车速度是" << speed << endl; } //主函数 void main() { //先创建第car1对象，再创建car2对象 Car car1(10, 1), car2(20, 2); car1.move(); car2.move(); }
    • 类的静态成员
      • C++ 类的静态成员 我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。 静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化，如下面的实例所示。 下面的实例有助于更好地理解静态数据成员的概念： #include <iostream> using namespace std; class Box { public: static int objectCount; // 构造函数定义 Box(double l=2.0, double b=2.0, double h=2.0) { cout <<"Constructor called." << endl; length = l; breadth = b; height = h; // 每次创建对象时增加 1 objectCount++; } double Volume() { return length * breadth * height; } private: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; // 初始化类 Box 的静态成员 int Box::objectCount = 0; int main(void) { Box Box1(3.3, 1.2, 1.5); // 声明 box1 Box Box2(8.5, 6.0, 2.0); // 声明 box2 // 输出对象的总数 cout << "Total objects: " << Box::objectCount << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Constructor called. Constructor called. Total objects: 2 静态函数成员 如果把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符 :: 就可以访问。 静态成员函数只能访问静态数据成员，不能访问其他静态成员函数和类外部的其他函数。 静态成员函数有一个类范围，他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。 下面的实例有助于更好地理解静态函数成员的概念： #include <iostream> using namespace std; class Box { public: static int objectCount; // 构造函数定义 Box(double l=2.0, double b=2.0, double h=2.0) { cout <<"Constructor called." << endl; length = l; breadth = b; height = h; // 每次创建对象时增加 1 objectCount++; } double Volume() { return length * breadth * height; } static int getCount() { return objectCount; } private: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; // 初始化类 Box 的静态成员 int Box::objectCount = 0; int main(void) { // 在创建对象之前输出对象的总数 cout << "Inital Stage Count: " << Box::getCount() << endl; Box Box1(3.3, 1.2, 1.5); // 声明 box1 Box Box2(8.5, 6.0, 2.0); // 声明 box2 // 在创建对象之后输出对象的总数 cout << "Final Stage Count: " << Box::getCount() << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Inital Stage Count: 0 Constructor called. Constructor called. Final Stage Count: 2
    • 成员变量的初始化顺序
      • #include <iostream> using namespace std; // 本示例代码用于讨论类成员变量的初始化顺序 /* 类变量的初始化顺序 1 基类的静态变量或全局变量 2 派生类的静态变量或全局变量 3 基类的成员变量 4 派生类的成员变量 */ /* 从普通成员变量 a 和b的值变化可以看出： 成员变量初始化顺序为：先进行声明时初始化，然后进行初始化列表初始化，最后进行构造函数初始化。 初始化列表中初始化的顺序是和变量声明的顺序一样，而与列表中的顺序无关。 */ /* 从引用成员变量ri和常量成员变量ci和cd可以看出： 对于一般常量型和引用型成员变量，必须通过初始化参数列表进行初始化。 */ /* 从静态成员变量si和静态常量成员变量sci和scd可以看出：静态成员变量要再类的定义外初始化。 静态成员属于类作用域，但不属于类对象，和普通的static变量一样，程序一运行就分配内存并初始化，生命周期和程序一致。 所以，在类的构造函数里初始化static变量显然是不合理的。 静态成员其实和全局变量地位是一样的，只不过编译器把它的使用限制在类作用域内（不是类对象，它不属于类对象成员）， 要在类的定义外（不是类作用域外）初始化。 静态变量必须初始化在编译阶段 */ class Price{ public: double price; Price(double price):price(price) { cout << "正在创建Price类的实例" <<endl<<endl; } }; class Alphabet { public: Alphabet() { cout << "正在创建Alphabet类的实例" << endl; } }; class A : public Alphabet{ private: //在C++ 11标准下，成员变量可以在声明的时候初始化 int b = 2; // 普通成员变量 int a = 1; // 普通成员变量 double d = 12.13; // 普通成员变量 int& ri; // 引用成员变量 Price pri; const int ci; // 常量成员变量 const double cd; // 常量成员变量 static int si; // 静态成员变量 static const int sci; // 静态常量成员变量 static const double scd; // 静态常量成员变量 public: A(Price pri_, int &ri_, const int ci_, const double cd_):pri(pri_), ri(ri_), ci(ci_), cd(cd_) { cout << "使用类A的第一个构造函数" << endl; this->print(); } A(Price pri_, int a_, int b_, int& ri_, const int ci_, const double cd_) :pri(pri_), a(a_), b(a + b_), ri(ri_), ci(ci_), cd(cd_){ cout << "使用类A的第二个构造函数" << endl; this->print(); } A(Price pri_, int a_, bool b, int& ri_, const int ci_, const double cd_) :pri(pri_), a(4), ri(ri_), ci(ci_), cd(cd_){ cout << "使用类A的第三个构造函数" << endl; a = a_; this->print(); } void print() { cout << "a = " << a << "\t" << "b = " << b << "\t" << "d = " << d << endl << endl; } }; //注意下面三行：不能再带有static int A::si = 0; // 静态成员变量的初始化(Integral type) const int A::sci = 1; // 静态常量成员变量的初始化(Integral type) const double A::scd = 99.9; // 静态常量成员变量的初始化(non-Integral type) void main() { int x = 100; const int y = 1000; const double z = 1111.11; Price price(99.9); A a1(price, x, y, z); A a2(price, 3, 10, x, y, z); A a3(price, 5, true, x, y, z); }
    • 友元函数与友元类
      • C++ 友元函数 类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。 友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。 如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend，如下所示： class Box { double width; public: double length; friend void printWidth( Box box ); void setWidth( double wid ); }; 声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元，需要在类 ClassOne 的定义中放置如下声明： friend class ClassTwo; 请看下面的程序： #include <iostream> using namespace std; class Box { double width; public: friend void printWidth( Box box ); void setWidth( double wid ); }; // 成员函数定义 void Box::setWidth( double wid ) { width = wid; } // 请注意：printWidth() 不是任何类的成员函数 void printWidth( Box box ) { /* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */ cout << "Width of box : " << box.width <<endl; } // 程序的主函数 int main( ) { Box box; // 使用成员函数设置宽度 box.setWidth(10.0); // 使用友元函数输出宽度 printWidth( box ); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Width of box : 10
      • 关键字 friend
    • 内联函数
      • C++ 内联函数 C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。 对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。 如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。 在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。 下面是一个实例，使用内联函数来返回两个数中的最大值： #include <iostream> using namespace std; inline int Max(int x, int y) { return (x > y)? x : y; } // 程序的主函数 int main( ) { cout << "Max (20,10): " << Max(20,10) << endl; cout << "Max (0,200): " << Max(0,200) << endl; cout << "Max (100,1010): " << Max(100,1010) << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Max (20,10): 20 Max (0,200): 200 Max (100,1010): 1010
      • 关键字 inline
    • 数据抽象
      • C++ 数据抽象 数据抽象是指，只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。 数据抽象是一种依赖于接口和实现分离的编程（设计）技术。 让我们举一个现实生活中的真实例子，比如一台电视机，您可以打开和关闭、切换频道、调整音量、添加外部组件（如喇叭、录像机、DVD 播放器），但是您不知道它的内部实现细节，也就是说，您并不知道它是如何通过缆线接收信号，如何转换信号，并最终显示在屏幕上。 因此，我们可以说电视把它的内部实现和外部接口分离开了，您无需知道它的内部实现原理，直接通过它的外部接口（比如电源按钮、遥控器、声量控制器）就可以操控电视。 现在，让我们言归正传，就 C++ 编程而言，C++ 类为数据抽象提供了可能。它们向外界提供了大量用于操作对象数据的公共方法，也就是说，外界实际上并不清楚类的内部实现。 例如，您的程序可以调用 sort() 函数，而不需要知道函数中排序数据所用到的算法。实际上，函数排序的底层实现会因库的版本不同而有所差异，只要接口不变，函数调用就可以照常工作。 在 C++ 中，我们使用类来定义我们自己的抽象数据类型（ADT）。您可以使用类 ostream 的 cout 对象来输出数据到标准输出，如下所示： #include <iostream> using namespace std; int main( ) { cout << "Hello C++" <<endl; return 0; } 在这里，您不需要理解 cout 是如何在用户的屏幕上显示文本。您只需要知道公共接口即可，cout 的底层实现可以自由改变。 访问标签强制抽象 在 C++ 中，我们使用访问标签来定义类的抽象接口。一个类可以包含零个或多个访问标签： 使用公共标签定义的成员都可以访问该程序的所有部分。一个类型的数据抽象视图是由它的公共成员来定义的。 使用私有标签定义的成员无法访问到使用类的代码。私有部分对使用类型的代码隐藏了实现细节。 访问标签出现的频率没有限制。每个访问标签指定了紧随其后的成员定义的访问级别。指定的访问级别会一直有效，直到遇到下一个访问标签或者遇到类主体的关闭右括号为止。 数据抽象的好处 数据抽象有两个重要的优势： 类的内部受到保护，不会因无意的用户级错误导致对象状态受损。 类实现可能随着时间的推移而发生变化，以便应对不断变化的需求，或者应对那些要求不改变用户级代码的错误报告。 如果只在类的私有部分定义数据成员，编写该类的作者就可以随意更改数据。如果实现发生改变，则只需要检查类的代码，看看这个改变会导致哪些影响。如果数据是公有的，则任何直接访问旧表示形式的数据成员的函数都可能受到影响。 数据抽象的实例 C++ 程序中，任何带有公有和私有成员的类都可以作为数据抽象的实例。请看下面的实例： #include <iostream> using namespace std; class Adder{ public: // 构造函数 Adder(int i = 0) { total = i; } // 对外的接口 void addNum(int number) { total += number; } // 对外的接口 int getTotal() { return total; }; private: // 对外隐藏的数据 int total; }; int main( ) { Adder a; a.addNum(10); a.addNum(20); a.addNum(30); cout << "Total " << a.getTotal() <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Total 60 上面的类把数字相加，并返回总和。公有成员 addNum 和 getTotal 是对外的接口，用户需要知道它们以便使用类。私有成员 total 是用户不需要了解的，但又是类能正常工作所必需的。 设计策略 抽象把代码分离为接口和实现。所以在设计组件时，必须保持接口独立于实现，这样，如果改变底层实现，接口也将保持不变。 在这种情况下，不管任何程序使用接口，接口都不会受到影响，只需要将最新的实现重新编译即可。
  • 继承
    • 定义
      • C++ 继承 面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。 当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。 基类 & 派生类 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下： class derived-class: access-specifier base-class 其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。 假设有一个基类 Shape，Rectangle 是它的派生类，如下所示： #include <iostream> using namespace std; // 基类 class Shape { public: void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // 派生类 class Rectangle: public Shape { public: int getArea() { return (width * height); } }; int main(void) { Rectangle Rect; Rect.setWidth(5); Rect.setHeight(7); // 输出对象的面积 cout << "Total area: " << Rect.getArea() << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Total area: 35
    • 访问控制和继承
      • 访问控制和继承 派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。 我们可以根据访问权限总结出不同的访问类型，如下所示： 访问 public protected private 同一个类 yes yes yes 派生类 yes yes no 外部的类 yes no no 一个派生类继承了所有的基类方法，但下列情况除外： 基类的构造函数、析构函数和拷贝构造函数。 基类的重载运算符。 基类的友元函数。
    • 继承类型
      • 继承类型 当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。 我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则： 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
    • 多继承
      • 多继承 多继承即一个子类可以有多个父类，它继承了多个父类的特性。 C++ 类可以从多个类继承成员，语法如下： class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,… { <派生类类体> }; 其中，访问修饰符 access 是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。现在让我们一起看看下面的实例： #include <iostream> using namespace std; // 基类 Shape class Shape { public: void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // 基类 PaintCost class PaintCost { public: int getCost(int area) { return area * 70; } }; // 派生类 class Rectangle: public Shape, public PaintCost { public: int getArea() { return (width * height); } }; int main(void) { Rectangle Rect; int area; Rect.setWidth(5); Rect.setHeight(7); area = Rect.getArea(); // 输出对象的面积 cout << "Total area: " << Rect.getArea() << endl; // 输出总花费 cout << "Total paint cost: $" << Rect.getCost(area) << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Total area: 35 Total paint cost: $2450
  • 数据封装
    • C++ 数据封装 所有的 C++ 程序都有以下两个基本要素： 程序语句（代码）：这是程序中执行动作的部分，它们被称为函数。 程序数据：数据是程序的信息，会受到程序函数的影响。 封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。 数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。 C++ 通过创建类来支持封装和数据因此。我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。默认情况下，在类中定义的所有项目都是私有的。例如： class Box { public: double getVolume(void) { return length * breadth * height; } private: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; 变量 length、breadth 和 height 都是私有的（private）。这意味着它们只能被 Box 类中的其他成员访问，而不能被程序中其他部分访问。这是实现封装的一种方式。 为了使类中的成员变成公有的（即，程序中的其他部分也能访问），必须在这些成员前使用 public 关键字进行声明。所有定义在 public 标识符后边的变量或函数可以被程序中所有其他的函数访问。 把一个类定义为另一个类的友元类，会暴露实现细节，从而降低了封装性。理想的做法是尽可能地对外隐藏每个类的实现细节。 数据封装的实例 C++ 程序中，任何带有公有和私有成员的类都可以作为数据封装和数据抽象的实例。请看下面的实例： #include <iostream> using namespace std; class Adder{ public: // 构造函数 Adder(int i = 0) { total = i; } // 对外的接口 void addNum(int number) { total += number; } // 对外的接口 int getTotal() { return total; }; private: // 对外隐藏的数据 int total; }; int main( ) { Adder a; a.addNum(10); a.addNum(20); a.addNum(30); cout << "Total " << a.getTotal() <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Total 60 上面的类把数字相加，并返回总和。公有成员 addNum 和 getTotal 是对外的接口，用户需要知道它们以便使用类。私有成员 total 是对外隐藏的，用户不需要了解它，但它又是类能正常工作所必需的。 设计策略 通常情况下，我们都会设置类成员状态为私有（private），除非我们真的需要将其暴露，这样才能保证良好的封装性。 这通常应用于数据成员，但它同样适用于所有成员，包括虚函数。
  • 重载
    • C++ 重载运算符和重载函数 C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。 当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。
    • 重载函数
      • C++ 中的函数重载 在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。 下面的实例中，同名函数 print() 被用于输出不同的数据类型： #include <iostream> using namespace std; class printData { public: void print(int i) { cout << "Printing int: " << i << endl; } void print(double f) { cout << "Printing float: " << f << endl; } void print(char* c) { cout << "Printing character: " << c << endl; } }; int main(void) { printData pd; // Call print to print integer pd.print(5); // Call print to print float pd.print(500.263); // Call print to print character pd.print("Hello C++"); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Printing int: 5 Printing float: 500.263 Printing character: Hello C++
    • 重载运算符
      • C++ 中的运算符重载 您可以重定义或重载大部分 C++ 内置的运算符。这样，您就能使用自定义类型的运算符。 重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。 Box operator+(const Box&); 声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或这被定义为类成员函数。如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，如下所示： Box operator+(const Box&, const Box&); 下面的实例使用成员函数演示了运算符重载的概念。在这里，对象作为参数进行传递，对象的属性使用 this 运算符进行访问，如下所示： #include <iostream> using namespace std; class Box { public: double getVolume(void) { return length * breadth * height; } void setLength( double len ) { length = len; } void setBreadth( double bre ) { breadth = bre; } void setHeight( double hei ) { height = hei; } // 重载 + 运算符，用于把两个 Box 对象相加 Box operator+(const Box& b) { Box box; box.length = this->length + b.length; box.breadth = this->breadth + b.breadth; box.height = this->height + b.height; return box; } private: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; // 程序的主函数 int main( ) { Box Box1; // 声明 Box1，类型为 Box Box Box2; // 声明 Box2，类型为 Box Box Box3; // 声明 Box3，类型为 Box double volume = 0.0; // 把体积存储在该变量中 // Box1 详述 Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0); // Box2 详述 Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0); // Box1 的体积 volume = Box1.getVolume(); cout << "Volume of Box1 : " << volume <<endl; // Box2 的体积 volume = Box2.getVolume(); cout << "Volume of Box2 : " << volume <<endl; // 把两个对象相加，得到 Box3 Box3 = Box1 + Box2; // Box3 的体积 volume = Box3.getVolume(); cout << "Volume of Box3 : " << volume <<endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Volume of Box1 : 210 Volume of Box2 : 1560 Volume of Box3 : 5400
      • 可重载运算符/不可重载运算符
        • 可重载运算符/不可重载运算符 下面是可重载的运算符列表： + - * / % ^ & | ~ ! , = < > <= >= ++ -- << >> == != && || += -= /= %= ^= &= |= *= <<= >>= [] () -> ->* new new [] delete delete [] 下面是不可重载的运算符列表： :: .* . ?:
  • 多态
    • 定义
      • C++ 多态 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 下面的实例中，基类 Shape 被派生为两个类，如下所示： #include <iostream> using namespace std; class Shape { protected: int width, height; public: Shape( int a=0, int b=0) { width = a; height = b; } int area() { cout << "Parent class area :" <<endl; return 0; } }; class Rectangle: public Shape{ public: Rectangle( int a=0, int b=0):Shape(a, b) { } int area () { cout << "Rectangle class area :" <<endl; return (width * height); } }; class Triangle: public Shape{ public: Triangle( int a=0, int b=0):Shape(a, b) { } int area () { cout << "Triangle class area :" <<endl; return (width * height / 2); } }; // 程序的主函数 int main( ) { Shape *shape; Rectangle rec(10,7); Triangle tri(10,5); // 存储矩形的地址 shape = &rec; // 调用矩形的求面积函数 area shape->area(); // 存储三角形的地址 shape = &tri; // 调用三角形的求面积函数 area shape->area(); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Parent class area Parent class area 导致错误输出的原因是，调用函数 area() 被编译器设置为基类中的版本，这就是所谓的静态多态，或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。 但现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示： class Shape { protected: int width, height; public: Shape( int a=0, int b=0) { width = a; height = b; } virtual int area() { cout << "Parent class area :" <<endl; return 0; } }; 修改后，当编译和执行前面的实例代码时，它会产生以下结果： Rectangle class area Triangle class area 此时，编译器看的是指针的内容，而不是它的类型。因此，由于 tri 和 rec 类的对象的地址存储在 *shape 中，所以会调用各自的 area() 函数。 正如您所看到的，每个子类都有一个函数 area() 的独立实现。这就是多态的一般使用方式。有了多态，您可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。
    • 虚函数
      • 虚函数 虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。 我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。
      • 纯虚函数
        • 纯虚函数 您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。 我们可以把基类中的虚函数 area() 改写如下： class Shape { protected: int width, height; public: Shape( int a=0, int b=0) { width = a; height = b; } // pure virtual function virtual int area() = 0; }; = 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。
  • 接口（抽象类）
    • C++ 接口（抽象类） 接口描述了类的行为和功能，而不需要完成类的特定实现。 C++ 接口是使用抽象类来实现的，抽象类与数据抽象互不混淆，数据抽象是一个把实现细节与相关的数据分离开的概念。 如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 "= 0" 来指定的，如下所示： class Box { public: // 纯虚函数 virtual double getVolume() = 0; private: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; 设计抽象类（通常称为 ABC）的目的，是为了给其他类提供一个可以继承的适当的基类。抽象类不能被用于实例化对象，它只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。 因此，如果一个 ABC 的子类需要被实例化，则必须实现每个虚函数，这也意味着 C++ 支持使用 ABC 声明接口。如果没有在派生类中重载纯虚函数，就尝试实例化该类的对象，会导致编译错误。 可用于实例化对象的类被称为具体类。 抽象类的实例 请看下面的实例，基类 Shape 提供了一个接口 getArea()，在两个派生类 Rectangle 和 Triangle 中分别实现了 getArea()： #include <iostream> using namespace std; // 基类 class Shape { public: // 提供接口框架的纯虚函数 virtual int getArea() = 0; void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // 派生类 class Rectangle: public Shape { public: int getArea() { return (width * height); } }; class Triangle: public Shape { public: int getArea() { return (width * height)/2; } }; int main(void) { Rectangle Rect; Triangle Tri; Rect.setWidth(5); Rect.setHeight(7); // 输出对象的面积 cout << "Total Rectangle area: " << Rect.getArea() << endl; Tri.setWidth(5); Tri.setHeight(7); // 输出对象的面积 cout << "Total Triangle area: " << Tri.getArea() << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Total Rectangle area: 35 Total Triangle area: 17 从上面的实例中，我们可以看到一个抽象类是如何定义一个接口 getArea()，两个派生类是如何通过不同的计算面积的算法来实现这个相同的函数。 设计策略 面向对象的系统可能会使用一个抽象基类为所有的外部应用程序提供一个适当的、通用的、标准化的接口。然后，派生类通过继承抽象基类，就把所有类似的操作都继承下来。 外部应用程序提供的功能（即公有函数）在抽象基类中是以纯虚函数的形式存在的。这些纯虚函数在相应的派生类中被实现。 这个架构也使得新的应用程序可以很容易地被添加到系统中，即使是在系统被定义之后依然可以如此。
• C++标准库
  • C++ 标准库可以分为两部分： 标准函数库： 这个库是由通用的、独立的、不属于任何类的函数组成的。函数库继承自 C 语言。 面向对象类库： 这个库是类及其相关函数的集合。 C++ 标准库包含了所有的 C 标准库，为了支持类型安全，做了一定的添加和修改。
  • 标准函数库
    • 标准函数库分为以下几类： 输入/输出 I/O 字符串和字符处理 数学 时间、日期和本地化 动态分配 宽字符函数 其他
  • 面向对象类库
    • 标准的 C++ 面向对象类库定义了大量支持一些常见操作的类，比如输入/输出 I/O、字符串处理、数值处理。面向对象类库包含以下内容： 标准的 C++ I/O 类 String 类 数值类 STL 容器类 STL 算法 STL 函数对象 STL 迭代器 STL 分配器 本地化库 异常处理类 杂项支持库
    • 标准模板库STL
      • 模板
        • C++ 模板 模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。 模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。 每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。
        • 函数模板
          • 函数模板 模板函数定义的一般形式如下所示： template <class type> ret-type func-name(parameter list) { // 函数的主体 } 在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。 下面是函数模板的实例，返回两个数中的最大值： #include <iostream> #include <string> using namespace std; template <typename T> inline T const& Max (T const& a, T const& b) { return a < b ? b:a; } int main () { int i = 39; int j = 20; cout << "Max(i, j): " << Max(i, j) << endl; double f1 = 13.5; double f2 = 20.7; cout << "Max(f1, f2): " << Max(f1, f2) << endl; string s1 = "Hello"; string s2 = "World"; cout << "Max(s1, s2): " << Max(s1, s2) << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Max(i, j): 39 Max(f1, f2): 20.7 Max(s1, s2): World
        • 类模板
          • 类模板 泛型类声明的一般形式如下所示： template <class type> class class-name { . . . } 在这里，type 是占位符类型名称，可以在类被实例化的时候进行指定。您可以使用一个逗号分隔的列表来定义多个泛型数据类型。 下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作： #include <iostream> #include <vector> #include <cstdlib> #include <string> #include <stdexcept> using namespace std; template <class T> class Stack { private: vector<T> elems; // 元素 public: void push(T const&); // 入栈 void pop(); // 出栈 T top() const; // 返回栈顶元素 bool empty() const{ // 如果为空则返回真。 return elems.empty(); } }; template <class T> void Stack<T>::push (T const& elem) { // 追加传入元素的副本 elems.push_back(elem); } template <class T> void Stack<T>::pop () { if (elems.empty()) { throw out_of_range("Stack<>::pop(): empty stack"); } // 删除最后一个元素 elems.pop_back(); } template <class T> T Stack<T>::top () const { if (elems.empty()) { throw out_of_range("Stack<>::top(): empty stack"); } // 返回最后一个元素的副本 return elems.back(); } int main() { try { Stack<int> intStack; // int 类型的栈 Stack<string> stringStack; // string 类型的栈 // 操作 int 类型的栈 intStack.push(7); cout << intStack.top() <<endl; // 操作 string 类型的栈 stringStack.push("hello"); cout << stringStack.top() << std::endl; stringStack.pop(); stringStack.pop(); } catch (exception const& ex) { cerr << "Exception: " << ex.what() <<endl; return -1; } } 当上面的代码被编译和执行时，它会产生下列结果： 7 hello Exception: Stack<>::pop(): empty stack
      • 标准模板库
        • C++ STL（标准模板库） C++ STL（标准模板库）是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现多种流行和常用的算法和数据结构，如向量、链表、队列、栈。 C++ 标准模板库的核心包括以下三个组件： 容器（Containers） 容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。 算法（Algorithms） 算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。 迭代器（terators） 迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。 这三个组件都带有丰富的预定义函数，帮助我们通过简单的方式处理复杂的任务。 下面的程序演示了向量容器（一个 C++ 标准的模板），它与数组十分相似，唯一不同的是，向量在需要扩展大小的时候，会自动处理它自己的存储需求： #include <iostream> #include <vector> using namespace std; int main() { // 创建一个向量存储 int vector<int> vec; int i; // 显示 vec 的原始大小 cout << "vector size = " << vec.size() << endl; // 推入 5 个值到向量中 for(i = 0; i < 5; i++){ vec.push_back(i); } // 显示 vec 扩展后的大小 cout << "extended vector size = " << vec.size() << endl; // 访问向量中的 5 个值 for(i = 0; i < 5; i++){ cout << "value of vec [" << i << "] = " << vec[i] << endl; } // 使用迭代器 iterator 访问值 vector<int>::iterator v = vec.begin(); while( v != vec.end()) { cout << "value of v = " << *v << endl; v++; } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： vector size = 0 extended vector size = 5 value of vec [0] = 0 value of vec [1] = 1 value of vec [2] = 2 value of vec [3] = 3 value of vec [4] = 4 value of v = 0 value of v = 1 value of v = 2 value of v = 3 value of v = 4 关于上面实例中所使用的各种函数，有几点要注意： push_back( ) 成员函数在向量的末尾插入值，如果有必要会扩展向量的大小。 size( ) 函数显示向量的大小。 begin( ) 函数返回一个指向向量开头的迭代器。 end( ) 函数返回一个指向向量末尾的迭代器。
        • vector
          • C++ vector使用方法
            • C++ vector使用方法 在c++中，vector是一个十分有用的容器。它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。 基本操作 (1)头文件#include<vector>. (2)创建vector对象，vector<int> vec; (3)尾部插入数字：vec.push_back(a); (4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。 (5)使用迭代器访问元素. vector<int>::iterator it; for(it=vec.begin();it!=vec.end();it++) cout<<*it<<endl; (6)插入元素：vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a; (7)删除元素：vec.erase(vec.begin()+2);删除第3个元素 vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始 (8)向量大小:vec.size(); (9)清空:vec.clear(); 特别提示：这里有begin()与end()函数、front()与back()的差别 使用vector注意事项： 如果你要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低； Vector作为函数的参数或者返回值时，需要注意它的写法：double Distance(vector<int>&a, vector<int>&b)其中的“&”绝对不能少。 使用自定义类型作为vector元素 vector的元素不仅仅可以是int,double,string,还可以是结构体，但是要注意：结构体要定义为全局的，否则会出错。 #include<stdio.h> #include<algorithm> #include<vector> #include<iostream> using namespace std; typedef struct rect { int id; int length; int width; 　　//对于向量元素是结构体的，可在结构体内部定义比较函数，下面按照id,length,width升序排序。 　　bool operator< (const rect &a) const { if(id!=a.id) return id<a.id; else { if(length!=a.length) return length<a.length; else return width<a.width; } } }Rect; int main() { vector<Rect> vec; Rect rect; rect.id=1; rect.length=2; rect.width=3; vec.push_back(rect); vector<Rect>::iterator it=vec.begin(); cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<<endl; return 0; } 算法 (1) 使用reverse将元素翻转：需要头文件#include<algorithm> reverse(vec.begin(),vec.end());将元素翻转，即逆序排列。 (2)使用sort排序：需要头文件#include<algorithm>， sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大). 可以通过重写排序比较函数按照降序比较，如下： 定义排序比较函数： bool Comp(const int &a,const int &b) { return a>b; } 调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。 输出Vector的中的元素 vector<float> vecClass; int nSize = vecClass.size(); //打印vecClass,方法一： for(int i=0;i<nSize;i++) { cout<<vecClass[i]<<" "; } cout<<endl; 需要注意的是：以方法一进行输出时，数组的下表必须保证是整数。 //打印vecClass,方法二： for(int i=0;i<nSize;i++) { cout<<vecClass.at(i)<<" "; } cout<<endl; //打印vecClass,方法三：输出某一指定的数值时不方便 for(vector<float>::iterator it = vecClass.begin();it!=vecClass.end();it++) { cout<<*it<<" "; } cout<<endl; 二维数组的使用 #include "stdafx.h" #include <cv.h> #include <vector> #include <iostream> using namespace std; int main() { using namespace std; int out[3][2] = { 1, 2, 3, 4, 5, 6 }; vector <int*> v1; v1.push_back(out[0]); v1.push_back(out[1]); v1.push_back(out[2]); cout << v1[0][0] << endl;//1 cout << v1[0][1] << endl;//2 cout << v1[1][0] << endl;//3 cout << v1[1][1] << endl;//4 cout << v1[2][0] << endl;//5 cout << v1[2][1] << endl;//6 return 0; }
        • map
          • C++ map用法
            • C++ map用法 map是C++中的一个标准容器，它提供了很好一对一的关系。 map最基本的构造函数 map<string , int >mapstring; map<int ,string >mapint; map<string, char>mapstring; map< char ,string>mapchar; map<char ,int>mapchar; map<int ,char >mapint； map的基本操作函数 C++ Maps是一种关联式容器，包含“关键字/值”对 begin() 返回指向map头部的迭代器 clear(） 删除所有元素 count() 返回指定元素出现的次数 empty() 如果map为空则返回true end() 返回指向map末尾的迭代器 equal_range() 返回特殊条目的迭代器对 erase() 删除一个元素 find() 查找一个元素 get_allocator() 返回map的配置器 insert() 插入元素 key_comp() 返回比较元素key的函数 lower_bound() 返回键值>=给定元素的第一个位置 max_size() 返回可以容纳的最大元素个数 rbegin() 返回一个指向map尾部的逆向迭代器 rend() 返回一个指向map头部的逆向迭代器 size() 返回map中元素的个数 swap() 交换两个map upper_bound() 返回键值>给定元素的第一个位置 value_comp() 返回比较元素value的函数 map添加数据 map<int ,string> maplive; 1.maplive.insert(pair<int,string>(102,"aclive")); 2.maplive.insert(map<int,string>::value_type(321,"hai")); 3, maplive[112]="April";//map中最简单最常用的插入添加！ map中元素的查找 find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。 map<int ,string >::iterator l_it;; l_it=maplive.find(112); if(l_it==maplive.end()) cout<<"we do not find 112"<<endl; else cout<<"wo find 112"<<endl; map中元素的删除 如果删除112； map<int ,string >::iterator l_it;; l_it=maplive.find(112); if(l_it==maplive.end()) cout<<"we do not find 112"<<endl; else maplive.erase(l_it); //delete 112; map中 swap的用法 Map中的swap不是一个容器中的元素交换，而是两个容器交换； 示例： #include <map> #include <iostream> using namespace std; int main( ) { map <int, int> m1, m2, m3; map <int, int>::iterator m1_Iter; m1.insert ( pair <int, int> ( 1, 10 ) ); m1.insert ( pair <int, int> ( 2, 20 ) ); m1.insert ( pair <int, int> ( 3, 30 ) ); m2.insert ( pair <int, int> ( 10, 100 ) ); m2.insert ( pair <int, int> ( 20, 200 ) ); m3.insert ( pair <int, int> ( 30, 300 ) ); cout << "The original map m1 is:"; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << " " << m1_Iter->second; cout << "." << endl; // This is the member function version of swap //m2 is said to be the argument map; m1 the target map m1.swap( m2 ); cout << "After swapping with m2, map m1 is:"; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << " " << m1_Iter -> second; cout << "." << endl; cout << "After swapping with m2, map m2 is:"; for ( m1_Iter = m2.begin( ); m1_Iter != m2.end( ); m1_Iter++ ) cout << " " << m1_Iter -> second; cout << "." << endl; // This is the specialized template version of swap swap( m1, m3 ); cout << "After swapping with m3, map m1 is:"; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << " " << m1_Iter -> second; cout << "." << endl; } map的sort问题 Map中的元素是自动按key升序排序,所以不能对map用sort函数： 示例： #include <map> #include <iostream> using namespace std; int main( ) { map <int, int> m1; map <int, int>::iterator m1_Iter; m1.insert ( pair <int, int> ( 1, 20 ) ); m1.insert ( pair <int, int> ( 4, 40 ) ); m1.insert ( pair <int, int> ( 3, 60 ) ); m1.insert ( pair <int, int> ( 2, 50 ) ); m1.insert ( pair <int, int> ( 6, 40 ) ); m1.insert ( pair <int, int> ( 7, 30 ) ); cout << "The original map m1 is:"<<endl; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << m1_Iter->first<<" "<<m1_Iter->second<<endl; }
• C++高级教程
  • 预处理器
    • C++ 预处理器 预处理器是一些指令，指示编译器在实际编译之前所需完成的预处理。 所有的预处理器指令都是以井号（#）开头，只有空格字符可以出现在预处理指令之前。预处理指令不是 C++ 语句，所以它们不会以分号（;）结尾。 我们已经看到，之前所有的实例中都有 #include 指令。这个宏用于把头文件包含到源文件中。 C++ 还支持很多预处理指令，比如 #include、#define、#if、#else、#line 等，让我们一起看看这些重要指令。
    • #define
      • 预处理
        • #define 预处理 #define 预处理指令用于创建符号常量。该符号常量通常称为宏，指令的一般形式是： #define macro-name replacement-text 当这一行代码出现在一个文件中时，在该文件中后续出现的所有宏都将会在程序编译之前被替换为 replacement-text。例如： #include <iostream> using namespace std; #define PI 3.14159 int main () { cout << "Value of PI :" << PI << endl; return 0; } 现在，让我们测试这段代码，看看预处理的结果。假设源代码文件已经存在，接下来使用 -E 选项进行编译，并把结果重定向到 test.p。现在，如果您查看 test.p 文件，将会看到它已经包含大量的信息，而且在文件底部的值被改为如下： $gcc -E test.cpp > test.p ... int main () { cout << "Value of PI :" << 3.14159 << endl; return 0; }
      • 函数宏
        • 函数宏 您可以使用 #define 来定义一个带有参数的宏，如下所示： #include <iostream> using namespace std; #define MIN(a,b) (((a)<(b)) ? a : b) int main () { int i, j; i = 100; j = 30; cout <<"The minimum is " << MIN(i, j) << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： The minimum is 30
    • #ifndef、#ifdef
      • 条件编译
        • 条件编译 有几个指令可以用来有选择地对部分程序源代码进行编译。这个过程被称为条件编译。 条件预处理器的结构与 if 选择结构很像。请看下面这段预处理器的代码： #ifndef NULL #define NULL 0 #endif 您可以只在调试时进行编译，调试开关可以使用一个宏来实现，如下所示： #ifdef DEBUG cerr <<"Variable x = " << x << endl; #endif 如果在指令 #ifdef DEBUG 之前已经定义了符号常量 DEBUG，则会对程序中的 cerr 语句进行编译。您可以使用 #if 0 语句注释掉程序的一部分，如下所示： #if 0 不进行编译的代码 #endif 让我们尝试下面的实例： #include <iostream> using namespace std; #define DEBUG #define MIN(a,b) (((a)<(b)) ? a : b) int main() { int i, j; i = 100; j = 30; #ifdef DEBUG cerr << "Trace: Inside main function" << endl; #endif #if 0 /* 这是注释部分 */ cout << MKSTR(HELLO C++) << endl; #endif cout << "The minimum is " << MIN(i, j) << endl; #ifndef DEBUG cerr << "Trace: Coming out of main function" << endl; #endif return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Trace: Inside main function The minimum is 30
    • # 和 ## 运算符
      • # 和 ## 运算符 # 和 ## 预处理运算符在 C++ 和 ANSI/ISO C 中都是可用的。 # 运算符会把 replacement-text 令牌转换为用引号引起来的字符串 请看下面的宏定义： #include <iostream> using namespace std; #define MKSTR( x ) #x int main () { cout << MKSTR(HELLO C++) << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： HELLO C++ 让我们来看看它是如何工作的。不难理解，C++ 预处理器把下面这行： cout << MKSTR(HELLO C++) << endl; 转换成了： cout << "HELLO C++" << endl; ## 运算符用于连接两个令牌 下面是一个实例： #define CONCAT( x, y ) x ## y 当 CONCAT 出现在程序中时，它的参数会被连接起来，并用来取代宏。例如，程序中 CONCAT(HELLO, C++) 会被替换为 "HELLO C++"，如下面实例所示。 #include <iostream> using namespace std; #define concat(a, b) a ## b int main() { int xy = 100; cout << concat(x, y); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： 100 让我们来看看它是如何工作的。不难理解，C++ 预处理器把下面这行： cout << concat(x, y); 转换成了： cout << xy;
    • 预定义宏
      • C++ 中的预定义宏 C++ 提供了下表所示的一些预定义宏： 宏 描述 __LINE__ 这会在程序编译时包含当前行号。 __FILE__ 这会在程序编译时包含当前文件名。 __DATE__ 这会包含一个形式为 month/day/year 的字符串，它表示把源文件转换为目标代码的日期。 __TIME__ 这会包含一个形式为 hour:minute:second 的字符串，它表示程序被编译的时间。 让我们看看上述这些宏的实例： #include <iostream> using namespace std; int main () { cout << "Value of __LINE__ : " << __LINE__ << endl; cout << "Value of __FILE__ : " << __FILE__ << endl; cout << "Value of __DATE__ : " << __DATE__ << endl; cout << "Value of __TIME__ : " << __TIME__ << endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Value of __LINE__ : 6 Value of __FILE__ : Wangjiang.cpp Value of __DATE__ : Apr 13 2020 Value of __TIME__ : 16:00:07
  • 命名空间
    • C++ 命名空间 假设这样一种情况，当一个班上有两个名叫 Zara 的学生时，为了明确区分它们，我们在使用名字之外，不得不使用一些额外的信息，比如他们的家庭住址，或者他们父母的名字等等。 同样的情况也出现在 C++ 应用程序中。例如，您可能会写一个名为 xyz() 的函数，在另一个可用的库中也存在一个相同的函数 xyz()。这样，编译器就无法判断您所使用的是哪一个 xyz() 函数。 因此，引入了命名空间这个概念，专门用于解决上面的问题，它可作为附加信息来区分不同库中相同名称的函数、类、变量等。使用了命名空间即定义了上下文。本质上，命名空间就是定义了一个范围。
    • 定义
      • 定义命名空间 命名空间的定义使用关键字 namespace，后跟命名空间的名称，如下所示： namespace namespace_name { // 代码声明 } 为了调用带有命名空间的函数或变量，需要在前面加上命名空间的名称，如下所示： name::code; // code 可以是变量或函数 让我们来看看命名空间如何为变量或函数等实体定义范围： #include <iostream> using namespace std; // 第一个命名空间 namespace first_space{ void func(){ cout << "Inside first_space" << endl; } } // 第二个命名空间 namespace second_space{ void func(){ cout << "Inside second_space" << endl; } } int main () { // 调用第一个命名空间中的函数 first_space::func(); // 调用第二个命名空间中的函数 second_space::func(); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Inside first_space Inside second_space
      • 关键字namespace
      • 关键字using
        • using 指令 您可以使用 using namespace 指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。 #include <iostream> using namespace std; // 第一个命名空间 namespace first_space{ void func(){ cout << "Inside first_space" << endl; } } // 第二个命名空间 namespace second_space{ void func(){ cout << "Inside second_space" << endl; } } using namespace first_space; int main () { // 调用第一个命名空间中的函数 func(); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Inside first_space using 指令也可以用来指定命名空间中的特定项目。例如，如果您只打算使用 std 命名空间中的 cout 部分，您可以使用如下的语句： using std::cout; 随后的代码中，在使用 cout 时就可以不用加上命名空间名称作为前缀，但是 std 命名空间中的其他项目仍然需要加上命名空间名称作为前缀，如下所示： #include <iostream> using std::cout; int main () { cout << "std::endl is used with std!" << std::endl; return 0; } 当上面的代码被编译和执行时，它会产生下列结果： std::endl is used with std! using 指令引入的名称遵循正常的范围规则。名称从使用 using 指令开始是可见的，直到该范围结束。此时，在范围以外定义的同名实体是隐藏的。
    • 不连续的命名空间
      • 不连续的命名空间 命名空间可以定义在几个不同的部分中，因此命名空间是由几个单独定义的部分组成的。一个命名空间的各个组成部分可以分散在多个文件中。 所以，如果命名空间中的某个组成部分需要请求定义在另一个文件中的名称，则仍然需要声明该名称。下面的命名空间定义可以是定义一个新的命名空间，也可以是为已有的命名空间增加新的元素： namespace namespace_name { // 代码声明 }
    • 嵌套的命名空间
      • 嵌套的命名空间 命名空间可以嵌套，您可以在一个命名空间中定义另一个命名空间，如下所示： namespace namespace_name1 { // 代码声明 namespace namespace_name2 { // 代码声明 } } 您可以通过使用 :: 运算符来访问嵌套的命名空间中的成员： // 访问 namespace_name2 中的成员 using namespace namespace_name1::namespace_name2; // 访问 namespace:name1 中的成员 using namespace namespace_name1; 在上面的语句中，如果使用的是 namespace_name1，那么在该范围内 namespace_name2 中的元素也是可用的，如下所示： #include <iostream> using namespace std; // 第一个命名空间 namespace first_space{ void func(){ cout << "Inside first_space" << endl; } // 第二个命名空间 namespace second_space{ void func(){ cout << "Inside second_space" << endl; } } } using namespace first_space::second_space; int main () { // 调用第二个命名空间中的函数 func(); return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Inside second_space
  • 文件
  • 异常处理
  • 动态内存
    • 堆、栈
      • C++ 动态内存 了解动态内存在 C++ 中是如何工作的是成为一名合格的 C++ 程序员必不可少的。C++ 程序中的内存分为两个部分： 栈：在函数内部声明的所有变量都将占用栈内存。 堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。 很多时候，您无法提前预知需要多少内存来存储某个定义变量中的特定信息，所需内存的大小需要在运行时才能确定。 在 C++ 中，您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存，这会返回所分配的空间地址。这种运算符即 new 运算符。 如果您不需要动态分配内存，可以使用 delete 运算符，删除之前由 new 运算符分配的内存。
    • 操作符new和delete
      • new 和 delete 运算符 下面是使用 new 运算符来为任意的数据类型动态分配内存的通用语法： new data-type; 在这里，data-type 可以是包括数组在内的任意内置的数据类型，也可以是包括类或结构在内的用户自定义的任何数据类型。让我们先来看下内置的数据类型。例如，我们可以定义一个指向 double 类型的指针，然后请求内存，该内存在执行时被分配。我们可以按照下面的语句使用 new 运算符来完成这点： double* pvalue = NULL; // 初始化为 null 的指针 pvalue = new double; // 为变量请求内存 如果自由存储区已被用完，可能无法成功分配内存。所以建议检查 new 运算符是否返回 NULL 指针，并采取以下适当的操作： double* pvalue = NULL; if( !(pvalue = new double )) { cout << "Error: out of memory." <<endl; exit(1); } malloc() 函数在 C 语言中就出现了，在 C++ 中仍然存在，但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。 在任何时候，当您觉得某个已经动态分配内存的变量不再需要使用时，您可以使用 delete 操作符释放它所占用的内存，如下所示： delete pvalue; // 释放 pvalue 所指向的内存 下面的实例中使用了上面的概念，演示了如何使用 new 和 delete 运算符： #include <iostream> using namespace std; int main () { double* pvalue = NULL; // 初始化为 null 的指针 pvalue = new double; // 为变量请求内存 *pvalue = 29494.99; // 在分配的地址存储值 cout << "Value of pvalue : " << *pvalue << endl; delete pvalue; // 释放内存 return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Value of pvalue : 29495
    • 数组的动态内存分配
      • 数组的动态内存分配 假设我们要为一个字符数组（一个有 20 个字符的字符串）分配内存，我们可以使用上面实例中的语法来为数组动态地分配内存，如下所示： char* pvalue = NULL; // 初始化为 null 的指针 pvalue = new char[20]; // 为变量请求内存 要删除我们刚才创建的数组，语句如下： delete [] pvalue; // 删除 pvalue 所指向的数组 下面是 new 操作符的通用语法，可以为多维数组分配内存，如下所示： int ROW = 2; int COL = 3; double **pvalue = new double* [ROW]; // 为行分配内存 // 为列分配内存 for(int i = 0; i < COL; i++) { pvalue[i] = new double[COL]; } 释放多维数组内存： for(int i = 0; i < COL; i++) { delete[] pvalue[i]; } delete [] pvalue;
    • 对象的动态内存分配
      • 对象的动态内存分配 对象与简单的数据类型没有什么不同。例如，请看下面的代码，我们将使用一个对象数组来理清这一概念： #include <iostream> using namespace std; class Box { public: Box() { cout << "调用构造函数！" <<endl; } ~Box() { cout << "调用析构函数！" <<endl; } }; int main( ) { Box* myBoxArray = new Box[4]; delete [] myBoxArray; // Delete array return 0; } 如果要为一个包含四个 Box 对象的数组分配内存，构造函数将被调用 4 次，同样地，当删除这些对象时，析构函数也将被调用相同的次数（4次）。 当上面的代码被编译和执行时，它会产生下列结果： 调用构造函数！ 调用构造函数！ 调用构造函数！ 调用构造函数！ 调用析构函数！ 调用析构函数！ 调用析构函数！ 调用析构函数！
  • 信号处理
    • 信号定义
      • C++ 信号处理 信号是由操作系统传给进程的中断，会提早终止一个程序。在 UNIX、LINUX、Mac OS X 或 Windows 系统上，可以通过按 Ctrl+C 产生中断。 有些信号不能被程序捕获，但是下表所列信号可以在程序中捕获，并可以基于信号采取适当的动作。这些信号是定义在 C++ 头文件 <csignal> 中。 信号 描述 SIGABRT 程序的异常终止，如调用 abort。 SIGFPE 错误的算术运算，比如除以零或导致溢出的操作。 SIGILL 检测非法指令。 SIGINT 接收到交互注意信号。 SIGSEGV 非法访问内存。 SIGTERM 发送到程序的终止请求。
    • 信号接收函数signal()
      • signal() 函数 C++ 信号处理库提供了 signal 函数，用来捕获突发事件。以下是 signal() 函数的语法： void (*signal (int sig, void (*func)(int)))(int); 这个函数接收两个参数：第一个参数是一个整数，代表了信号的编号；第二个参数是一个指向信号处理函数的指针。 让我们编写一个简单的 C++ 程序，使用 signal() 函数捕获 SIGINT 信号。不管您想在程序中捕获什么信号，您都必须使用 signal 函数来注册信号，并将其与信号处理程序相关联。看看下面的实例： #include <iostream> #include <csignal> #include <windows.h> using namespace std; void signalHandler(int signum) { cout << "Interrupt signal (" << signum << ") received.\n"; // 清理并关闭 // 终止程序 exit(signum); } int main() { // 注册信号 SIGINT 和信号处理程序 signal(SIGINT, signalHandler); while (1) { cout << "Going to sleep...." << endl; Sleep(1); } return 0; } 当上面的代码被编译和执行时，它会产生下列结果： Going to sleep.... Going to sleep.... Going to sleep.... 现在，按 Ctrl+C 来中断程序，您会看到程序捕获信号，程序打印如下内容并退出： Going to sleep.... Going to sleep.... Going to sleep.... Interrupt signal (2) received.
    • 信号生成函数raise()
      • raise() 函数 您可以使用函数 raise() 生成信号，该函数带有一个整数信号编号作为参数，语法如下： int raise (signal sig); 在这里，sig 是要发送的信号的编号，这些信号包括：SIGINT、SIGABRT、SIGFPE、SIGILL、SIGSEGV、SIGTERM、SIGHUP。以下是我们使用 raise() 函数内部生成信号的实例： #include <iostream> #include <csignal> #include <Windows.h> using namespace std; void signalHandler(int signum) { cout << "Interrupt signal (" << signum << ") received.\n"; // 清理并关闭 // 终止程序 exit(signum); } int main() { int i = 0; // 注册信号 SIGINT 和信号处理程序 signal(SIGINT, signalHandler); while (++i) { cout << "Going to sleep...." << endl; if (i == 3) { raise(SIGINT); } Sleep(1); } return 0; } 当上面的代码被编译和执行时，它会产生下列结果，并会自动退出： Going to sleep.... Going to sleep.... Going to sleep.... Interrupt signal (2) received.
  • 多线程
    • C++ 多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。在一般情况下，有两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理处理的是程序的并发执行。基于线程的多任务处理的是同一程序的片段的并发执行。 多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。 C++ 不包含多线程应用程序的任何内置支持。相反，它完全依赖于操作系统来提供此功能。
  • Web编程
    • 公共网关接口CGI
      • CGI全称是“公共网关接口”(Common Gateway Interface)，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，其程序须运行在网络服务器上。
• C+关键字
  • 关键字(keyword)属于保留字，是整个语言范围内预先保留的标识符。每个C++关键字都有特殊的含义。经过预处理后，关键字从预处理记号(preprocessing-token)中区别出来，剩下的标识符作为记号(token)，用于声明对象、函数、类型、命名空间等。不能声明与关键字同名的标识符。
  • ISO C++ 98 关键字（共63个）
    • asm do if return typedef auto double inline short typeid bool dynamic_cast int signed typename break else long sizeof union case enum mutable static unsigned catch explicit namespace static_cast using char export new struct virtual class extern operator switch void const false private template volatile const_cast float protected this wchar_t continue for public throw while default friend register true delete goto reinterpret_cast try
  • nullptr
    • nullptr 字面量nullptr是具有std::nullptr_t类型的右值，是空指针常量。C++98/03中表示空指针常量的NULL或0都会在重载中引起混淆，而纯库的解决方案在这里也遇到困难，所以有必要加入新的关键字来专门表示空指针。
  • auto
    • auto C++11标准和C++98/03标准的auto是不同的。C++98/03标准中，auto表示自动储存类型； C++11标准中，auto表示由编译器静态判断其应有的类型。
• 设计模式
  • 设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
  • C++ 设计模式
  • 设计模式实现(Java、C++、Golang)
  • Design Patterns