9.2 构造函数和析构函数 类的组合 结构体与联合体 类的 UML 描述 第十讲 类与对象 (II) 面向对象进阶 对象的生存期 静态成员 友元关系

Transcription

1 C++ 笔记 ( 草稿 ) 潘建瑜 (jypan@math.ecnu.edu.cn) 第二讲 C++ 编程基础 C++ 语言概述 C++ 编程基础 C++ 简单输入输出... 4 第三讲 选择与循环 关系运算与逻辑运算 选择结构 循环结构... 6 第四讲 函数 函数的声明 定义与调用 函数间的参数传递 函数嵌套与内联函数 形参带缺省值的函数与函数重载 数据的作用域 预编译处理与多文件结构 第五讲 数组 一维数组 二维数组 数组作为函数参数 第六讲 指针与字符串数组 指针的定义与运算 指针与一维数组 指针与二维数组 指针与引用 指针与函数 持久动态内存分配 字符串 ( 字符数组 ) 第七讲 简单输入输出 I/O 流 C 语言格式化输出语句 C 语言文件读写 第八讲 排序算法及其实现 选择排序 插入排序 希尔排序 冒泡排序 快速排序 第九讲 类与对象 (I) 面向对象基础 类和对象基础 i

2 9.2 构造函数和析构函数 类的组合 结构体与联合体 类的 UML 描述 第十讲 类与对象 (II) 面向对象进阶 对象的生存期 静态成员 友元关系 常对象与常成员 对象数组与对象指针 向量类 :vector 字符串类 :string 第十一讲 运算符重载 为什么要重载运算符 怎么实现运算符重载 成员函数方式实现运算符重载 非成员函数方式实现运算符重载 简单自动类型转换 几点注记 第十二讲 继承与多态 继承与派生 派生类的定义 构造函数和析构函数 派生类成员的标识与访问 类型兼容规则 虚父类 多态 第十三讲 文件流与输出输入重载 输入输出流 文件流类与文件流对象 文件的打开与关闭 文件读写 : 文本文件与二进制文件 重载输出输入操作运算符 << 和 >> 附录 : 程序示例 ii

3 第二讲 C++ 编程基础 2.1 C++ 语言概述 C++ 的发展 1 C++ 是从 C 语言发展演变而来, 可以看成是 C 的超集 ; 年由 Bjarne Stroustrup 开发创建 ; 年正式取名为 C++,1989 年开始 C++ 的标准化工作 ; 年制定了 ANSI C++ 标准草案 ; 年由 ISO 批准为国际标准, 通称 C++98; 年 8 月发布 C C++ 源程序结构 1 一个 C++ 源程序由一个或多个源文件组成 ; 2 每个源文件可由一个或多个函数组成 ; 3 一个源程序有且只能有一个 main 函数, 即主函数 ; 4 程序执行从 main 开始, 在 main 中结束 ; 5 源程序中可以有预处理命令, 通常应放在源文件或源程序的最前面 ; 6 一行可以写多个语句, 一个语句可以分几行书写 C++ 源程序书写规范 1 每条语句须以分号 ; 结尾, 但预处理命令, 函数头和花括号 } 之后不能加分号 ; 2 标识符, 关键字之间至少加一个空格表示间隔, 若已有明显的间隔符, 也可不加 ; 3 区分大小写, 习惯用小写字母 ; 4 注释符 :// 和 /* */ ; 5 常用锯齿形书写格式 ; 6 所有标点符号必须在英文状态下输入 书写漂亮的程序 1 花括号 { } 要对齐 2 一行写一个语句, 一个语句写一行 ; 3 使用 TAB 缩进 ; 4 有足够的注释 ; 有合适的空行 编译器 1 编译器就是将 高级语言 翻译为机器语言 的程序 ; 2 一个现代编译器的主要工作流程 : 源代码 编译 目标代码 链接 可执行程序 ; 3 常见的 C++ 编译器 :Visual C++, GNU C++, Intel C++, ; 4 常用的 IDE ( 集成开发环境 ):Visual Studio,Dev C++,Code::Blocks, ; 1

4 2.2 C++ 编程基础 C++ 字符集 1 字母 ( 大写和小写, 共 52 个 ); 2 数字 (0 到 9 共 10 个 ); 3 空白符 ( 空格符 制表符 换行符 ); 4 标点和特殊字符 :+ - * / =! # % ^ & ( ) [ ] { } _ ~ < > \ ' " : ;.,? C++ 关键字 : 具有特定意义的字符串, 也称为保留字 1 包括 : 类型说明符 语句定义符 ( 控制命令 ) 预处理命令等; 2 参见 C++ 标识符 : 用来标识变量名 函数名 对象名等的字符序列 : 1 由字母 数字 下划线组成, 第一个字符必须是字母或下划线 ; 2 区分大小写, 不能用关键字 ; 3 C++ 不限制标识符长度, 实际长度与编译器有关, 一般不要超过 32 个字母 ; 4 命名原则 : 见名知意 不宜混淆 C++ 分隔符 : 逗号 冒号 分号 空格 ( ) { } C++ 注释符 1 单行注释 :// 2 块 ( 多行 ) 注释 :/* */ C++ 数据类型 1 基本数据类型 : 整型, 实型, 字符型 (char) 和布尔型 (bool); 整型 :int, short, long, unsigned int, unsigned short, unsigned long 实型 :float, double, long double 2 扩展 / 构造数据类型 : 数组, 指针, 枚举, 结构, 类, 等等 3 C++ 标准没有规定每种数据类型的字节数和表示范围, 只规定大小顺序, 具体长度由处理器和编译器决定 C++ 数据类型的转换 1 自动转换 / 隐式转换 : 相同类型的数据进行运算时, 结果仍然是同一数据类型不同类型的数据进行运算, 需先转换成同一类型转换按数据长度增加的方向进行, 以保证精度不降低所有的浮点运算都是以双精度进行的 char 型和 short 型参与运算时, 必须先转换成 int 型赋值号两边的数据类型不同时, 右边的类型将转换为左边的 2 强制转换 / 显示转换 : 类型说明符 ( 表达式 ) C++ 风格, 将表达式的值转化为指定的数据类型 ( 类型说明符 ) 表达式 C 风格, 作用同上 3 类型转换不会改变变量的数据类型! 4 类型转换规则 : 浮点型转整型 : 直接丢掉小数部分 ; 字符型转整型 : 取字符的 ASCII 码 ; 整型转字符型 :ASCII 对应的字符 C++ 变量 : 存储数据, 值可以改变 1 变量名 : 命名规则与标识符相同 2 变量必须先声明, 后使用 ; 先赋值, 后使用 2

5 3 变量声明 : 数据类型变量名列表 ; 可以同时声明多个变量, 用逗号隔开 ; 变量声明时可以初始化 : 两种方式 ( 赋值运算符和小括号 ) C++ 常量 ( 常数 ): 在程序运行中值不能改变的量 1 整型常量 : 整数, 后面加 l 或 L 表示长整型, 后面加 u 或 U 表示无符号整型 ; 2 实型常量 : 缺省为双精度实数, 后面加 f 或 F 表示单精度, 加 l 或 L 表示 long double; 3 字符型常量 : 用单引号括起来的单个字符和转义字符 ; 4 字符串常量 : 用双引号括起来的字符序列 ; 5 布尔常量 :true 和 false C++ 符号常量 : 用标识符代表常量 1 声明方式 :const 数据类型变量名 = 常量值 ; 2 符号常量在声明时必须初始化 ; 3 符号常量的值在程序中不能被修改 ( 不能重新赋值 ) typedef: 为一个已有的数据类型另外命名 ( 取别名 ) enum: 枚举, 定义新的数据类型 enum 枚举类型名 { 变量可取值列表, 即枚举元素 }; 1 对枚举元素按常量处理, 不能对它们赋值 2 枚举元素具有默认值, 依次为 :0, 1, 2,...; 3 也可以在声明时指定枚举元素的值, 如 : enum weekday {sun=7,mon=1,tue,wed,thu,fri,sat}; 4 枚举值可以进行关系运算 ; 5 整数值不能直接赋给枚举变量, 需进行强制类型转换 C++ 运算符 1 算术运算符 :+ - * / % ++ ( 自增 ) -- ( 自减 ) 2 赋值运算符 := += -= *= /= %= &= = ^= >>= <<= 3 逗号运算符 :, ( 把若干表达式组合成一个表达式 ) ; 4 关系运算符 : 用于比较运算,> < == >= <=!= 5 逻辑运算符 : 用于逻辑运算,&&! 6 条件运算符 : 是一个三目运算符, 用于条件求值 (? : ) 7 求字节数运算符 :sizeof ( 计算数据类型所占的字节数 ) 8 位操作运算符 : 按二进制位进行运算,& ~ ^ ( 异或 ) << ( 左移 ) >> ( 右移 ) 9 指针运算符 :* ( 取内容 ) & ( 取地址 ) C++ 运算符优先级 : 参见 C++ 语句 1 空语句 ( 只有分号 ) 2 声明语句 ; 3 表达式语句 ( 赋值表达式 ); 4 复合语句 ( 将多个语句用 { } 括起来组成的一个语句 ); 5 选择语句, 循环语句, 跳转语句 ; 6 C++ 表达式与表达式语句 1 表达式 : 由运算符连接常量 变量 函数等所组成的式子 ; 2 表达式语句 : 表达式后加分号 ; 3 表达式中的运算符包含赋值运算符 ; 赋值表达式的值是赋值号左边变量的值 ; 3

