基本信息

内容简介

目录

基本信息

作者： 陈国建 游梁 张建辉

丛书名： 程序员书库

出版社：机械工业出版社

ISBN：9787111325468

上架时间：2011-1-27

出版日期：2011 年1月

开本：16开

页码：417

内容简介

本书是一本全面介绍c++的书籍，讲解由浅入深、循序渐进，可使读者熟练掌握c++，并能开发c++应用程序。

本书分为五篇，第一篇是c++基础篇，介绍了c++程序设计入门、c++变量与运算符以及c++选择和循环语句等基础知识。第二篇讨论了c++面向过程编程的一些知识点，讨论了数组与字符串、指针与内存、如何自定义数据类型（结构体）和函数的基本知识。第三篇是c++面向对象编程，重点在于类和对象、运算符重载、类的继承和多态与虚函数等。第四篇谈论了c++泛型编程，包括c++模板和标准模板库（stl）。第五篇介绍了c++输入/输出处理和编码规范，讨论了输入/输出、文件操作、命名空间、异常和错误处理的基本知识。

目录

丛书序

前言

第一篇 c++基础

第1章 c++程序设计入门 1

1.1 面向对象的程序概述 1

1.1.1 面向过程的程序设计 1

1.1.2 面向对象的程序设计 2

1.2 c++概述 2

1.2.1 c++的发展历程 2

1.2.2 c++的特点 3

1.3 visual c++开发环境 3

1.3.1 visual c++ 6.0简介 4

1.3.2 visual c++开发环境概述 4

1.4 c、c++与visual c++ 14

1.4.1 c与c++ 14

1.4.2 c++与visual c++ 14

1.5 第一个c++程序 15

1.5.1 c++程序的结构 15

1.5.2 创建源程序 18

1.5.3 编译、链接和运行程序 18

.1.6 小结 19

1.7 习题 19

第2章 变量与运算符 20

2.1 变量与基本数据类型 20

2.1.1 什么是变量 20

2.1.2 如何定义变量 22

2.1.3 整型 23

2.1.4 浮点型 28

2.1.5 字符类型 30

2.1.6 布尔类型 33

2.2 常量 34

2.2.1 什么是常量 34

2.2.2 数值常量—整型常量和实型常量 34

2.2.3 字符型常量 35

2.2.4 字符串常量 35

2.3 算术运算符与算术表达式 36

2.3.1 基本算术运算符 36

2.3.2 关系运算符 37

2.3.3 逻辑运算符 37

2.3.4 位运算符 38

2.3.5 sizeof运算符 39

2.3.6 强制类型转换 39

2.3.7 运算符的优先级与结合性 41

2.3.8 算术表达式 41

2.3.9 逻辑表达式 42

2.3.10 赋值表达式 42

2.3.11 逗号表达式 42

2.4 小结 43

2.5 习题 43

第3章 选择与循环 44

3.1 选择结构和if语句 44

3.1.1 if语句的3种形式 44

3.1.2 if语句的嵌套 49

3.1.3 switch选择语句 52

3.2 循环结构和循环语句 58

3.2.1 while循环结构 58

3.2.2 for循环结构 59

3.2.3 do-while循环结构 62

3.2.4 循环的嵌套 63

3.2.5 几种循环的比较 64

3.2.6 循环语句的效率 65

3.2.7 break、continue和goto语句 66

3.3 小结 74

3.4 习题 75

第二篇 c++过程开发

第4章 数组与字符串 77

4.1 数组的概念 77

4.2 一维数组的定义和引用 78

4.2.1 一维数组的定义 78

4.2.2 一维数组元素的引用 79

4.2.3 一维数组的初始化 80

4.2.4 一维数组与指针 82

4.3 二维数组的定义和引用 83

4.3.1 二维数组的定义 83

4.3.2 二维数组元素的引用 84

4.3.3 二维数组的初始化 85

4.3.4 多维数组的使用 87

4.4 指针与数组 89

4.4.1 指针与数组的关系 89

4.4.2 指向数组元素的指针 89