6 4 表达式可以包含在其它表达式中, 但语句不行! C++ 赋值语句 1 标准赋值语句 : 变量 = 表达式 ; 2 自增自减 :++, -- 前置 : 先自增自减, 然后使用 ; 后置 : 先使用, 然后自增自减 不要在同一语句中包含一个变量的多个 ++ 或 --, 因为它们的解释在 C/C++ 标准中没有 规定, 完全取决于编译器的个人行为 ; 3 复合赋值运算符 :+= -= *= /= %= C++ 逗号运算符 : 表达式 1, 表达式 2 1 先计算表达式 1, 再计算表达式 2, 并将表达式 2 的值作为整个表达式的结果 求字节数运算符 :sizeof( 数据类型 ) 或 sizeof( 表达式 ) 常用数学函数 ( 需加入 cmath 头文件 : #include <cmath>) abs(x) 绝对值 sqrt(x) 平方根 exp(x) 指数函数 power(x,y) x y log(x) 对数函数 ln log10(x) 对数函数 取整函数 ceil, floor, round, trunk 三角函数 sin, cos, tan, asin, acos, atan 双曲三角函数 sinh, cosh, tanh, asinh, acosh, atanh 2.3 C++ 简单输入输出 C++ 输入 / 输出 :cin cout 常用转义字符 :\n \t \\ \ \ 输入运算符与输出运算符 : >> << 常用操纵符 ( 需加入头文件 iomanip: #include <iomanip>) 操纵符 含义 endl 插入换行符, 并刷新流 ( 将缓冲区中的内容刷入输出设备 ) setw(n) cout.width(n) setfill(c) cout.fill(c) fixed scientific 设置域宽 设置填充,c 可以是任意字符, 缺省为空格, 如 setfill('*'), setfill('0') 使用定点方式输出 使用指数形式 setprecision(n) 设置输出的有效数字个数 ; left 若在 fixed 或 scientific 后使用, 则设置小数位数 左对齐 right 右对齐 ( 缺省方式 ) showpoint 显示小数点和尾随零, 即使没有小数部分 作用范围 :setw 对紧随其后的输出起作用 ; 其它操纵符 : 至下一个同类型命令为止 4

7 第三讲 选择与循环 3.1 关系运算与逻辑运算 关系运算, 即比较大小 :> < == >= <=!= 1 结论是真则返回 true, 否则返回 false; 2 C++ 中用 1 表示 true,0 表示 false; 3 bool 型变量的值为 0 时表示 false, 其他它值都表示 true; 4 注意 == 与 = 的区别 ; 5 对浮点数进行比较运算时尽量不要使用等于 逻辑运算 :&&! 1 ( 表达式 1) && ( 表达式 2) 先计算表达式 1 的值, 若是 true, 再计算表达式 2 的值 ; 若表达式 1 的值是 false, 则不再计算表达式 2 的值 ; 2 ( 表达式 1) ( 表达式 2) 先计算表达式 1 的值, 若是 false, 再计算表达式 2 的值 ; 若表达式 1 的值是 true, 则不再计算表达式 2 的值 ; 3 优先级 :! 优于 && 优于 条件运算符 :? : 即条件表达式? 表达式 1 : 表达式 2 1 条件表达式为真时返回表达式 1 的值, 否则返回表达式 2 的值 ; 2 表达式 1 和表达式 2 的类型要一致 3 这是 C++ 中惟一的三目运算符 3.2 选择结构 选择结构的两种实现方式 :if 和 switch if 语句 1 单分支 : if ( 表达式 ) 语句 2 双分支 : if ( 表达式 ) 语句 else 语句 3 多分支 : if ( 表达式 ) 语句 else if ( 表达式 ) 语句 else if ( 表达式 ) 语句 else 语句 4 这里的语句可以是复合语句 5 if 语句可以嵌套 6 嵌套时每一层 if 都要和 else 配套, 若没有 else, 则需将该层 if 语句用 { } 括起来 switch 结构 switch( 表达式 ) // 该表达式可以是整型 字符型 枚举型 { case 常量表达式 1: 语句 case 常量表达式 2: 语句

8 case 常量表达式 n: 语句 default: 语句 } 1 以 case 中的常量表达式值为入口标号, 由此开始顺序执行 2 每个 case 分支最后一般需要加 break 语句 3 每个 case 后面的常量表达式的值不能相同 4 每个 case 后面可以有多个语句 ( 复合语句 ), 但可以不用 { } 3.3 循环结构 循环结构的三种实现方式 :while,do while 和 for 循环可以嵌套 while 循环 while( 条件表达式 ) { } 循环体语句 1 执行过程 (1) 判断条件表达式的值 (2) 如果是 真, 则执行循环体语句 ; 否则退出循环 (3) 返回第一步 2 如果循环体语句是复合语句, 别忘了大括号! do { 循环体语句 } while( 条件表达式 ); 1 执行过程 (1) 执行循环体语句 (2) 判断条件表达式的值, 如果是 真, 返回第一步 ; 否则退出循环 2 与 while 循环的区别 : 无论条件是否成立, 循环体语句至少执行一次 for 循环 for( 初始化语句 ; 表达式 1; 表达式 2) { } 循环体语句 1 执行过程 (1) 执行初始化语句 (2) 计算表达式 1 的值, 如果是 真, 则执行循环体语句, 否则退出循环 (3) 执行表达式 2, 返回第二步 2 初始化语句, 表达式 1, 表达式 2 均可省略, 但分号不能省 3 表达式 1 是循环控制语句, 如果省略的话就构成死循环 4 循环体可以是单个语句, 也可以是复合语句 ( 大括号!) 5 初始化语句与表达式 2 可以是逗号语句 6 若省略初始化语句和表达式 2, 只有表达式 1, 则等同于 while 循环 6

9 7 for 循环有时也可以描述为 for( 循环变量赋初值 ; 循环条件 ; 循环变量增量 ) { } 循环体语句 1 循环变量可以在初始化语句中声明, 这样, 循环变量只在该循环内有效, 循环结束后, 循环变量即被释放 循环终止 break // 跳出循环体, 但只能跳出一层循环 continue // 结束本轮循环, 执行下一轮循环 goto // 跳转语句, 建议尽量不使用 1 break,continue 和 goto 通常与 if 语句配合使用 7

10 第四讲 函数 4.1 函数的声明 定义与调用 C++ 程序必须有且只能有一个 main 函数 类型标识符函数名 ( 形式参数表 ) // 函数头 { } 函数体 1 类型标识符 指明了本函数的类型, 即函数返回值的类型, 若没有返回值, 则用 void 2 函数返回值通过 return 语句给出 3 若没有返回值, 可以不写, 也可以写不带表达式的 return 形式参数列表 类型标识符变量, 类型标识符变量, 形式参数表 ( 形参 ) 要指定数据类型 2 有多个形参时, 用逗号隔开, 每个形参需单独指定数据类型 3 如果函数不带参数, 则形式参数可以省略, 但括号不能省 4 形参只在函数内部有效 / 可见, 即属于函数局部变量 函数的调用 1 函数调用前须先声明 : 可以在调用函数中, 或程序文件中所有函数之外声明 2 函数的调用方式 : 函数名 ( 实参数表 ) 3 被调函数可以出现在表达式中, 此时必须要有返回值 4 主调函数与被调函数 : 被调函数在主调函数前定义, 则可直接调用, 否则必须先声明 4.2 函数间的参数传递 值传递 : 1 传递时是将实参的值传递给对应的形参, 即单向传递 2 形参只在函数被调用时才分配存储单元, 调用结束即被释放 3 实参可以是常量 变量 表达式 函数 ( 名 ) 等, 但它们必须要有确定的值 4 实参和形参在数量 类型 顺序上应严格一致 5 形参获得实参传递过来的值后, 便与实参脱离关系 引用传递 : 引用的声明与使用 & 1 引用是一种特殊类型的变量, 可看作是变量的别名 2 声明一个引用时必须初始化, 指向一个存在的对象 3 引用一旦初始化就不能改变, 即不能再作为其它对象的引用 ( 别名 ) 4 若引用作为形参, 则调用函数时才会被初始化, 此时形参是实参的一个别名, 对形参的任何操作也会直接作用于实参 4.3 函数嵌套与内联函数 函数的嵌套调用 1 函数可以嵌套调用, 但不能嵌套定义 2 函数也可以递归调用 ( 函数可以直接或间接调用自己 ) 3 对同一个函数的多次不同调用中, 编译器会给函数的形参和局部变量分配不同的空间, 它们互不影响 内联函数 1 关键字 inline 8

11 2 编译时在调用处用函数体进行替换 3 使用内联函数能节省参数传递 控制转移等开销, 提高代码的执行效率 4 内联函数通过应该功能简单 规模小 使用频繁 5 内联函数体内不建议使用循环语句和 switch 语句 6 有些函数无法定义成内联函数, 如递归调用函数等 4.4 形参带缺省值的函数与函数重载 形参缺省值 1 函数在定义时可以预先给出缺省的形参值, 调用时如给出实参, 则采用实参值, 否则采用预先给定的形参缺省值 2 特点 : 调用时可以不提供或提供部分实参 形参缺省值的声明次序 1 形参缺省值必须从右向左顺序声明 2 在形参缺省值的右面不能有不带缺省值的形参, 因为参数传递是从左向右依次进行的 3 当被调函数在主调函数之前定义时, 形参缺省值须在函数定义时给出 4 当被调函数在主调函数之后定义时, 形参缺省值须在函数声明时给出 5 在同一个作用域内, 形参缺省值的说明应保持惟一 6 在不同作用域内, 允许设置不同的缺省值 函数重载 : 两个以上的函数, 具有相同的函数名, 但形参的个数或类型不同, 编译器会根据实参和形参的个数和类型的最佳匹配, 自动确定调用哪一个函数 1 功能相近的函数在相同的作用域内以相同函数名声明, 方便使用, 便于记忆 2 重载函数特点 : 函数名必须相同, 形参必须不同 ( 个数不同或类型不同 ) 3 函数名相同, 形参个数与类型相同, 函数返回值类型不同, 不形成重载, 是语法错误! 4 不要将功能不同的函数定义为重载函数 5 在使用带有默认形参的重载函数时, 要注意防止二义性! 4.5 数据的作用域每个变量都有作用域, 即在程序中哪些地方可以引用该变量 数据的作用域 : 数据在程序中有效的区域,C++ 的作用域 1 函数原型作用域 : 函数原型声明时形参的作用范围, 变量名可省略, 但类型不能省! 2 局部作用域 ( 局部变量, 语句块, 类, 函数等 ) 3 命名空间作用域 ( 全局变量 ) 4 类作用域 局部变量与全局变量 1 函数定义时的形参, 或函数中定义的变量均为局部变量, 只在该函数内有效 ; 2 语句块中定义的变量是局部变量, 只在该语句块中有效 ; 3 for 循环的初始语句中定义的变量也是局部变量, 只在 for 循环中有效 ; 4 在所有函数外定义的变量为全局变量, 在它后面定义的函数中均可以使用 ; 若要在它前面定义的函数中使用该全局变量, 则需声明其为外部变量 extern 类型名变量名 ; 5 若局部变量与全局变量同名, 则优先使用局部变量! 作用域解析运算符 :: 若存在同名的局部变量和全局变量, 则缺省引用局部变量, 此时若需引用全局变量, 需在变量名前加作用域解析运算符 名字空间 namespace 9

12 大型程序通常由不同模块组成, 不同模块中的类和函数可能存在重名 为解决这个问题, C++ 引入命名空间概念 namespace 名字空间名 { 名字空间内的各种声明, 包括函数声明, 类声明等 } 1 名字空间内的元素, 可以是类 函数 变量等, 均称为名字 2 名字空间的使用 :using 3 可以将名字空间中的所有名称都导入到当前作用域中, 也可以只导入指定的某个名称 4 标准库的所有函数 类 对象等, 都在 std 名字空间中 可见性 1 可见性是指对标识符 ( 变量, 函数等 ) 是否可以引用 2 如果标识符在某处可见, 则就可以在该处引用此标识符 3 对于两个嵌套的作用域, 若内层作用域内定义了与外层作用域中同名的标识符, 则外层作用域的标识符在内层不可见 生存期 1 静态生存期 : 生存期与程序的运行期相同, 即一直有效 2 动态生存期 : 当对象所在的程序块执行完后即消失 3 静态变量和全局变量 : 静态生存期 4 动态变量 : 动态生存期 5 局部变量缺省为动态变量 静态变量 1 静态局部变量不会随函数的调用结束而消失, 下次调用该函数时, 该变量会保持上次调用后的值 2 没有初始化的静态变量会自动初始化为 0 3 静态变量只能初始化一次 4.6 预编译处理与多文件结构 头文件 #include < 文件名 > // 按标准方式导入头文件, 即在系统目录中寻找指定的文件 #include " 文件名 " // 先在当前目录中寻找, 然后再按标准方式搜索 条件编译 #if 常量表达式程序正文 #endif // 当 常量表达式 非零时编译 #if 常量表达式程序正文 #else 程序正文 #endif // 当 常量表达式 非零时编译 // 否则编译这段程序 #if 常量表达式 1 程序正文 // 当 常量表达式 1 非零时编译 10

13 #elif 常量表达式 2 程序正文 // 否则, 当 常量表达式 2 非零时编译 #elif 常量表达式 3 程序正文 // 否则, 当 常量表达式 3 非零时编译 #else #endif 程序正文 // 否则编译这段程序 #ifdef 标识符程序正文 #else 程序正文 #endif // 当 标识符 已由 #define 定义时编译 // 否则编译这段程序 #ifndef 标识符程序正文 #else 程序正文 #endif // 当 标识符 没有定义时编译 // 否则编译这段程序 多文件结构一个程序可以由多个文件组成, 编译时可以使用工程 / 项目来组合 若使用命令行编译, 则需要同时编译 外部变量 : 如果需要用到其它文件中定义的变量, 则需要用 extern 声明其为外部变量 extern 类型名变量名 ; 外部函数 : 如果需要用到其它文件中定义的函数, 则需要用 extern 声明其为外部函数 extern 函数声明 ; 系统函数 1 标准 C++ 函数 ( 库函数 ): 参见 cppreference.com 2 非标准 C++ 函数 : 操作系统或编译环境提高的系统函数 3 充分使用库函数可以大大减少编程工作量, 提高代码可靠性和执行效率 11

14 第五讲 数组 数组 : 具有一定顺序关系的若干相同类型变量的集合体 5.1 一维数组 一维数组的声明类型标识符数组名 [n] // 声明一个长度为 n 的一维数组 ( 向量 ) 1 数组名代表数组存放在内存中的首地址 2 n 为数组的长度, 即元素的个数, 可以是一个表达式, 但值必须是一个确定的正整数 一维数组的引用数组名 [k] // 注 : 下标 k 的取值为 0 到 n-1 1 注意 : 数组的下标不能越界, 否则可能会引起严重的后果! 2 只能逐个引用数组元素, 而不能一次引用整个数组 3 数组元素在内存中顺序存放, 它们的地址是连续的 一维数组的初始化 : 在声明时可以同时赋初值 1 全部元素都初始化时可以不指定数组长度 2 可以部分初始化, 即只给部分元素赋初值 3 若数组声明时进行了部分初始化, 则没有初始化的元素自动赋值为 0 4 声明数组时, 若长度为一个表达式, 且含有变量, 则不能初始化! 5 注意 : 只能对数组元素赋值, 不能对数组名赋值! 6 若数组元素没有赋值, 则其值是不确定的 ( 静态数据类型除外 ); 7 注意 : 数组声明与数组引用的区别 ; 初始化与赋值的区别 5.2 二维数组 二维数组的声明类型标识符变量名 [m][n] // 声明一个长度为 m x n 的二维数组 ( 矩阵 ) 二维数组的引用变量名 [i][j] // 注意下标不要越界 二维数组的存储 : 按行存储在 C++ 中, 二维数组可以看作是由一维数组组成的数组 二维数组的初始化 1 全部初始化时只能省略第一维的长度 2 可以分组初始化, 也可以部分初始化 多维数组 : 多维数组的赋值 引用 初始化与二维数组类似类型标识符变量名 [n1][n2][n3] 5.3 数组作为函数参数 数组中的单个元素作实参 : 与单个变量一样, 采用值传递 数组名作为参数 : 地址传递, 即传递的是数组的首地址 1 形参后面要加中括号, 但可以不指定第一维的大小 2 形参和实参都应该是数组名, 类型要一致 3 实参与形参代表的是同一个数组, 在函数中对形参的任何改动都会影响到实参 4 数组作为形参时一般不指定大小, 此时需要加一个参数, 用来传递实参数组的大小 5 若形参数组的大小中含有变量, 则必须是常量 函数调用时, 只需输入数组名即可 12

15 第六讲 指针与字符串数组 6.1 指针的定义与运算指针变量, 简称指针, 用来存放其它变量的内存地址 指针的定义类型标识符 * 指针变量名 1 类型标识符表示该指针所指向的对象的数据类型 指针的两个基本运算 1 提取变量的内存地址 :& 变量名 2 提取指针所指向的变量的值 :* 指针 指针的初始化 : 声明指针变量时, 可以赋初值 指针的赋值 1 指针的类型必须与其指向的对象的类型一致 2 给指针赋值时, 只能使用以下的值 (1) 空指针 :0,NULL 或值为 0/NULL 的常量 ; (2) 类型匹配的某个对象的地址 ; (3) 同类型的另一个有效指针 ; 3 没有初始化或赋值的指针是无效的指针, 引用无效指针会带来难以预料的问题 4 在使用指针时, 我们通常关心的是指针指向的元素 void 类型的指针 void * 指针名 1 void 类型的指针可以存储任何类型的对象的地址 2 不允许使用 void 指针操纵它所指向的对象 3 必须通过显式类型转换, 才可以访问 void 类型指针所指向的对象 指向常量的指针 const 类型标识符 * 指针名 1 指向常量的指针必须用 const 声明 2 这里的 const 限定了指针所指对象的属性, 不是指针本身的属性 3 允许把非 const 对象的地址赋给指向常量的指针 4 但不允许使用指向常量的指针来修改它所指向的对象的值 常量指针, 简称常指针 : 指针本身的值不能修改类型标识符 * const 指针名 指向常量的常指针 const 类型标识符 * const 指针名 1 指针本身的值不能修改, 其指向的对象的值也不能修改 指针运算 1 指针可以和整数或整型变量进行加减运算, 运算规则与指针的类型有关! 2 在指针上加上或减去一个整型数值 k, 等效于获得一个新指针, 该新指针指向原来的元素之后或之前的第 k 个元素 3 一个指针可以加上或减去 0, 其值不变 4 指针与数组密切相关 : 由于数组元素是连续存储的, 因此使用指针可以非常方便地处理数组元素! 5 数组名就是数组的首地址 6 当数组名出现在表达式中时, 会自动转化成指向第一个数组元素的指针 13