4.4.3 指针与一维数组 89

4.4.4 指针与多维数组 90

4.4.5 指针与字符数组 90

4.5 指针数组与数组指针 91

4.5.1 指针数组 91

4.5.2 数组指针 91

4.6 动态分配二维数组 92

4.6.1 已知二维数组的第二维进行动态分配 92

4.6.2 已知二维数组的第一维进行动态分配 93

4.6.3 已知二维数组的第一维并一次分配内存 94

4.6.4 二维数组的两维都未知的情况下进行动态分配 95

4.6.5 二维数组的两维都未知的情况下一次分配内存 96

4.7 字符数组与字符串 97

4.7.1 字符数组 97

4.7.2 字符串及其使用 99

4.7.3 字符串处理函数 100

4.8 小结 104

4.9 习题 104

第5章 指针与内存 106

5.1 指针的概念 106

5.2 变量与指针 106

5.2.1 定义指针变量 106

5.2.2 引用指针变量 108

5.2.3 引用指针变量与指针的指针 109

5.2.4 指针作函数参数 110

5.3 数组与指针 112

5.3.1 指向数组元素的指针 112

5.3.2 用指针变量作函数参数接收数组地址 113

5.3.3 多维数组与指针 115

5.4 函数与指针 117

5.4.1 函数指针与指针函数 117

5.4.2 用指向函数的指针作函数参数 120

5.5 动态内存分配 121

5.5.1 使用new动态分配内存 121

5.5.2 使用new申请动态数组 123

5.6 小结 125

5.7 习题 125

第6章 自定义数据类型 127

6.1 结构体类型 127

6.1.1 结构体概述 127

6.1.2 结构体类型变量的定义方法及其初始化 128

6.1.3 结构体变量的引用 132

6.1.4 结构体数组 133

6.1.5 指向结构体变量的指针 135

6.1.6 结构体类型数据作为函数参数 136

6.2 共用体 138

6.2.1 共用体的语法形式 139

6.2.2 定义共用体变量 139

6.2.3 共用体变量的引用 140

6.3 枚举类型 142

6.4 链表 143

6.4.1 链表的结构 143

6.4.2 创建链表 144

6.4.3 链表与数组的区别 144

6.4.4 删除整个链表 145

6.4.5 在链表中插入结点 145

6.5 小结 146

6.6 习题 146

第7章 函数 148

7.1 函数概述 148

7.2 函数定义 150

7.2.1 无参函数 150

7.2.2 有参函数 153

7.2.3 函数头与函数体 158

7.2.4 函数返回值 159

7.2.5 函数声明 160

7.3 函数参数 162

7.3.1 形参和实参 163

7.3.2 值传递 164

7.3.3 引用传递 164

7.3.4 指针传递 165

7.3.5 有缺省参数的函数 166

7.3.6 内联函数 168

7.4 函数的嵌套调用 170

7.4.1 函数的相互嵌套调用 170

7.4.2 函数的递归调用 171

7.5 函数的重载 174

7.5.1 什么是函数重载 174

7.5.2 如何实现函数重载 175

7.6 函数变量 176

7.6.1 局部变量 176

7.6.2 全局变量 177

7.6.3 静态局部变量 180

7.6.4 静态全局变量 182

7.7 小结 183

7.8 习题 183

第8章 c++过程开发的进一步讨论 186

8.1 c/c++重要的关键字 186

8.1.1 const关键字 186

8.1.2 static关键字 188

8.2 内存问题 192

8.2.1 内存泄漏 192

8.2.2 野指针 193

8.2.3 试图修改常量 193

8.2.4 用错sizeof 194

8.3 带参的主函数 195

8.4 小结 196

8.5 习题 196

第三篇 c++面向对象开发

第9章 类和对象 197

9.1 面向对象程序设计概述 197

9.1.1 什么是面向对象的程序设计 197

9.1.2 面向对象程序设计的特点 198

9.1.3 面向对象程序设计的优点 204

9.1.4 类的概念 206