16 6.2 指针与一维数组 引用数组元素的三种方式 1 数组名与下标, 如 :a[0] 2 数组名与指针运算, 如 :*(a+1) 3 指针, 如 :int * pa=a; *pa 一维数组指针 1 数组名 a 是地址常量, 数组名 a 与 &a[0] 等价 ; 2 a+i 是 a[i] 的地址,a[i] 与 *(a+i) 等价 ; 3 设指针 pa 存储的是数组 a 的首地址, 则 *(pa+i) 与 pa[i] 等价 ; 4 指针的值可以随时改变, 即可以指向不同的元素 ; 5 数组名是常量指针, 值不能改变 6 pa++ 或 ++pa 合法, 但 a++ 不合法 ; 7 a[i] <=> pa[i] <=> *(pa+i) <=> *(a+i) 指针数组 1 由指针变量组成的数组 2 指针数组的声明类型标识符 * 指针数组名 [n] 6.3 指针与二维数组 1 C++ 中, 二维数组是按行存储的, 可以理解为由一维数组组成的数组 2 引用二维数组的元素可以通过数组名和指针运算进行 3 对于二维数组 A, 虽然 A A[0] 都是数组首地址, 但二者指向的对象不同 : (1) A[0] 是一维数组的名字, 它指向的是行数组 A[0] 的首元素, 对其进行 * 运算时, 得到的是 A[0] 的首元素的值, 即 *A[0] 与 A[0][0] 是相同的 ; (2) 而 A 是一个二维数组的名字, 它指向的是它的首元素, 而它的元素都是一维数组 ( 即行数组 ), 因此, 它的指针移动单位是 行, 所以 A+i 指向的是第 i 个行数组, 即指向 A[i] 对 A 进行 * 运算时, 得到的是一维数组 A[0] 的首地址, 即 *A 与 A[0] 是相同的 5 当用 int * p 声明指针 p 时,p 只能指向一个 int 型数据, 而不是一个地址, 因此, p=a[0] 是正确的, 而用 p=a 是错误的! 6 设指针 pa=&a[0][0], 则 A[i][j] <=> *(pa+n*i+j) // 假定 A 的列数为 n 行指针 ( 略 ) 6.4 指针与引用 1 引用是变量的别名, 必须初始化, 且不能修改 2 引用只针对变量, 函数没有引用 3 引用能实现的功能, 用指针都能实现 引用作为函数参数的优点 1 传递方式与指针类似, 但可读性强 ; 2 函数调用比指针更简单 安全 ; 6.5 指针与函数 指针作为函数参数 1 指针作为函数参数时, 以地址方式传递数据 2 形参是指针时, 实参可以是指针或地址 14

17 3 当函数间需要传递大量数据时, 开销会很大 此时, 如果数据是连续存放的, 则可以 只传递数据的首地址, 这样就可以减小开销, 提高执行效率 4 可以传递函数代码的首地址 ( 函数指针 ) 5 如果在被调函数中不需要改变指针所指向的对象的值, 则可以将形参中的指针声明为 指向常量的指针 指针型函数 1 当函数的返回值是地址时, 该函数就是指针型函数 2 指针型函数的定义 数据类型 * 函数名 ( 形参列表 ) { } 函数体 指向函数的指针, 即函数指针 1 在程序运行过程中, 不仅数据要占用内存空间, 函数也要在内存中占用一定的空间 2 函数名就代表函数在内存空间中的首地址 3 用来存放这个地址的指针就是指向该函数的指针 4 函数指针的定义 : 数据类型 (* 函数指针名 )( 形参列表 ) 5 这里的数据类型和形参列表应与其指向的函数相同 6 函数名除了表示函数的首地址外, 还包括函数的形参, 返回值类型等信息 7 可以象使用函数名一样使用函数指针 6.6 持久动态内存分配 1 每个程序在执行时都会占用一块可用的内存, 用于存放动态分配的对象, 此内存空间 称为自由存储区 (free store) 或堆 (heap) 申请单个存储单元 px = new 数据类型 ; px = new 数据类型 ( 初始值 ); 1 申请用于存放指定数据类型数据的内存空间 2 若申请成功, 则返回该内存空间的首地址, 并赋给指针 px 3 若申请不成功, 则返回 0 或 NULL 释放由 new 申请的存储单元 delete px; 1 px 必须是由 new 操作的返回值 创建一维动态数组 px = new 数据类型 [ 数组长度 ]; px = new 数据类型 [ 数组长度 ](); // 赋初值 0 1 这里初始化时只能将全部元素设置为 0, 而不能象数组变量那样用初始化列表赋初值 (C++11 新标准已加入该功能 ) 创建多维动态数组 px = new 数据类型数据类型 [n1][n2]...[nm]; 动态数组的释放 delete[] px; 15

18 6.7 字符串 ( 字符数组 ) 1 字符串的表示 : 字符数组 2 字符串以 "\0" 为结束标志 3 使用字符串常量初始化时时, 会自动添加结束标志 字符串的输出 cout << 字符串数组名 ; 1 输出字符串中不含 "\0" 2 可使用下标输出单个字符 字符串的输入 cin >> 字符串数组名 ; // 输入单个字符串, 中间不能有空格 getchar(); // 输入单个字符 cin.getline(str,n, 结束符 ); 1 cin.getline 连续输入多个字符 ( 可以有空格 ) 直到读入 N-1 个字符为止, 或遇到指 定的结束符 不存储结束符, 结束符可以省略, 缺省为 '\n' ( 换行符 ) 字符串相关函数 ( 头文件 cstring 和 cstdlib) strlen 求字符串长度 strlen(str) strcat 字符串连接 strcat(dest,src) strcpy 字符串复制 strcpy(dest,src) strcmp 字符串比较 strcmp(str1,str2) atoi 将字符串转换为整数 atoi(str) atol 将字符串转换为 long atol(str) atof 将字符串转换为 double atof(str) itoa 将整数转换为字符串 itoa(int,str,raidx) 1 这些函数只能作用在字符串上, 不能作用在字符上 C++ 字符检测函数 ( 头文件 cctype) isdigit 是否为数字 isdigit('3') isalpha 是否为字母 isalpha('a') isalnum 是否为字母或数字 isalnum('c') islower 是否为小写 islower('b') isupper 是否为大写 isupper('b') isspace 是否为空格 isspace(' ') isprint 是否为可打印字符, 包含空格 isprint('a') isgraph 是否为可打印字符, 不含空格 isgraph('a') ispunct 除字母数字空格外的可打印字符 ispunct('*') iscntrl 是否为控制符 iscntrl('\n') tolower 将大写转换为小写 tolower('a') toupper 将小写转换为大写 toupper('a') 1 以上检测和转换函数只针对单个字符, 而不是字符串 字符与整数的运算 1 字符参加算术运算时, 自动转换为整数 ( 按 ASCII 码转换 ) 16

19 第七讲 简单输入输出 7.1 I/O 流 预定义的四个输入输出对象 ( 头文件 iostream) cin 标准输入 ( 键盘等 ) cout 标准输出 ( 屏幕 打印机等 ) cerr 标准错误输出, 没有缓冲, 立即被输出 clog 与 cerr 类似, 但有缓冲, 缓冲区满时被输出 操纵符 ( 头文件 iomanip) endl 插入换行符, 并刷新流 setw(n) 设置域宽, 若数据超过设置的宽度, 则显示全部值 cout.width(n) 设置域宽, 若数据超过设置的宽度, 则显示全部值 setfill( 字符 ) 设置填充字符, 缺省为空格 cout.fill( 字符 ) 设置填充字符, 缺省为空格 left 左对齐 right 右对齐, 缺省右对齐 fixed 使用定点方式输出 scientific 使用指数形式 setprecision(n) 设置输出的有效数字个数 ; 若在 fixed 或 scientific 后使用, 则设置小数位数 showpoint 显示小数点及尾随零, 即使没有小数部分 1 除 setw 和 cout.width 外, 其它操纵符一直有效, 直到遇到相同类型的操纵符为止 7.2 C 语言格式化输出语句 printf( 格式控制字符串, 输出变量列表 ); // 加头文件 cstdio 1 格式控制字符串 : 普通字符串 格式字符串 转义字符 2 格式字符串 : 以 % 开头, 后面跟格式说明符和其它选项 %[flag][ 输出最小宽度 ][. 精度 ] 格式说明符 常见的格式说明符 c 字符型 g 浮点数 ( 自动 ) d 十进制整数 o 八进制 e 浮点数 ( 科学计数法 ) s 字符串 f 浮点数 ( 小数形式 ) x/x 十六进制 常见转义字符 ( 输出特殊符号 ) \b 退后一格 \t 水平制表符 \f 换页 \\ 反斜杠 \n 换行 \" 双引号 \r 回车 %% 百分号 17

20 7.3 C 语言文件读写 文件读写基本步骤 : 打开文件 读取或写入 关闭文件 文件指针 : FILE *pf; 文件打开 pf=fopen( 文件名, 打开方式 ); 1 文件名 : 普通字符串 2 打开方式 : 读 写 文本文件 二进制文件 rt wt at rb wb ab rt+ wt+ at+ rb+ wb+ ab+ r 为读,w 为写,+ 为读写,t 为文本,b 为二进制 3 若文件打开成功, 返回指向文件的指针 ; 若打开失败, 则返回一个空指针 (NULL) 文件关闭 :fclose(pf); 1 正常关闭返回值为 0; 出错时, 返回值为非 0 写文本文件 fprintf(pf, " 格式控制字符串 ", 输出变量列表 ); 1 fprintf 的用法与 printf 类似 读文本文件 fscanf(pf, " 格式控制字符串 ", 地址列表 ); 写二进制文件 fwrite(buffer, size,count,pf); 将 count 个长度为 size 的连续数据写入到 pf 指向的文件中,buffer 是这些数据的首地址 ( 可以是指针或数组名 ) 读二进制文件 fread(buffer, size,count,pf); 从 pf 指向的文件中读取 count 个长度为 size 的连续数据,buffer 是存放这些数据的首地址 ( 可以是指针或数组名 ) 二进制文件读写示例 int A[3][3]={{11,12,13},{21,22,23},{31,32,33}}; FILE *pf; pf=fopen("data1.dat","wb"); fwrite(a,sizeof(int),9,pf); // fwrite(a,sizeof(a),1,pf); fclose(pf); int B[3][3]; pf=fopen("data1.dat","rb"); fread(b,sizeof(int),9,pf); fclose(pf); 18

21 第八讲 排序算法及其实现 8.1 选择排序 基本思想找出最小值, 将其与第一个位置的元素进行交换, 然后对剩余的序列重复以上过程, 直至排序结束 8.2 插入排序 基本思想 1 假设前面 k 个元素已经按顺序排好了 2 排第 k+1 个元素时, 将其插入到前面已排好的 k 个元素中, 使得插入后得到的 k+1 个元素组成的序列仍按值有序 3 然后采用同样的方法排第 k+2 个元素 4 以此类推, 直到排完序列的所有元素为止 关键点 1 如何将第 k+1 个元素插入到前面的有序序列中 2 策略 : 依次与其左边的元素进行比较, 直至遇见第一个不大于它的元素为止 优化 : 可以将比较与移位同时进行 8.3 希尔排序 1 又称为 缩小增量排序, 由 D. Shell 于 1959 年提出, 是对插入排序的改进 基本过程 1 把序列按照某个增量 (gap) 分成几个子序列, 对这几个子序列进行插入排序 2 不断缩小增量, 扩大每个子序列的元素数量, 并对每个子序列进行插入排序 3 当增量为 1 时, 子序列就是整个序列, 而此时序列已经基本有序了, 因此只需做少量的比较和移动就可以完成对整个序列的排序 出发点 1 插入排序在元素基本有序的情况下, 效率很高 2 gap: 初始值设为 n/2, 然后不断减半 8.4 冒泡排序 基本过程描述如下 : 1 走访需要排序的序列, 比较相邻的两个元素, 如果他们的顺序错误就把他们交换过来 2 不断重复上述过程, 直到没有元素需要交换, 排序结束 3 这个算法的名字由来是因为越大的元素会经由交换慢慢 浮 到数列的顶端 具体过程 1 将第 1 个和第 2 个元素进行比较, 如果前者大于后者, 则交换两者的位置, 否则位置不变 ; 2 然后将第 2 个元素与第 3 个元素进行比较, 如果前者大于后者, 则交换两者的位置, 否则位置不变 ; 3 依此类推, 直到最后两个元素比较完毕为止 这就是第一轮冒泡过程, 这个过程结束后, 最大的元素就 浮 到了最后一个位置上 4 对前面 n-1 个元素进行第二轮冒泡排序, 结束后, 这 n-1 个元素中的最大值就被安 19

22 放在了第 n-1 个位置上 5 对前面的 n-2 个元素进行第三轮冒泡排序 6 以此类推, 当执行完第 n-1 轮冒泡过程后, 排序结束 冒泡排序的优化如果在某轮冒泡过程中没有发生元素交换, 这说明整个序列已经排好序了, 这时就不用再进行后面的冒泡过程, 可以直接结束程序 冒泡排序的进一步优化如果有 100 个数的数组, 仅前面 10 个无序, 后面 90 个都已排好序且都大于前面 10 个数字, 那么在第一轮冒泡过程后, 最后发生交换的位置必定小于 10, 且这个位置之后的数据必定已经有序了, 记录下这位置, 第二次只要从数组头部遍历到这个位置就可以了 8.5 快速排序 是目前最常用的排序算法之一快速排序采用的是分而治之思想 : 将原问题分解为若干个规模更小但结构与原问题相似的子问题, 然后递归求解这些子问题, 最后将这些子问题的解组合为原问题的解 具体过程 1 随机选定其中一个元素作为基准数 (pivot)( 通常采用第一个元素 ), 然后通过循环和比较运算, 将原序列分割成两部分, 使得新序列中在该基准数前面的元素都小于等于这个元素, 而其后面的元素都大于等于这个元素 ( 这时基准数已经归位 ) 2 依此类推, 再对这两个分割好的子序列进行上述过程, 直到排序结束 3 递归思想, 分而治之 第一步的具体实现 :( 假定基准数的值为 a, 原始位置是 i1=1) 1 先从原序列的最右边开始, 往左找出第一个小于 a 的数, 然后将该数与基准数交换位置, 设基准数新位置为 i2 2 从 i1 右边的位置开始, 往右找出第一个大于 a 的数, 然后将该数与基准数交换位置, 设基准数新位置为 i3 3 从 i2 左边的位置开始, 往左找出第一个小于 a 的数, 然后将该数与基准数交换位置, 设基准数新位置为 i4 4 从 i3 右边的位置开始, 往右找出第一个大于 a 的数, 然后将该数与基准数交换位置, 设基准数新位置为 i5 5 不断重复以上过程, 遍历整个序列 6 事实上, 可以不用交换, 而是先把基准数保留, 然后直接覆盖即可 后面步骤 1 对基准数所在位置前面的子序列和后面的子序列, 分别重复第一步的过程 2 不断重复以上过程, 通过递归实现排序 20

23 第九讲 类与对象 (I) 面向对象基础 9.1 类和对象基础 类的声明 类型标识符 class 类名 { }; public: 公有成员 ( 外部接口 ) private: 私有成员 protected: 保护型成员 类的成员 : 数据与函数 1 成员的访问属性 ( 权限控制 ):public,private,protected ( 如果没有指定访问属性, 则缺省是 private) 2 数据成员 ( 描述问题的属性 ), 一般情况下, 建议声明为私有类型 3 函数成员 ( 描述问题的行为 / 操作 / 功能 ) 4 在类中可以只声明函数原型, 函数的具体实现可以在类外部定义 5 不同访问属性的成员可以按任意顺序出现, 修饰访问属性的关键字也可以多次出现 6 一个成员只能有一种访问属性 7 一般将公有类型的成员放在最前面, 便于阅读 对象的创建 类名对象名 1 声明一个类后, 便可将其作为新的数据类型来创建变量, 即对象 2 类与对象的关系类似于基本数据类型与普通变量之间的关系 3 对象是类的实例, 即具有该类型的变量 4 对象所占的内存空间只用于存放数据成员 5 函数成员在内存中只占一份空间, 不会在每个对象中存储副本 6 定义对象的过程也称为类的实例化 7 不同对象之间的主要区别 : 名称与数据 对象成员的访问 对象名. 数据成员名 对象名. 函数成员名 ( 参数列表 ) 1 类的成员函数可以访问所有数据成员 ; 2 外部函数只能访问公有成员 成员函数的定义 数据类型类名 :: 函数名 ( 形参列表 ) // 在类外部定义 { } 函数体 ; 1 与普通函数的区别 : 前面要加上类的名称和两个连续冒号 2 简单成员函数建议直接在类内部定义, 此时函数名前面不需要加 类名 :: 3 复杂函数建议在类内部声明, 然后在类外部定义 21

24 目的对象 1 调用成员函数时, 需用. 操作符指定本次调用所针对的对象 2 该对象就是本次调用的 目的对象 3 在成员函数中, 可以直接引用目的对象的所有数据成员, 而无需使用. 操作符 4 在成员函数中, 引用其它对象的数据成员和函数成员时, 必须使用. 操作符 5 在类的成员函数中, 可以直接访问当前类的所有对象的私有成员 形参缺省值 1 与普通函数一样, 成员函数的形参也可以带缺省值 2 成员函数的形参缺省值只能在类的声明中设置, 不能在类外部定义函数时设置 内联成员函数 1 内联成员函数的定义 : 隐式方式和显式方式 2 隐式方式 : 将函数体直接放在类的定义中 3 显式方式 : 在定义函数时加上关键词 inline 4 使用内联函数可以减少调用开销, 提高效率, 但只适合简单的函数 ( 短函数 ) 5 使用显式方式定义内联函数可以保持类定义的简洁 9.2 构造函数和析构函数 构造函数 : 负责对象的初始化, 即声明对象时, 对数据成员进行初始化 对象创建的过程 1 申请内存空间 ( 用于存放数据成员 ) 2 初始化 : 自动调用构造函数初始化数据成员 构造函数几点说明 : 1 构造函数的函数名与类的名称相同 2 构造函数没有返回值, 前面也不需要带任何返回数据类型 3 构造函数在对象创建时会被系统自动调用 4 若没有构造函数, 系统会自动生成构造函数 ( 形参和函数体都为空 ) 5 构造函数的形参可以带缺省值 6 使用不带参数的构造函数声明对象时不需要加小括号 构造函数可以重载, 即可定义多个构造函数 匿名对象类名 (); // 调用不带形参的构造函数 ( 或形参都带缺省值 ) 类名 ( 参数列表 ); // 调用带形参的构造函数 1 在大多数情况下, 创建对象时都需要指定一个对象名, 但在有些情况下, 可能需要创建一个临时对象, 只使用一次, 这时可以使用匿名对象 2 创建匿名对象时, 使用不带参数的构造函数或形参都使用缺省值时, 一定要带小括号 对象作为函数参数 1 对象可以作为成员函数和非成员函数的参数 2 实参与形参的传递方式 : 值传递, 引用传递, 地址传递 复制构造函数 1 一类特殊的构造函数, 将已有对象的值复制给其它对象 2 缺省复制构造函数 : 系统自动生成, 将已有对象的数据全部简单复制给指定对象 3 不管是否存在用户自定义的复制构造函数, 缺省复制构造函数总是存在 4 若不存在自定义复制构造函数, 则在所有用对象赋值的地方都调用缺省赋值构造函数 5 若存在自定义复制构造函数, 则在以下几种情况下会调用自定义复制构造函数 : 22