9.2 类的声明与定义 206

9.2.1 类声明和类定义 206

9.2.2 类和结构体 207

9.3 类的成员变量 208

9.3.1 如何定义类的成员变量 208

9.3.2 类成员变量的赋值 209

9.4 类的成员函数 210

9.4.1 成员函数的声明和实现 210

9.4.2 带默认形参值的成员函数 210

9.4.3 内联成员函数 211

9.5 const成员变量与成员函数 212

9.5.1 const成员变量 212

9.5.2 const成员函数 213

9.6 静态成员变量与成员函数 214

9.6.1 静态成员变量 214

9.6.2 静态成员函数 215

9.7 小结 216

9.8 习题 216

第10章 类和对象的进一步讨论 218

10.1 类的构造函数 218

10.1.1 构造函数的概念 218

10.1.2 含有参数的构造函数 220

10.1.3 构造函数的重载 221

10.1.4 构造函数允许按参数默认方式调用 222

10.1.5 用参数初始化表对数据成员初始化 224

10.2 类的析构函数 225

10.2.1 析构函数的概念 225

10.2.2 析构函数的作用 226

10.2.3 构造函数和析构函数的调用顺序 227

10.3 复制构造函数 227

10.3.1 复制构造函数的概念与作用 228

10.3.2 如何定义复制构造函数 229

10.3.3 浅复制与深复制 230

10.3.4 复制构造函数的调用 232

10.4 类作用域和对象生存期 234

10.5 友元 236

10.5.1 友元函数 236

10.5.2 友元成员 238

10.5.3 友元类 240

10.6 对象指针 242

10.6.1 指向对象的指针 242

10.6.2 this指针 244

10.7 对象的动态建立和释放 246

10.7.1 对象的创建 246

10.7.2 对象的释放 247

10.7.3 malloc/free与new/delete的区别 248

10.8 小结 249

10.9 习题 250

第11章 运算符重载 251

11.1 运算符重载概要 251

11.2 运算符重载 252

11.2.1 单目运算符重载 252

11.2.2 双目运算符重载 254

11.2.3 运算符“[ ]”的重载 257

11.2.4 运算符重载为友元函数 258

11.3 小结 260

11.4 习题 260

第12章 类的继承 261

12.1 继承与派生的概念 261

12.2 派生类的声明方式 263

12.3 派生类成员的访问权限 264

12.3.1 公有继承 264

12.3.2 私有继承 265

12.3.3 保护继承 266

12.4 派生类的构造函数和析构函数 267

12.4.1 派生类的构造函数 267

12.4.2 派生类的析构函数 269

12.5 虚基类 270

12.5.1 虚基类的概念 271

12.5.2 共同基类带来的二义性 272

12.6 基类与派生类的相互转换 272

12.7 小结 274

12.8 习题 274

第13章 多态与虚函数 276

13.1 多态与虚函数简介 276

13.1.1 静态联编 276

13.1.2 动态联编 278

13.1.3 虚函数概念 278

13.1.4 虚函数的声明和定义 278

13.1.5 关于虚函数的几点说明 280

13.1.6 虚函数的原理 281

13.2 虚函数的访问 283

13.2.1 对象名访问 283

13.2.2 基指针访问 284

13.2.3 引用访问 286

13.2.4 类内访问 288

13.2.5 在构造函数或析构函数中访问 289

13.3 纯虚函数与抽象类 291

13.3.1 纯虚函数的声明和定义 291

13.3.2 抽象类 293

13.3.3 另一种抽象类：类中只定义了protected型的构造函数 294

13.3.4 虚析构函数 295

13.4 虚函数引入的二义性 297

13.4.1 多基派生的二义性 297

13.4.2 虚继承 399

13.5 重载、覆盖与隐藏 302

13.6 小结 304

13.7 习题 304

第四篇 c++泛型编程

第14章 模板 307

14.1 模板的概念 307

14.2 函数模板 308

14.2.1 函数模板的一般定义 308

14.2.2 显式具体化 309

14.2.3 优先级与执行顺序 312