25 (1) 用一个对象去初始化另一个同类的对象时 ( 注意是初始化, 不是赋值 ) (2) 若函数的形参是对象, 调用函数时形参与实参的结合 ( 值传递 ) 6 自定义复制构造函数不影响赋值号 ( 初始化除外 ) 的行为 函数调用时, 只有在进行值传递时, 复制构造函数才会被调用 ; 若传递的是引用, 则不会调用复制构造函数 因此传递比较大的对象时, 传递引用效率要高 析构函数 : 负责对象被释放时的一些清理工作 ~ 类名 ( 形参列表 ) { 函数体 } // 析构函数 1 析构函数的函数名由类名前加 ~ 组成 2 析构函数没有返回值, 也不需要加返回值数据类型 3 析构函数在对象生存期即将结束时被自动调用 4 析构函数不接收任何参数 5 若没有析构函数, 系统会自动生成一个析构函数 ( 函数体都为空 ) 9.3 类的组合 类的组合 : 将已有的类的对象作为新的类的成员 1 在创建类的对象时, 如果这个类包含其它类的对象 ( 称为内嵌对象成员 ), 则各个内嵌 对象将首先被自动创建 2 初始化时可以对每个内嵌对象成员进行初始化 组合类构造函数的一般形式 类名 :: 类名 ( 总参数列表 ): 内嵌对象 1( 参数 ), 内嵌对象 2( 参数 ),... { } 函数体 ( 类的数据成员的初始化 ) 1 内嵌对象 1( 参数 ), 内嵌对象 2( 参数 ),... 作用是对内嵌对象进行初始化, 这里的参 数前面不用加数据类型 ( 第一行单冒号后面部分称为 初始化列表 ) 2 除了自身的构造函数外, 内嵌对象的构造函数也被调用 3 构造函数调用顺序 : (1) 按内嵌对象在组合类的定义中出现的顺序依次调用内嵌对象的构造函数 (2) 最后调用本类的构造函数 4 总参数列表中的参数需要带数据类型 ( 形参 ), 初始化列表则不需要 5 析构函数的调用顺序与构造函数相反 数据成员中常量和引用的初始化 1 在初始化列表中进行初始化 2 不能在类的声明中初始化任何数据成员! 前向引用声明 1 类必须先定义后使用 2 若两个类互相引用, 则需要使用前向引用声明 3 使用前向引用声明时, 只能使用被声明的符号, 而不能涉及类的任何细节 9.4 结构体与联合体 结构体 : 一种特殊形态的类, 为了保持与 C 语言程序的兼容性 struct 结构体名称 { 23

26 }; public: 公有成员 private: 私有成员 protected: 保护型成员 1 结构体与类的区别 : 在类中, 对于未指定访问控制属性的成员, 默认为私有成员 ; 而 在结构体中, 未指定访问控制属性的成员, 默认为公有成员 2 C++ 中的结构体可以含数据成员和函数成员, 而 C 语言中的结构体只能含数据成员 联合体 : 一种特殊形态的类, 从 C 语言继承而来 union Mark { }; char grade; // 等级制 bool pass; int score; // 是否通过 // 百分制 1 联合体的所有成员共享一个存储单元 2 联合体的所有成员中同时至多一个有意义 3 联合体中成员的默认访问属性是公有类型 4 联合体一般只存数据, 不含函数成员 9.5 类的 UML 描述 UML:Unified Modeling Language 1 面向对象建模语言, 通过图形的方式描述面向对象程序设计 2 在 UML 类图中, 类一般由三部分组成 : 类名, 数据成员, 函数成员 数据成员表示方法 : 可见性名称 : 类型 [ = 缺省值 ] 函数成员表示方法 : 可见性名称 ( 参数列表 ) [ : 返回类型 ] + 表示 public,- 表示 private,# 表示 protected 24

27 第十讲 类与对象 (II) 面向对象进阶 10.1 对象的生存期 静态生存期 : 生存期与程序的运行期相同, 即一直有效 动态生存期 : 当对象所在的程序块执行完后即消失 类作用域 ( 主要考虑数据成员和局部变量的生存期与可见性 ) 1 数据成员可以被类中的所有函数成员访问 ( 类似全局变量 ) 2 成员函数中声明的变量是局部变量, 只在该成员函数内可见 3 如果成员函数中声明了与数据成员同名的变量, 则数据成员被屏蔽 10.2 静态成员 1 一般情况下, 同一个类的不同对象分别有自己的数据成员, 名字一样, 但各有各的值, 互不相干 但有时希望某些数据成员为所有对象所共有, 这样可以实现数据共享 2 全局变量可以达到共享数据的目的, 但其安全性得不到保证 : 任何函数都可以自由修改全局变量的值, 很有可能偶然失误, 全局变量的值被错误修改, 导致程序的失败 因此在编程中要慎用全局变量 3 如果需要在同一个类的多个对象之间实现数据共享, 可以使用静态数据成员 静态数据成员 1 用关键字 static 修饰 2 静态数据成员在内存中只占一份空间, 为整个类所共有, 不属于任何特定对象 3 该类的所有对象共同使用和维护静态数据成员 4 静态数据成员可以初始化, 但必须在类的外部初始化 5 如果静态数据成员没有初始化, 则系统会自动赋予初值 0 6 定义了静态数据成员, 即使不声明对象, 也为静态数据成员分配空间, 并可以被引用 7 静态数据成员既可以通过对象名引用, 也可以通过类名来引用, 即 : 对象名. 静态成员名或类名 :: 静态成员名 静态函数成员 1 用关键字 static 修饰, 为整个类所共有, 调用方式 : 类名 :: 静态函数成员名 2 没有目的对象, 所以不能对非静态成员进行缺省访问 3 静态成员函数可以直接访问静态成员, 但不能直接访问非静态成员 4 如果静态成员函数访问非静态数据成员时, 需指明对象 5 静态成员函数一般用于访问静态数据成员, 维护对象之间共享的数据 6 静态成员函数声明时需加 static, 但定义时不需加 static 7 允许通过对象名调用静态成员函数, 但此时使用的是类名, 而不是对象 8 编程好习惯 : 只用静态成员函数引用静态数据成员, 而不引用非静态数据成员, 这样思路清晰, 逻辑清楚, 不易出错 10.3 友元关系 友元关系 1 提供一种对象与非成员函数之间进行数据共享的机制 2 通俗说法 : 一个类主动声明哪些类或函数是它的朋友, 从而给它们提供对本类的访问特许, 即可以直接访问私有成员和保护成员 3 友元包括 : 友元函数与友元类 25

28 4 友元类的所有函数成员都是友元函数 5 友元提供了一种数据共享的方式, 提高了程序效率和可读性 6 但友元在一定程度上破坏了数据封装和数据隐藏的机制 友元函数 1 用关键字 friend 修饰, 在类的声明中声明, 在类外部定义 2 友元函数是非成员函数 ( 可以是普通函数或其它类的成员函数 ) 3 友元函数可以通过对象名直接访问私有成员和保护成员 友元类 1 用关键字 friend 修饰 2 友元类的所有函数成员都是友元函数 3 除非确有必要, 一般并不把整个类声明为友元类, 而只将确实有需要的成员函数声明为友元函数, 这样更安全 几点说明 1 友元关系不能传递 2 友元关系是单向的 3 友元关系不能被继承 4 面向对象程序设计的一个基本原则是封装性和信息隐蔽 友元一方面是对封装原则的一个小的破坏, 另一方面是有助于数据共享, 提高程序的效率 因此在使用友元时, 要注意它的副作用, 不要过多地使用友元, 只有在使用它能使程序精炼, 并能大大提高程序的效率时才用友元, 否则可能得不偿失 10.4 常对象与常成员将对象声明成常对象, 可以有效地保护数据 const 类名对象名 ; 类名 const 对象名 ; 1 常对象必须进行初始化 ( 初始化列表, 不能赋值 ) 2 常对象的所有数据成员均为常量, 不能被修改 3 不能通过常对象调用普通成员函数, 即常对象只能作为常成员函数的目的对象 常数据成员 1 可以将部分数据成员声明为常量 2 常数据成员必须初始化 ( 采用初始化列表方式, 不能在构造函数的函数体内赋值 ) 常函数成员类型说明符函数名 ( 形参 ) const; 1 若一个对象是常对象, 则通过该对象只能调用常成员函数 2 普通对象也可以调用常成员函数 3 无论对象是否为常对象, 在常成员函数被调用期间, 目的对象都将被视为常对象 4 如果成员函数不修改对象的数据域, 则可声明为常函数 常引用 const 类型说明符 & 引用名 ; 1 常引用所绑定的对象不能被更新 2 常引用可以绑定到常对象, 普通引用不能绑定到常对象 3 常引用也可以绑定到普通对象, 但不能通过常引用来修改其所绑定的对象 4 用常指针和常引用作函数参数, 可以节省存储量和运算, 也能保证数据的安全 26

29 10.5 对象数组与对象指针 对象数组的声明与初始化 1 一维对象数组 : 类名数组名 [n] 2 一维对象数组的引用 : 数组名 [k]. 成员名 3 初始化 : 对每个分量都调用构造函数 对象指针 : 指向对象的指针, 存放对象的地址 1 对象指针的声明 : 类名 * 对象指针名 2 使用对象指针访问对象成员 : 对象指针名 -> 成员名或 (* 对象指针名 ). 成员名 3 指向常对象的指针 :const 类名 * 对象指针名 this 指针 : 隐含在非静态成员函数中的特殊指针, 永远指向目的对象 1 this 指针是常指针 2 当局部作用域中声明了与类成员同名的标识符 ( 如变量名 ) 时, 可以通过 this 指针访问该类的成员 3 当通过一个对象的调用成员函数 ( 非静态成员函数 ) 时, 系统会把该对象的起始地址赋给成员函数的 this 指针 4 非静态成员函数有 this 指针, 而静态成员函数没有 this 指针 指向非静态成员的指针 : 直接指向类的成员 ( 数据成员或函数成员 ) 类型说明符类名 ::* 指针名 // 指向数据成员类型说明符 ( 类名 ::* 指针名 )( 参数 ) // 指向函数成员 1 数据成员指针的赋值 : 指针名 =& 类名 :: 数据成员名 2 数据成员指针的引用 : 对象名.* 指针名, 对象指针名 ->* 指针名 3 函数成员指针的赋值 : 指针名 =& 类名 :: 函数成员名 4 函数成员指针的引用 :( 对象名.* 指针名 )( 参数 ),( 对象指针名 ->* 指针名 )( 参数 ) 指向静态成员的指针 1 对类的静态成员的访问不依赖于对象, 可以通过普通的指针来指向和访问静态成员 动态对象的创建与释放 :new,delete 类名 * 指针名 =new 类名 () // 不带参数类名 * 指针名 =new 类名 ( 参数列表 ) // 带参数 1 动态对象的释放 :delete 指针名 2 程序结束后, 动态对象会被释放, 但在程序运行期间释放动态对象的话, 须用 delete 10.6 向量类 :vector 略 10.7 字符串类 :string 略 27

30 第十一讲 运算符重载 11.1 为什么要重载运算符预定义的运算符 ( 如 + - * / > < == 等 ) 只针对基本数据类型, 若要对类的对象进行类似的运算, 需要重新定义运算符的功能 运算符重载 : 1 本质上就是函数重载, 即对已有的运算符赋予多重含义, 使得同一个运算符作用于不同类型的数据时导致不同的行为 运算符重载基本规则 1 只能重载已有的运算符 2 重载不改变运算符的优先级和结合率 3 运算符重载不改变运算符的操作数的个数 4 重载的运算符的功能应该与已有的功能类似 5 运算符重载是为了满足新数据类型 ( 类与对象 ) 的需要, 因此要求至少有一个操作数是新类型的数据 ( 这里可以理解为自定义类的对象 ) 四个不能被重载的运算符 :..* ::? : 11.2 怎么实现运算符重载 运算符重载的一般形式 :( 以成员函数方式为例 ) 1 声明 : 类型说明符 operator 运算符 ( 形参列表 ); 2 定义 ( 如果在类内部声明, 在类外部定义 ): 类型说明符类名 ::operator 运算符 ( 形参列表 ) { 函数体 ; } 3 这里的类型说明符可以是类名或基本数据类型 运算符重载的两种实现方式 : 成员函数和非成员函数 11.3 成员函数方式实现运算符重载 特点 1 可以自由访问本类对象的 ( 私有 ) 数据成员 2 运算符重载为成员函数时, 形参个数可以少一个 3 若是双目运算, 则左操作数就是目的对象本身, 可使用 this 指针来调用 4 若是单目运算, 则目的对象就是操作数, 不需要其它形参 ( 注 : 后置 ++ 和后置 -- 除外 ) 双目运算符的重载格式 1 声明 : 类型说明符 operator (const 类名 &); 注 : 形参建议用 常引用, 既可以实现与变量的运算, 也可以实现与常量的运算 2 定义 ( 假定在类外部定义 ): 类型说明符类名 ::operator (const 类名 & p) { 函数体 ; } 3 这里 表示可以重载的双目运算 前置单目运算符的重载 1 声明 : 类型说明符 operator (); 2 定义 ( 假定在类外部定义 ): 类型说明符类名 ::operator () { 函数体 ; } 后置单目运算符 (++ --) 的重载 1 声明 : 类型说明符 operator (int); 28

31 2 定义 ( 假定在类外部定义 ): 类型说明符类名 ::operator (int dummy) { 函数体 ; } 3 带一个整型形参, 但该参数在运算中不起任何作用, 只用于区分前置和后置, 因此也称为伪参数 11.4 非成员函数方式实现运算符重载 非成员函数方式 1 需在相关类中将其声明为友元函数 2 形参个数与操作数相同 3 所有操作数都通过参数传递 双目运算符的重载格式 1 声明 : 类型说明符 operator (const 类名 &, const 类名 &); 2 定义 ( 必须在类外部定义 ): 类型说明符类名 ::operator (const 类名 & p1, const 类名 & p2) { 函数体 ; } 11.5 简单自动类型转换目的 : 实现对象与基本数据类型变量之间的运算怎么做 : 自动 / 隐式类型转换能做什么 : 将对象自动转换为基本数据类型, 将基本数据类型自动转换为对象 基本数据类型 对象 1 实现方法 : 构造函数 对象 基本数据类型 1 实现方法 : 重载类型转换函数 ( 必须以成员函数方式 ) 2 声明 :operator 转换函数名 (); 3 定义 ( 假定在类外部定义 ): 类名 ::operator 转换函数名 () { 函数体 }; 4 注意 : 没有返回数据类型 注意点 : 1 一个类可以重载类型转换函数, 实现对象到基本数据类型的转换, 也可以重载构造函数, 实现基本数据类型到对象的转化, 但两者不能并存! 2 若定义了转换函数, 则建议使用非成员函数方式实现运算符重载, 并且形参使用 常引用 11.6 几点注记 1 运算符 [] () 必须以成员函数方式重载 2 运算符 << >> 必须以非成员函数重载 ( 这两个运算符的重载涉及到输入输出, 将在文件流中介绍 ) 3 算术运算符和关系运算符建议以非成员函数重载, 以便实现一些简单的自动类型转换 29

32 第十二讲 继承与多态 12.1 继承与派生 1 类的派生 : 在已有类的基础上产生新类的过程 2 类的继承 : 派生类继承了父类的已有特性 ( 数据和函数 ) 3 原有类称为基类或父类, 新类称为派生类或子类 4 派生类可以改造父类的特性, 也可以加入新的特性 5 派生类也可以作为父类, 派生出新的子类 6 继承和派生提高了代码的可重用性, 有利于软件开发 12.2 派生类的定义 class 派生类名 : 继承方式父类名 1, 继承方式父类名 2,... { }; 派生类成员声明 ; 1 一个派生类可以有多个父类 ( 多重继承 ) 2 单继承 : 一个派生类只有一个父类 3 一个父类可以派生出多个子类 类族 4 继承是可传递的 : 从父类继承的特性可以传递给新派生的子类 5 继承方式 : 规定了如何访问从父类继承的成员 6 继承方式有三种 :public protected private 7 派生类成员 : 从父类继承的成员 + 新增加的成员 类的派生过程 1 吸收父类成员 : 派生类包含父类中除构造和析构函数外的所有非静态成员 2 改造父类成员 : - 通过继承方式改变父类成员的访问控制 - 对父类成员的屏蔽 ( 如果新成员与父类成员同名, 则缺省只能访问新成员 ) 3 添加新成员 : 根据实际需要, 添加新的数据成员或函数成员 派生类成员的访问控制 1 能否访问和怎样访问从父类继承得来的成员 2 这里主要强调派生类中新增成员和派生类外部函数访问派生类中从父类继承的成员 3 继承方式不同, 访问控制不同 : 公有继承 (public) - 父类的公有和保护成员的访问属性保持不变 - 父类的私有成员不可直接访问 私有继承 (private) - 父类的公有和保护成员都成为派生类的私有成员 - 父类的私有成员不可直接访问 保护继承 (protected) 几点注记 - 父类的公有和保护成员都成为派生类的保护成员 - 父类的私有成员不可直接访问 1 从父类继承的成员函数对父类成员的访问不受影响 2 无论以何种方式继承, 父类的私有成员都不可直接访问 30

33 3 私有继承后, 父类成员 ( 特别是公有函数 ) 无法在以后的派生类中直接发挥作用, 相当于终止了父类功能的继续派生 因此, 私有继承较少使用 4 保护继承与私有继承的区别 : 父类成员 ( 特别是公有函数 ) 可以在以后的派生中作为保护成员继承下去 访问控制小结 1 父类成员函数访问父类成员 : 正常访问 2 派生类成员函数访问派生类新增成员 : 正常访问 3 父类成员函数访问派生类新增成员 : 不能访问 4 派生类成员函数访问父类成员 : 取决于继承方式和父类成员本身访问属性 5 派生类外部函数 ( 非成员函数 ) 访问派生类所有成员 : 只能访问公有成员 6 派生类成员按访问属性可划分为下面四类 : - 不可访问成员 : 父类的私有成员 - 私有成员 : 父类继承的部分成员 + 新增的私有成员 - 保护成员 : 父类继承的部分成员 + 新增的保护成员 - 公有成员 : 父类继承的部分成员 + 新增的公有成员 12.3 构造函数和析构函数 1 派生类不能继承父类的构造和析构函数, 必须自己定义 2 派生类的构造函数只负责新增成员的初始化 3 从父类继承的成员需通过调用父类的构造函数进行初始化 派生类构造函数 ( 初始化参数列表 ) 派生类名 ( 总参数列表 ): 父类 1( 参数 ),..., 父类 n( 参数 ), 成员对象 1( 参数 ),..., 成员对象 m( 参数 ) { 新增数据成员的初始化 ( 不包括继承的父类成员 ); }; 1 总参数列表中的参数需要带数据类型 ( 形参 ), 其他不需要 2 需要初始化的数据成员 : 父类成员 + 新增成员, 基本数据类型变量 + 类的对象 3 父类数据成员的初始化 : 调用父类构造函数 4 对象成员的初始化 : 通过对象所在类的构造函数 几点注记 1 在派生类构造函数的总参数列表中, 有一些参数是传递给父类的构造函数的 2 若父类使用缺省构造函数, 则可以省略 3 若成员对象使用缺省构造函数来初始化, 也可以省略 4 派生类构造函数执行的一般次序 - 调用父类的构造函数, 按被继承时声明的顺序执行 - 对派生类新增对象成员初始化, 按它们在类中声明的顺序执行 - 执行派生类的构造函数体的内容 派生类的复制构造函数 1 派生类复制构造函数的作用 : 调用父类的复制构造函数完成父类数据成员的复制, 然后再执行派生类数据成员的复制 2 在定义派生类的复制构造函数时, 需要为父类相应的复制构造函数传递参数 派生类析构函数 1 派生类的析构函数只负责新增数据成员 ( 非对象成员 ) 的清理工作 31