14.3 类模板 313

14.3.1 类模板的一般定义 313

14.3.2 模板类的继承 316

14.3.3 模板类的静态数据成员 317

14.4 小结 319

14.5 习题 319

第15章 标准模板库（stl） 320

15.1 stl概述 320

15.1.1 算法简介 320

15.1.2 容器简介 320

15.1.3 迭代器简介 321

15.1.4 适配器简介 321

15.2 容器 322

15.2.1 向量 322

15.2.2 列表 323

15.3 迭代器 325

15.3.1 输入和输出迭代器 325

15.3.2 前向迭代器、双向迭代器和随机访问迭代器 326

15.3.3 插入迭代器 327

15.3.4 混合迭代器函数 328

15.3.5 迭代器适配器 328

15.4 算法和函数对象 329

15.4.1 stl通用算法调用形式 329

15.4.2 不可变序列算法 331

15.4.3 可变序列算法 332

15.4.4 函数对象 332

15.5 小结 334

15.6 习题 334

第五篇 输入/输出处理和编程规范

第16章 输入/输出 335

16.1 输入/输出概述 335

16.1.1 流 336

16.1.2 缓冲区 336

16.1.3 3种输入/输出流 336

16.1.4 重定向 336

16.2 c语言i/o库函数 337

16.2.1 标准输出函数printf 337

16.2.2 标准输入函数scanf 340

16.2.3 sprintf和sscanf函数 341

16.2.4 c语言的文件访问机制 345

16.3 流类库 347

16.3.1 流类库更安全、更高效 347

16.3.2 流类库层次 348

16.4 c++输入/输出流 350

16.4.1 标准输出流对象cout 350

16.4.2 其他输出流对象 351

16.4.3 标准输入流对象cin 352

16.4.4 使用格式控制符控制输出格式 354

16.4.5 用流对象的成员函数控制输出格式 356

16.4.6 用流成员函数put输出字符 359

16.4.7 用于字符输入的流成员函数 359

16.4.8 istream类的其他成员函数 362

16.5 重载“[[”和“]]” 365

16.6 c++文件输入/输出流 366

16.6.1 文件的输出 367

16.6.2 文件的输入 368

16.7 小结 370

16.8 习题 370

第17章 文件操作 372

17.1 文件的概述 372

17.2 文件的打开与关闭 372

17.2.1 文件的打开 372

17.2.2 文件的关闭 373

17.3 文件的读写 374

17.3.1 c++文件的读写方法 374

17.3.2 文本文件的读写 375

17.3.3 文件的定位 376

17.3.4 二进制文件的读写 377

17.4 小结 378

17.5 习题 378

第18章 命名空间 379

18.1 什么是命名空间 379

18.1.1 命名空间范例 379

18.1.2 定义命名空间 381

18.2 实体的作用域与可见域 382

18.2.1 局部作用域 382

18.2.2 全局作用域和域操作符 384

18.2.3 作用域嵌套及可见性 385

18.3 使用命名空间 386

18.3.1 作用域解析运算符 386

18.3.2 using指令 386

18.3.3 using指令与using声明的比较 388

18.4 小结 389

18.5 习题 389

第19章 异常和错误处理 390

19.1 编码时的防错 390

19.1.1 使用断言 390

19.1.2 调用exit、abort、_exit和atexit函数 392

19.1.3 返回错误标志 396

19.2 异常机制 397

19.2.1 异常的抛出 399

19.2.2 异常的捕获 402

19.2.3 异常的处理 404

19.2.4 terminate函数和set_terminate函数 405

19.2.5 unexpected函数与set_unexpected函数 407

19.2.6 标准异常 408

19.3 关于异常处理的进一步讨论 410

19.3.1 异常规范 410

19.3.2 堆栈解退 411

19.3.3 构造函数、析构函数与异常处理 411

19.4 auto_ptr类 412

19.4.1 使用auto_ptr类 412

19.4.2 关于auto_ptr的使用说明 415

19.5 小结 415

19.6 习题 416