34 2 派生类析构函数的定义与普通析构函数一样 3 父类成员和新增对象成员的清理工作由父类和对象成员所属类的析构函数负责 4 析构函数的执行顺序与构造函数相反 : - 执行派生类析构函数体 - 执行派生类对象成员的析构函数 - 执行父类的析构函数 12.4 派生类成员的标识与访问如何处理成员同名问题? 屏蔽规则 1 如果存在两个或多个具有包含关系的作用域, 外层作用域声明的标识符在内层作用域可见, 但如果在内层作用域声明了同名标识符, 则外层标识符在内层不可见 2 父类是外层, 派生类是内层 3 若在派生类中新定义了与父类同名的成员, 则缺省使用新定义的成员 4 若在派生类中声明了与父类同名的新函数, 即使函数参数表不同, 从父类继承的同名函数的所有重载形式都会被屏蔽 5 如何访问被屏蔽的成员 : 类名 + 作用域分辨符 :: 类名 :: 成员名 // 数据成员类名 :: 成员名 ( 参数 ) // 函数成员 6 若派生类有多个父类, 且这些父类中有同名标识符, 则必须使用作用域分辨符来指定使用哪个父类的标识符! 7 通过作用域分辨符就明确地唯一标识了派生类中从父类继承的成员, 从而解决了成员同名问题 12.5 类型兼容规则 基本规则 1 在需要父类对象出现的地方, 可以使用派生类 ( 以公有方式继承 ) 的对象来替代 2 通俗解释 : 公有派生类实际具备了父类的所有功能, 凡是父类能解决的问题, 公有派生类都可以解决 3 替代后, 只能使用从父类继承的成员, 即派生类只能发挥父类的作用 类型兼容规则中的替代包括以下情况 : 1 派生类的对象可以隐式转化为父类对象 2 派生类的对象可以初始化父类的引用 3 派生类的指针可以隐式转化为父类的指针 12.6 虚父类在多重继承时, 如果派生类的部分或全部父类是从另一个共同父类派生而来, 则在最终的派生类中会保留该间接共同父类数据成员的多份同名成员 这时不仅会存在标识符同名问题, 还会占用额外的存储空间, 同时也增加了访问这些成员时的困难, 且容易出错 而事实上, 在很多情况下, 我们只需要一个这样的成员副本 ( 特别是函数成员 ) 虚父类 : 当某个类的部分或全部父类是从另一个共同父类派生而来时, 可以将这个共同父类设置成虚父类, 这时从不同路径继承来的同名数据成员在内存中只存放一个副本, 同一 32

35 个函数名也只有一个映射 class 派生类名 : virtual 继承方式父类名 { }; 在直接或间接继承虚父类的所有派生类中, 都必须在构造函数的初始化列表中列出对 虚父类的初始化 2 虚父类并不是在声明父类时声明的, 而是在声明派生类时, 指定继承方式时声明的 3 一个类可以在生成某个派生类时作为虚父类, 而在生成另一个派生类时不作为虚父类 4 为了保证虚父类成员在派生类中只继承一次, 应当在该父类的所有直接派生类中声明 其为虚父类, 否则仍然可能会出现对该父类的多次继承 12.7 多态多态性是面向对象程序设计的重要特征之一 1 同样的消息被不同类型的对象接收时会导致不同的行为 2 消息 : 对类的成员函数的调用 3 不同行为 : 不同的实现 ( 功能 ), 即调用不同函数 多态的实现 : 1 函数重载, 运算符重载 2 虚函数 3 模板 33

36 第十三讲 文件流与输出输入重载 13.1 输入输出流 1 在 C++ 中, 所有的输入输出都通过流来描述 2 输入流 : 数据流向程序 3 输出流 : 数据从程序中流出 4 具体实现方法 : 流类和流对象 13.2 文件流类与文件流对象 C++ I/O 库中定义的流类 类名 作用 头文件 ios 抽象父类 iostream istream ostream iostream ifstream ofstream fstream istrstream ostrstream strstream 各流类继承关系 通用输入流和其他输入流的父类通用输出流和其他输出流的父类通用输入输出流和其他输入输出流的父类 输入文件流类输出文件流类输入输出文件流类 输入字符串流类输出字符串流类输入输出字符串流类 iostream fstream strstream 文件流头文件 :#include <fstream> ofstream 向文件写入数据 ifstream 从文件读取数据 fstream 可以读写文件 创建文件流对象 fstream fstrm; // 创建一个文件流对象, 未绑定到任何文件 fstream fstrm(fname); // 创建一个文件流, 并绑定到文件 fname fstream fstrm(fname, mode); // 创建文件流的同时指定文件的打开模式 1 这里的类 fstream 也可以是 ifstream 或 ofstream 2 ifstream 对象所关联的文件只能读 3 ofstream 对象所关联的文件只能写 34

37 13.3 文件的打开与关闭 文件流对象基本操作 ( 成员函数 ) fstrm.open(fname) // 将文件流对象 fstrm 绑定到文件 fname fstrm.close() // 关闭与文件流对象 fstrm 绑定的文件 fstrm.is_open() // 测试文件是否已顺利打开 ( 且未关闭 ) 1 将文件流对象关联到其它文件时, 须先关闭已绑定的文件 2 文件流对象被释放时,close 会被自动调用 文件打开方式 ios::in // 只读 ios::out // 只写, 若文件存在, 则内容被清除 ios::app // 追加, 即每次写操作均定位到文件末尾 ios::ate // 打开文件后立即定位到文件末尾 ios::trunc // 若文件存在, 则清除文件中原有的内容 ios::binary // 以二进制方式进行读写 1 输入输出方式是在 ios 类中定义的 2 以上方式可以组合使用, 用 隔开, 如 ios::out ios::binary 3 ios::app 通常与 ios::out 组合使用 4 在缺省情形下, 文件以文本方式打开 5 ifstream 对象只能设定 in 模式, 缺省为 in 6 ofstream 对象只能设定 out 模式, 缺省为 out 7 fstream 对象可以设定 in 或 / 和 out 模式 8 建议使用 fstream 对象进行文件读写操作 13.4 文件读写 : 文本文件与二进制文件 文本文件操作 1 文本文件的写 :<< 2 文本文件的读 :>> 或 getline 3 我们是如何使用 cin 和 cout 的, 就可以同样来使用文件流对象 二进制文件操作 1 对二进制文件使用 << >> 或 getline 是没有意义的 2 写 : 使用父类 ostream 的成员函数 write 3 读 : 使用父类 istream 的成员函数 read write(const char* buf, int n); read(char* buf, int n); // buf 指向内存中一段存储空间,n 是读写字节数 输出文件流对象.write(buf,50); // 将 buf 所指定的地址开始的 50 个字节的内容不加转换地写到流对象中输入文件流对象.read(buf,30); // 从流对象所关联的文件中, 读入 30 个字节 ( 或至文件结尾 ), 存放在 buf 所指向的内存空间内 35

38 13.5 重载输出输入操作运算符 << 和 >> 1 一个具体例子 class Rational { public: Rational() { x=0; y=1; } Rational(int x, int y) { this->x=x; this->y=y; } friend ostream & operator<<(ostream&, const Rational&); friend istream & operator>>(istream&, Rational&); void display() { cout << x << "/" << y << endl; } private: int x, y; }; ostream & operator<<(ostream& out, const Rational& a) { out << a.x << "/" << a.y; return out; } istream & operator>>(istream& in, Rational& a) { cout << "Enter numerator: "; in >> a.x; cout << "Enter denomiator: "; in >> a.y; }

39 附录 : 程序示例 显示当前时间 :etime(0)( 时 分 秒, 北京时间 : 格林威治时间 + 8 小时 ) 显示当前日期 ( 年 月 日, 北京时间 ) 计时函数 :clock(),clocks_per_sec 随机数 : 任意范围随机整数, 随机小数,srand(seed),rand(),RAND_MAX 素数问题 ( 素数判断, 所有素数因子,emirp 数, 梅森素数, 孪生素数 ) 循环 ( 乘法表, 最大公约数, 最小公倍数, 退出多重循环, 猜数游戏 ) 递归算法 :Fibonacci 数, 阶乘, 求和, 素数因子, 3n+1 问题 ( 循环, 递归 ) 储物柜问题 闰年判断 数字反转 ( 回文数, 各位数字之和 ) 十进制转二进制 二进制转十进制 ( 字符串方式, 即用字符串表示二进制数 ) 数组最小值所在位置 ( 一维数组, 二维数组 ) 矩阵运算 ( 矩阵与向量的乘积, 矩阵与矩阵的乘积, 用普通指针实现 ) 函数重载 ( 整数加法, 实数加法 ) 有序数组中插入新元素 字符与字符串 ( 字符易位破译, 字符与数字的转换, 字符串与数字的转换 ) 矩阵对角线之和 ( 正对角线, 反对角线, 行和, 列和, 多项式乘积 ) 文件操作 (C 语言方式 ): 文本文件读写, 二进制文件读写 排序算法 : 选择排序, 插入排序,Shell 排序, 冒泡排序, 快速排序 (*) 类的声明与实现 ( 有理数类,Clock,Circle,Rectangle,Complex,Point,Date,Employee) 类的组合 (Point, Line) 初始化参数列表 ( 对象成员初始化, 常量作为数据成员的初始化, 引用作为数据成员的初始化 ) 运算符重载 ( 成员函数方式, 非成员函数方式 ) 派生类的声明与实现 文件对象 : 文本文件读写, 二进制文件读写 几点注记 : 1 教材上 const 解释为只读 2 :: 二元作用域解析运算符 binary scope resolution operator 3. 点运算符 dot operator