标签分类
当前位置:首页 > 程序设计电子书 > C++编程入门电子书网盘下载
C++ Primer Plus C++ Primer Plus
u01441712

u01441712 提供上传

资源
43
粉丝
3
喜欢
131
评论
14

    C++ Primer Plus PDF 超清第6版

    C++编程入门电子书
    • 发布时间:

    给大家带来的一篇关于C++编程入门相关的电子书资源,介绍了关于C++、Primer方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小162.4 MB,Stephen编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.4,更多相关的学习资源可以参阅 程序设计电子书、等栏目。

  • C++ Primer Plus PDF 下载
  • 下载地址:https://pan.baidu.com/s/1mpl_RB5V6kAovso5dn8TCA
  • 分享码:28d2
  • C++ Primer Plus

    C++ Primer Plus电子书封面

    读者评价

    非常好用的书籍,我之前买过一本c,这次买的c++,这套书籍真的非常详细,非常不错。

    内容没得说,但不知是不是配色的问题,封面看起来有些泛黄,但瑕不掩瑜。毕竟经典之作,在c++11方面的更新也算是一大亮点,对初学者入门和作为工具书案头常备还是非常推荐的

    很适合初学者的C++书籍,案例经典,我觉得有希望跨专业自修完C++,打call

    今晚,终于把这本厚重的书从头到尾的读了一遍,将近170万字的书~~没读之前,我认为今天是个有成就感的日子,因为我把这么厚重的书看了,从小到大,还没有看过这么厚的呢。但我现在,并没有任何成就感,因为我感觉到,这本书的读完,仅仅是我C++之路的开始,后面的路程很长,或许我并不…

    内容介绍

    C 是在 C 语言基础上开发的一种集面向对象编程、泛型编程和过程化编程于一体的编程语言,是C语言的超集。《C Primer Plus(第6版)中文版》是根据2003年的ISO/ANSI C 标准编写的,通过大量短小精悍的程序详细而全面地阐述了 C 的基本概念和技术,并专辟一章介绍了C 11新增的功能。
    全书分18章和10个附录。分别介绍了C 程序的运行方式、基本数据类型、复合数据类型、循环和关系表达式、分支语句和逻辑运算符、函数重载和函数模板、内存模型和名称空间、类的设计和使用、多态、虚函数、动态内存分配、继承、代码重用、友元、异常处理技术、string类和标准模板库、输入/输出、C 11新增功能等内容。   
    《C Primer Plus(第6版)中文版》针对C 初学者,书中从C语言基础知识开始介绍,然后在此基础上详细阐述C 新增的特性,因此不要求读者有C语言方面的背景知识。本书可作为高等院校教授C 课程的教材,也可供初学者自学C 时使用。

    内容节选

    C++高级程序员成长之路

    C++这门语言从诞生到今天已经经历了将近30个年头。不可否认,它的学习难度都比其它语言较高。而它的学习难度,主要来自于它的复杂性。现在C++的使用范围比以前已经少了很多,java、C#、python等语言在很多方面已经可以代替C++。但是也有很多地方是其他语言完全无法替代的,主要集中在需要运行效率比较高的行业,比如游戏、高效的服务器。

    现在学习java、C#等语言的人数远远高于C++,主要是C++的入门门槛太高,可能学习了一段时间后还做不了什么东西,导致信心大受打击,进而放弃。

    我想把我自己的经验分享给大家,希望帮助新人少走些弯路。

    在此我们不讨论具体的技术细节,只说我们应该学习什么东西。

    一、技术能力

    1.语言

    我们要成为一个程序员,学的东西会很多很杂,但是最开始一定要从语言开始学习,而学习语言最关键的莫过于选好一本书,学校的教材就算了,根本没有写得好的。在此隆重推荐《C++ Primer》,这本书很厚,内容也很丰富,对知识的讲解不仅仅停留在表面。如果这本书能有耐心看完,语言方面基本就没有什么大问题了,对以后的学习也打下了一个很好的基础。

    2.GUI

    C++方面的GUI库有很多种,比如MFC、WTL、wxWidgets、QT。这些GUI库都各有自己的特点,其实我们只要先了解一种就可以了,只要深入了解了一种GUI库,需要的时候再学习其他的就够了,本质上都差不多,很快就可以上手了。MFC虽然设计上有很多问题,但是作为入门还是不错的,而且学习资料很多,碰到问题也好解决。

    3.数据结构和算法

    很多人都忽视了数据结构和算法方面的知识,尤其是一些编程语言的库做得非常好,几乎不需要自己去实现一些数据结构和算法,导致现在很多程序员不重视甚至忽略这方面的知识。但是,当我们想让我们的程序跑的更快、内存占用更少的时候,这些知识就非常非常重要了。很多程序员都是刚开始的时候不重视这些,但是工作几年后又来补习这些知识。

    最开始可能不需要学习的太深入,但是基本的数据结构和算法一定要知道。

    推荐《数据结构(C语言版)》,在数据结构和算法的学习中,最好不要去关心面向对象方面的技巧,就用C语言来实现,这样能更关注于算法本身的内容。

    4.数据库

    学习数据库的基础知识,并且掌握一种数据库使用,推荐使用mysql,而且最好不要用一些封装好的接口,而应该直接用mysql提供的数据库api,可能对数据库了解的会更深入。

    5.并行

    cpu主频已经不能遵循摩尔定律了,现在cpu发展的趋势是多核心。无论是多线程,还是多进程,都是为了更好的利用cpu的性能,提供更好的用户体验。这就要求我们如果要写出高效的应用程序,必然要涉及到并行计算。多花些精力在并行计算上吧,一定会有丰富的回报。

    6.网络编程

    这里所指的网络编程是指socket编程。现在C++的应用很多都是在做服务器开发,如何开发一个高并发、大吞吐量、高稳定性的服务器就是我们要考虑的了。

    7.设计模式

    设计模式不是具体的技术,更多的是如何让代码更容易阅读、更好扩展、更容易使用。

    8.库的使用

    C++标准库仅仅提供了一些很基本的功能,所以我们经常会引入一些第三方库。最著名的恐怕就是被称为准标准库的boost库,它提供了我们编程中用到的各方面的技术,文本处理、算法、网络、多线程、图像处理等等,几乎无所不包。其它也有一些专著于某一方面的库,比如ACE是网络通信方面的,TinyXML是解析xml的,OGRE是图形渲染方面的。

    9.操作系统的知识

    程序员需要了解的操作系统知识和普通用户是不一样的,一个高手是需要深入了解操作系统的方方面面,而不是停留在使用层面。至于应该了解哪些知识,windows上的去看《windows核心编程》,linux的去看《深入理解linux内核》,应该可以知道自己应该学什么了。

    二、项目经验

    以上的内容如果都精通了,也算是个比较厉害的程序员了。但是对程序员来说,项目经验更加重要。一个好的项目可以让你把各种技术进行综合运用,并且能学到一些新的知识。比如说做游戏的就需要学习图形方面的知识,做播放器的要学习编解码器方面的知识。

    很多程序员会忽略项目的经验,而单纯的谈技术能力,这是错误的。其实这就是理论和实践的关系,技术就是理论知识,做项目就是实践,理论对实践有知道作用,实践能加深我们对理论的深入理解。

    三、沟通能力

    沟通能力是一个高级程序员要具备的软实力。

    我这里想说的沟通能力并不是一般说的能说会道,夸夸其谈,说话天花乱坠。而是建立在技术基础之上的沟通能力。

    目录

    • 第1章 预备知识 1
    • 1.1 C 简介 1
    • 1.2 C 简史 2
    • 1.2.1 C语言 2
    • 1.2.2 C语言编程原理 2
    • 1.2.3 面向对象编程 3
    • 1.2.4 C 和泛型编程 4
    • 1.2.5 C 的起源 4
    • 1.3 可移植性和标准 5
    • 1.3.1 C 的发展 6
    • 1.3.2 本书遵循的C 标准 6
    • 1.4 程序创建的技巧 6
    • 1.4.1 创建源代码文件 7
    • 1.4.2 编译和链接 8
    • 1.5 总结 10
    • 第2章 开始学习C  12
    • 2.1 进入C  12
    • 2.1.1 main()函数 13
    • 2.1.2 C 注释 15
    • 2.1.3 C 预处理器和iostream文件 16
    • 2.1.4 头文件名 16
    • 2.1.5 名称空间 17
    • 2.1.6 使用cout进行C 输出 18
    • 2.1.7 C 源代码的格式化 19
    • 2.2 C 语句 21
    • 2.2.1 声明语句和变量 21
    • 2.2.2 赋值语句 22
    • 2.2.3 cout的新花样 23
    • 2.3 其他C 语句 23
    • 2.3.1 使用cin 24
    • 2.3.2 使用cout进行拼接 24
    • 2.3.3 类简介 25
    • 2.4 函数 26
    • 2.4.1 使用有返回值的函数 26
    • 2.4.2 函数变体 29
    • 2.4.3 用户定义的函数 29
    • 2.4.4 用户定义的有返回值的函数 32
    • 2.4.5 在多函数程序中使用using编译指令 33
    • 2.5 总结 34
    • 2.6 复习题 35
    • 2.7 编程练习 35
    • 第3章 处理数据 37
    • 3.1 简单变量 37
    • 3.1.1 变量名 38
    • 3.1.2 整型 39
    • 3.1.3 整型short、int、long和long long 39
    • 3.1.4 无符号类型 43
    • 3.1.5 选择整型类型 45
    • 3.1.6 整型字面值 45
    • 3.1.7 C 如何确定常量的类型 47
    • 3.1.8 char类型:字符和小整数 47
    • 3.1.9 bool类型 53
    • 3.2 const限定符 54
    • 3.3 浮点数 55
    • 3.3.1 书写浮点数 55
    • 3.3.2 浮点类型 56
    • 3.3.3 浮点常量 58
    • 3.3.4 浮点数的优缺点 58
    • 3.4 C 算术运算符 59
    • 3.4.1 运算符优先级和结合性 60
    • 3.4.2 除法分支 60
    • 3.4.3 求模运算符 61
    • 3.4.4 类型转换 62
    • 3.4.5 C 11中的auto声明 66
    • 3.5 总结 67
    • 3.6 复习题 67
    • 3.7 编程练习 68
    • 第4章 复合类型 70
    • 4.1 数组 70
    • 4.1.1 程序说明 72
    • 4.1.2 数组的初始化规则 73
    • 4.1.3 C 11数组初始化方法 73
    • 4.2 字符串 74
    • 4.2.1 拼接字符串常量 75
    • 4.2.2 在数组中使用字符串 76
    • 4.2.3 字符串输入 77
    • 4.2.4 每次读取一行字符串输入 78
    • 4.2.5 混合输入字符串和数字 81
    • 4.3 string类简介 82
    • 4.3.1 C 11字符串初始化 83
    • 4.3.2 赋值、拼接和附加 83
    • 4.3.3 string类的其他操作 84
    • 4.3.4 string类I/O 86
    • 4.3.5 其他形式的字符串字面值 87
    • 4.4 结构简介 88
    • 4.4.1 在程序中使用结构 89
    • 4.4.2 C 11结构初始化 91
    • 4.4.3 结构可以将string类作为成员吗 91
    • 4.4.4 其他结构属性 91
    • 4.4.5 结构数组 93
    • 4.4.6 结构中的位字段 94
    • 4.5 共用体 94
    • 4.6 枚举 95
    • 4.6.1 设置枚举量的值 97
    • 4.6.2 枚举的取值范围 97
    • 4.7 指针和自由存储空间 97
    • 4.7.1 声明和初始化指针 100
    • 4.7.2 指针的危险 101
    • 4.7.3 指针和数字 102
    • 4.7.4 使用new来分配内存 102
    • 4.7.5 使用delete释放内存 104
    • 4.7.6 使用new来创建动态数组 104
    • 4.8 指针、数组和指针算术 106
    • 4.8.1 程序说明 107
    • 4.8.2 指针小结 109
    • 4.8.3 指针和字符串 111
    • 4.8.4 使用new创建动态结构 114
    • 4.8.5 自动存储、静态存储和动态存储 117
    • 4.9 类型组合 118
    • 4.10 数组的替代品 120
    • 4.10.1 模板类vector 120
    • 4.10.2 模板类array(C 11) 120
    • 4.10.3 比较数组、vector对象和array对象 120
    • 4.11 总结 122
    • 4.12 复习题 123
    • 4.13 编程练习 123
    • 第5章 循环和关系表达式 125
    • 5.1 for循环 125
    • 5.1.1 for循环的组成部分 126
    • 5.1.2 回到for循环 131
    • 5.1.3 修改步长 132
    • 5.1.4 使用for循环访问字符串 133
    • 5.1.5 递增运算符( )和递减运算符(--) 133
    • 5.1.6 副作用和顺序点 134
    • 5.1.7 前缀格式和后缀格式 135
    • 5.1.8 递增/递减运算符和指针 135
    • 5.1.9 组合赋值运算符 136
    • 5.1.10 复合语句(语句块) 136
    • 5.1.11 其他语法技巧——逗号运算符 138
    • 5.1.12 关系表达式 140
    • 5.1.13 赋值、比较和可能犯的错误 141
    • 5.1.14 C-风格字符串的比较 142
    • 5.1.15 比较string类字符串 144
    • 5.2 while循环 145
    • 5.2.1 for与while 147
    • 5.2.2 等待一段时间:编写延时循环 148
    • 5.3 do while循环 150
    • 5.4 基于范围的for循环(C 11) 152
    • 5.5 循环和文本输入 152
    • 5.5.1 使用原始的cin进行输入 152
    • 5.5.2 使用cin.get(char)进行补救 153
    • 5.5.3 使用哪一个cin.get() 154
    • 5.5.4 文件尾条件 155
    • 5.5.5 另一个cin.get()版本 157
    • 5.6 嵌套循环和二维数组 159
    • 5.6.1 初始化二维数组 160
    • 5.6.2 使用二维数组 160
    • 5.7 总结 162
    • 5.8 复习题 163
    • 5.9 编程练习 163
    • 第6章 分支语句和逻辑运算符 165
    • 6.1 if语句 165
    • 6.1.1 if else语句 167
    • 6.1.2 格式化if else语句 168
    • 6.1.3 if else if else结构 169
    • 6.2 逻辑表达式 170
    • 6.2.1 逻辑OR运算符:|| 171
    • 6.2.2 逻辑AND运算符:&& 172
    • 6.2.3 用&&来设置取值范围 174
    • 6.2.4 逻辑NOT运算符:! 175
    • 6.2.5 逻辑运算符细节 176
    • 6.2.6 其他表示方式 177
    • 6.3 字符函数库cctype 177
    • 6.4 ?:运算符 179
    • 6.5 switch语句 180
    • 6.5.1 将枚举量用作标签 183
    • 6.5.2 switch和if else 184
    • 6.6 break和continue语句 185
    • 6.7 读取数字的循环 187
    • 6.8 简单文件输入/输出 190
    • 6.8.1 文本I/O和文本文件 190
    • 6.8.2 写入到文本文件中 191
    • 6.8.3 读取文本文件 194
    • 6.9 总结 197
    • 6.10 复习题 198
    • 6.11 编程练习 199
    • 第7章 函数——C 的编程模块 202
    • 7.1 复习函数的基本知识 202
    • 7.1.1 定义函数 203
    • 7.1.2 函数原型和函数调用 205
    • 7.2 函数参数和按值传递 207
    • 7.2.1 多个参数 208
    • 7.2.2 另外一个接受两个参数的函数 210
    • 7.3 函数和数组 212
    • 7.3.1 函数如何使用指针来处理数组 213
    • 7.3.2 将数组作为参数意味着什么 213
    • 7.3.3 更多数组函数示例 215
    • 7.3.4 使用数组区间的函数 220
    • 7.3.5 指针和const 221
    • 7.4 函数和二维数组 224
    • 7.5 函数和C-风格字符串 225
    • 7.5.1 将C-风格字符串作为参数的函数 225
    • 7.5.2 返回C-风格字符串的函数 227
    • 7.6 函数和结构 228
    • 7.6.1 传递和返回结构 228
    • 7.6.2 另一个处理结构的函数示例 230
    • 7.6.3 传递结构的地址 234
    • 7.7 函数和string对象 235
    • 7.8 函数与array对象 236
    • 7.9 递归 238
    • 7.9.1 包含一个递归调用的递归 239
    • 7.9.2 包含多个递归调用的递归 240
    • 7.10 函数指针 241
    • 7.10.1 函数指针的基础知识 241
    • 7.10.2 函数指针示例 243
    • 7.10.3 深入探讨函数指针 244
    • 7.10.4 使用typedef进行简化 248
    • 7.11 总结 248
    • 7.12 复习题 249
    • 7.13 编程练习 250
    • 第8章 函数探幽 253
    • 8.1 C 内联函数 253
    • 8.2 引用变量 255
    • 8.2.1 创建引用变量 256
    • 8.2.2 将引用用作函数参数 258
    • 8.2.3 引用的属性和特别之处 260
    • 8.2.4 将引用用于结构 263
    • 8.2.5 将引用用于类对象 268
    • 8.2.6 对象、继承和引用 271
    • 8.2.7 何时使用引用参数 274
    • 8.3 默认参数 274
    • 8.4 函数重载 276
    • 8.4.1 重载示例 278
    • 8.4.2 何时使用函数重载 280
    • 8.5 函数模板 281
    • 8.5.1 重载的模板 283
    • 8.5.2 模板的局限性 285
    • 8.5.3 显式具体化 285
    • 8.5.4 实例化和具体化 288
    • 8.5.5 编译器选择使用哪个函数版本 289
    • 8.5.6 模板函数的发展 295
    • 8.6 总结 297
    • 8.7 复习题 297
    • 8.8 编程练习 298
    • 第9章 内存模型和名称空间 300
    • 9.1 单独编译 300
    • 9.2 存储持续性、作用域和链接性 304
    • 9.2.1 作用域和链接 305
    • 9.2.2 自动存储持续性 305
    • 9.2.3 静态持续变量 309
    • 9.2.4 静态持续性、外部链接性 310
    • 9.2.5 静态持续性、内部链接性 313
    • 9.2.6 静态存储持续性、无链接性 315
    • 9.2.7 说明符和限定符 317
    • 9.2.8 函数和链接性 318
    • 9.2.9 语言链接性 319
    • 9.2.10 存储方案和动态分配 319
    • 9.3 名称空间 324
    • 9.3.1 传统的C 名称空间 324
    • 9.3.2 新的名称空间特性 325
    • 9.3.3 名称空间示例 331
    • 9.3.4 名称空间及其前途 334
    • 9.4 总结 335
    • 9.5 复习题 335
    • 9.6 编程练习 338
    • 第10章 对象和类 340
    • 10.1 过程性编程和面向对象编程 340
    • 10.2 抽象和类 341
    • 10.2.1 类型是什么 341
    • 10.2.2 C 中的类 342
    • 10.2.3 实现类成员函数 345
    • 10.2.4 使用类 349
    • 10.2.5 修改实现 350
    • 10.2.6 小结 351
    • 10.3 类的构造函数和析构函数 352
    • 10.3.1 声明和定义构造函数 353
    • 10.3.2 使用构造函数 354
    • 10.3.3 默认构造函数 354
    • 10.3.4 析构函数 355
    • 10.3.5 改进Stock类 356
    • 10.3.6 构造函数和析构函数小结 362
    • 10.4 this指针 363
    • 10.5 对象数组 368
    • 10.6 类作用域 370
    • 10.6.1 作用域为类的常量 371
    • 10.6.2 作用域内枚举(C 11) 372
    • 10.7 抽象数据类型 373
    • 10.8 总结 376
    • 10.9 复习题 377
    • 10.10 编程练习 377
    • 第11章 使用类 380
    • 11.1 运算符重载 380
    • 11.2 计算时间:一个运算符重载示例 381
    • 11.2.1 添加加法运算符 384
    • 11.2.2 重载限制 387
    • 11.2.3 其他重载运算符 388
    • 11.3 友元 390
    • 11.3.1 创建友元 391
    • 11.3.2 常用的友元:重载<<运算符 392
    • 11.4 重载运算符:作为成员函数还是非成员函数 397
    • 11.5 再谈重载:一个矢量类 398
    • 11.5.1 使用状态成员 404
    • 11.5.2 为Vector类重载算术运算符 406
    • 11.5.3 对实现的说明 408
    • 11.5.4 使用Vector类来模拟随机漫步 408
    • 11.6 类的自动转换和强制类型转换 411
    • 11.6.1 转换函数 415
    • 11.6.2 转换函数和友元函数 419
    • 11.7 总结 421
    • 11.8 复习题 422
    • 11.9 编程练习 422
    • 第12章 类和动态内存分配 425
    • 12.1 动态内存和类 425
    • 12.1.1 复习示例和静态类成员 425
    • 12.1.2 特殊成员函数 432
    • 12.1.3 回到Stringbad:复制构造函数的哪里出了问题 434
    • 12.1.4 Stringbad的其他问题:赋值运算符 436
    • 12.2 改进后的新String类 437
    • 12.2.1 修订后的默认构造函数 438
    • 12.2.2 比较成员函数 439
    • 12.2.3 使用中括号表示法访问字符 439
    • 12.2.4 静态类成员函数 441
    • 12.2.5 进一步重载赋值运算符 441
    • 12.3 在构造函数中使用new时应注意的事项 446
    • 12.3.1 应该和不应该 447
    • 12.3.2 包含类成员的类的逐成员复制 448
    • 12.4 有关返回对象的说明 449
    • 12.4.1 返回指向const对象的引用 449
    • 12.4.2 返回指向非const对象的引用 449
    • 12.4.3 返回对象 450
    • 12.4.4 返回const对象 450
    • 12.5 使用指向对象的指针 451
    • 12.5.1 再谈new和delete 453
    • 12.5.2 指针和对象小结 454
    • 12.5.3 再谈定位new运算符 456
    • 12.6 复习各种技术 459
    • 12.6.1 重载<<运算符 459
    • 12.6.2 转换函数 460
    • 12.6.3 其构造函数使用new的类 460
    • 12.7 队列模拟 460
    • 12.7.1 队列类 461
    • 12.7.2 Customer类 468
    • 12.7.3 ATM模拟 471
    • 12.8 总结 475
    • 12.9 复习题 476
    • 12.10 编程练习 477
    • 第13章 类继承 480
    • 13.1 一个简单的基类 481
    • 13.1.1 派生一个类 482
    • 13.1.2 构造函数:访问权限的考虑 484
    • 13.1.3 使用派生类 486
    • 13.1.4 派生类和基类之间的特殊关系 488
    • 13.2 继承:is-a关系 489
    • 13.3 多态公有继承 490
    • 13.4 静态联编和动态联编 501
    • 13.4.1 指针和引用类型的兼容性 502
    • 13.4.2 虚成员函数和动态联编 503
    • 13.4.3 有关虚函数注意事项 505
    • 13.5 访问控制:protected 507
    • 13.6 抽象基类 508
    • 13.6.1 应用ABC概念 510
    • 13.6.2 ABC理念 516
    • 13.7 继承和动态内存分配 516
    • 13.7.1 第一种情况:派生类不使用new 516
    • 13.7.2 第二种情况:派生类使用new 517
    • 13.7.3 使用动态内存分配和友元的继承示例 519
    • 13.8 类设计回顾 523
    • 13.8.1 编译器生成的成员函数 523
    • 13.8.2 其他的类方法 524
    • 13.8.3 公有继承的考虑因素 527
    • 13.8.4 类函数小结 530
    • 13.9 总结 530
    • 13.10 复习题 531
    • 13.11 编程练习 531
    • 第14章 C 中的代码重用 534
    • 14.1 包含对象成员的类 534
    • 14.1.1 valarray类简介 535
    • 14.1.2 Student类的设计 535
    • 14.1.3 Student类示例 537
    • 14.2 私有继承 543
    • 14.2.1 Student类示例(新版本) 543
    • 14.2.2 使用包含还是私有继承 549
    • 14.2.3 保护继承 549
    • 14.2.4 使用using重新定义访问权限 550
    • 14.3 多重继承 551
    • 14.3.1 有多少Worker 555
    • 14.3.2 哪个方法 558
    • 14.3.3 MI小结 567
    • 14.4 类模板 567
    • 14.4.1 定义类模板 568
    • 14.4.2 使用模板类 570
    • 14.4.3 深入探讨模板类 572
    • 14.4.4 数组模板示例和非类型参数 577
    • 14.4.5 模板多功能性 578
    • 14.4.6 模板的具体化 582
    • 14.4.7 成员模板 584
    • 14.4.8 将模板用作参数 586
    • 14.4.9 模板类和友元 588
    • 14.4.10 模板别名(C 11) 593
    • 14.5 总结 594
    • 14.6 复习题 595
    • 14.7 编程练习 597
    • 第15章 友元、异常和其他 602
    • 15.1 友元 602
    • 15.1.1 友元类 602
    • 15.1.2 友元成员函数 606
    • 15.1.3 其他友元关系 609
    • 15.1.4 共同的友元 610
    • 15.2 嵌套类 611
    • 15.2.1 嵌套类和访问权限 612
    • 15.2.2 模板中的嵌套 613
    • 15.3 异常 616
    • 15.3.1 调用abort() 616
    • 15.3.2 返回错误码 617
    • 15.3.3 异常机制 619
    • 15.3.4 将对象用作异常类型 621
    • 15.3.5 异常规范和C 11 624
    • 15.3.6 栈解退 625
    • 15.3.7 其他异常特性 629
    • 15.3.8 exception类 631
    • 15.3.9 异常、类和继承 634
    • 15.3.10 异常何时会迷失方向 639
    • 15.3.11 有关异常的注意事项 641
    • 15.4 RTTI 642
    • 15.4.1 RTTI的用途 642
    • 15.4.2 RTTI的工作原理 642
    • 15.5 类型转换运算符 649
    • 15.6 总结 652
    • 15.7 复习题 653
    • 15.8 编程练习 654
    • 第16章 string类和标准模板库 655
    • 16.1 string类 655
    • 16.1.1 构造字符串 655
    • 16.1.2 string类输入 659
    • 16.1.3 使用字符串 661
    • 16.1.4 string还提供了哪些功能 665
    • 16.1.5 字符串种类 666
    • 16.2 智能指针模板类 667
    • 16.2.1 使用智能指针 668
    • 16.2.2 有关智能指针的注意事项 670
    • 16.2.3 unique_ptr为何优于auto_ptr 672
    • 16.2.4 选择智能指针 673
    • 16.3 标准模板库 674
    • 16.3.1 模板类vector 675
    • 16.3.2 可对矢量执行的操作 676
    • 16.3.3 对矢量可执行的其他操作 680
    • 16.3.4 基于范围的for循环(C 11) 684
    • 16.4 泛型编程 684
    • 16.4.1 为何使用迭代器 685
    • 16.4.2 迭代器类型 688
    • 16.4.3 迭代器层次结构 689
    • 16.4.4 概念、改进和模型 690
    • 16.4.5 容器种类 695
    • 16.4.4 关联容器 702
    • 16.4.5 无序关联容器(C 11) 707
    • 16.5 函数对象 707
    • 16.5.1 函数符概念 707
    • 16.5.2 预定义的函数符 710
    • 16.5.3 自适应函数符和函数适配器 711
    • 16.6 算法 713
    • 16.6.1 算法组 713
    • 16.6.2 算法的通用特征 714
    • 16.6.3 STL和string类 715
    • 16.6.4 函数和容器方法 716
    • 16.6.5 使用STL 717
    • 16.7 其他库 720
    • 16.7.1 vector、valarray和array 720
    • 16.7.2 模板initializer_list(C 11) 724
    • 16.7.3 使用initializer_list 725
    • 16.8 总结 727
    • 16.9 复习题 728
    • 16.10 编程练习 728
    • 第17章 输入、输出和文件 731
    • 17.1 C 输入和输出概述 731
    • 17.1.1 流和缓冲区 732
    • 17.1.2 流、缓冲区和iostream文件 733
    • 17.1.3 重定向 735
    • 17.2 使用cout进行输出 736
    • 17.2.1 重载的<<运算符 736
    • 17.2.2 其他ostream方法 738
    • 17.2.3 刷新输出缓冲区 740
    • 17.2.4 用cout进行格式化 741
    • 17.3 使用cin进行输入 753
    • 17.3.1 cin>>如何检查输入 754
    • 17.3.2 流状态 756
    • 17.3.3 其他istream类方法 759
    • 17.3.4 其他istream方法 764
    • 17.4 文件输入和输出 768
    • 17.4.1 简单的文件I/O 768
    • 17.4.2 流状态检查和is_open() 770
    • 17.4.3 打开多个文件 771
    • 17.4.4 命令行处理技术 772
    • 17.4.5 文件模式 773
    • 17.4.6 随机存取 781
    • 17.5 内核格式化 788
    • 17.6 总结 790
    • 17.7 复习题 791
    • 17.8 编程练习 792
    • 第18章 探讨C 新标准 795
    • 18.1 复习前面介绍过的C 11功能 795
    • 18.1.1 新类型 795
    • 18.8.2 统一的初始化 795
    • 18.1.3 声明 796
    • 18.1.4 智能指针 798
    • 18.1.5 异常规范方面的修改 798
    • 18.1.6 作用域内枚举 799
    • 18.1.7 对类的修改 799
    • 18.1.8 模板和STL方面的修改 800
    • 18.1.9 右值引用 801
    • 18.2 移动语义和右值引用 802
    • 18.2.1 为何需要移动语义 802
    • 18.2.2 一个移动示例 803
    • 18.2.3 移动构造函数解析 808
    • 18.2.4 赋值 809
    • 18.2.5 强制移动 809
    • 18.3 新的类功能 813
    • 18.3.1 特殊的成员函数 813
    • 18.3.2 默认的方法和禁用的方法 814
    • 18.3.3 委托构造函数 815
    • 18.3.4 继承构造函数 815
    • 18.3.5 管理虚方法:override和final 817
    • 18.4 Lambda函数 817
    • 18.4.1 比较函数指针、函数符和Lambda函数 818
    • 18.4.2 为何使用lambda 820
    • 18.5 包装器 822
    • 18.5.1 包装器function及模板的低效性 823
    • 18.5.2 修复问题 825
    • 18.5.3 其他方式 826
    • 18.6 可变参数模板 827
    • 18.6.1 模板和函数参数包 827
    • 18.6.2 展开参数包 828
    • 18.6.3 在可变参数模板函数中使用递归 828
    • 18.7 C 11新增的其他功能 831
    • 18.7.1 并行编程 831
    • 18.7.2 新增的库 831
    • 18.7.3 低级编程 832
    • 18.7.4 杂项 832
    • 18.8 语言变化 832
    • 18.8.1 Boost项目 833
    • 18.8.2 TR1 833
    • 18.8.3 使用Boost 833
    • 18.9 接下来的任务 834
    • 18.10 总结 834
    • 18.11 复习题 835
    • 18.12 编程练习 838
    • 附录A 计数系统 839
    • A.1 十进制数 839
    • A.2 八进制整数 839
    • A.3 十六进制数 839
    • A.4 二进制数 840
    • A.5 二进制和十六进制 841
    • 附录B C 保留字 842
    • B.1 C 关键字 842
    • B.2 替代标记 842
    • B.3 C 库保留名称 843
    • B.4 有特殊含义的标识符 843
    • 附录C ASCII字符集 845
    • 附录D 运算符优先级 849
    • 附录E 其他运算符 852
    • E.1 按位运算符 852
    • E.1.1 移位运算符 852
    • E.1.2 逻辑按位运算符 853
    • E.1.3 按位运算符的替代表示 855
    • E.1.4 几种常用的按位运算符技术 856
    • E.2 成员解除引用运算符 857
    • E.3 alignof(C 11) 860
    • E.4 noexcept(C 11) 861
    • 附录F 模板类string 862
    • F.1 13种类型和一个常量 862
    • F.2 数据信息、构造函数及其他 863
    • F.2.1 默认构造函数 865
    • F.2.2 使用C-风格字符串的构造函数 865
    • F.2.3 使用部分C-风格字符串的构造函数 865
    • F.2.4 使用左值引用的构造函数 866
    • F.2.5 使用右值引用的构造函数(C 11) 866
    • F.2.6 使用一个字符的n个副本的构造函数 867
    • F.2.7 使用区间的构造函数 867
    • F.2.8 使用初始化列表的构造函数(C 11) 868
    • F.2.9 内存杂记 868
    • F.3 字符串存取 868
    • F.4 基本赋值 869
    • F.5 字符串搜索 869
    • F.5.1 find()系列 870
    • F.5.2 rfind()系列 870
    • F.5.3 find_first_of()系列 870
    • F.5.4 find_last_of()系列 871
    • F.5.5 find_first_not_of()系列 871
    • F.5.6 find_last_not_of()系列 871
    • F.6 比较方法和函数 872
    • F.7 字符串修改方法 873
    • F.7.1 用于追加和相加的方法 873
    • F.7.2 其他赋值方法 874
    • F.7.3 插入方法 874
    • F.7.4 清除方法 875
    • F.7.5 替换方法 875
    • F.7.6 其他修改方法:copy()和swap() 876
    • F.8 输出和输入 876
    • 附录G 标准模板库方法和函数 877
    • G.1 STL和C 11 877
    • G.1.1 新增的容器 877
    • G.1.2 对C 98容器所做的修改 877
    • G.2 大部分容器都有的成员 878
    • G.3 序列容器的其他成员 881
    • G.4 set和map的其他操作 883
    • G.4 无序关联容器(C 11) 884
    • G.5 STL函数 886
    • G.5.1 非修改式序列操作 886
    • G.5.2 修改式序列操作 890
    • G.5.3 排序和相关操作 897
    • G.5.4 数值运算 907
    • 附录H 精选读物和网上资源 909
    • H.1 精选读物 909
    • H.2 网上资源 910
    • 附录I 转换为ISO标准C  911
    • I.1 使用一些预处理器编译指令的替代品 911
    • I.1.1 使用const而不是#define来定义常量 911
    • I.1.2 使用inline而不是#define来定义小型函数 912
    • I.2 使用函数原型 913
    • I.3 使用类型转换 913
    • I.4 熟悉C 特性 913
    • I.5 使用新的头文件 914
    • I.6 使用名称空间 914
    • I.7 使用智能指针 915
    • I.8 使用string类 915
    • I.9 使用STL 915
    • 附录J 复习题答案 916
    • 第2章复习题答案 916
    • 第3章复习题答案 916
    • 第4章复习题答案 917
    • 第5章复习题答案 919
    • 第6章复习题答案 919
    • 第7章复习题答案 920
    • 第8章复习题答案 922
    • 第9章复习题答案 924
    • 第10章复习题答案 925
    • 第11章复习题答案 927
    • 第12章复习题答案 927
    • 第13章复习题答案 929
    • 第14章复习题答案 930
    • 第15章复习题答案 931
    • 第16章复习题答案 932
    • 第17章复习题答案 933
    • 第18章复习题答案 935

    上一篇:数据科学家养成手册  下一篇:JavaScript ES6函数式编程入门经典

    展开 +

    收起 -

    码小辫二维码
     ←点击下载即可登录

    C++编程入门相关电子书
    学习笔记
    网友NO.736959

    PHP中调用C/C++制作的动态链接库的教程

    一般而言,php速度已经比较快,但是,对于一些较高级开发者而言,如果想要追求更快的速度,那毫无疑问可以通过自己写c代码,并编译为动态链接库(常为.so文件),然后php通过创建一个新的扩展(extension),并在扩展里调用该.so文件,同时对外暴露出php函数接口。 在实际使用中,只要调用该函数接口,即可使用底层更快速的c函数服务。 一、动态链接库(shared) 动态链接库的文件名后缀通常是 ".so"。在Windows系统中,其文件名后缀是".dll"。 程序如果是和动态连接库进行链接(link),程序运行时需要能够找到相应的动态链接库文件。 使用动态链接库存编译的程序在运行时要求用户的机器上必需也安装了相应的动态链接库文件,这些库文件需要放置在特定的目录,以让程序能够加载这些库。 虽然这似乎没有使用静态链接库的程序使用方便,但却减少了程序的大小。对于那些会被很多程序使用到的库,使用动态链接的好处就更加明显了。 动态链接库的制作: gcc -shared -fPIC -o libmylib.so mylib.c ; # 编译成为shared library 选项-fPIC在AMD64上是必须的,其它平台是则不是必要选项。 包含静态链接库到动态链接库中 编译动态链接库时,如果需要链接静态库,并把链接库的内容包含到要编译的动态库中,可以使用选项-Wl,--whole-archive。 例如: ……

    网友NO.370675

    如何利用Boost.Python实现Python C/C++混合编程详解

    前言 学习中如果碰到问题,参考官网例子: D:\boost_1_61_0\libs\python\test 参考:Boost.Python 中英文文档。 利用Boost.Python实现Python C/C++混合编程 关于python与C++混合编程,事实上有两个部分 extending 所谓python 程序中调用c/c++代码, 其实是先处理c++代码, 预先生成的动态链接库, 如example.so, 而在python代码中import example;即可使用c/c++的函数 . embedding c++代码中调用 python 代码. 两者都可以用 python c 转换api,解决,具体可以去python官方文档查阅,但是都比较繁琐. 对于1,extending,常用的方案是boost.python以及swig. swig是一种胶水语言,粘合C++,PYTHON,我前面的图形显示二叉树的文章中提到的就是利用pyqt作界面,调用c++代码使用swig生成的.so动态库. 而boost.python则直接转换,可以利用py++自动生成需要的wrapper.关于这方面的内容的入门除了boost.python官网,中文的入门资料推荐 下面话不多说了,来一起看看详细的介绍吧 导出函数 #includestring#includeboost/python.hppusing namespace std;using namespace boost::python;char const * greet(){ return "hello,world";}BOOST_PYTHON_MODULE(hello_ext){ def("greet", greet);} python: import hello_extprint hello_ext.greet() 导出类: 导出默认构造的函数的类 c++ #includestring#includeboost/python.hppusing namespace std;using namespace boost::python;struct World{ void set(string msg) { this-msg = msg; } string greet() { return ms……

    网友NO.969815

    node.js调用C++函数的方法示例

    目前nodejs调用c++主流的有两种方法,分别是addons和ffi addons是nodejs官方的c++扩展实现方案,但是由于需要使用模版,并且要对v8引擎有一定的了解,入门门槛较高。 ffi是nodejs直接调用so库的一种实现,可以调用纯c的接口。 要想node.js调用C++的函数等,须先将C++代码编译成二进制的.node文件。node.js官方文档https://nodejs.org/dist/latest-v8.x/docs/api/addons.html中的C++ addons介绍了如何将C++的代码编译为二进制的.node文件。 一、步骤: 1.首先在项目目录进行npm install -g node-gyp下载node-gyp模块,配置环境参考https://github.com/nodejs/node-gyp 2.这是node官方文档中的例子 // addon.cc#include node.hnamespace demo {using v8::Exception;using v8::FunctionCallbackInfo;using v8::Isolate;using v8::Local;using v8::Number;using v8::Object;using v8::String;using v8::Value;// This is the implementation of the "add" method// Input arguments are passed using the// const FunctionCallbackInfoValuelt;Value // Check the number of arguments passed. if (args.Length() 2) { // Throw an Error that is passed back to JavaScript isolate-ThrowException(Exception::TypeError( String::NewFromUtf8(isolate, "Wrong number of arguments"))); return; } // Check the argument types if (!args[0]-IsNumber() || !args[1]-IsNumber()) { isolate-ThrowException(Exception::TypeError( String::NewFromUtf8(isolate, "Wrong arguments"))); return; } // Perform the operation double value = a……

    网友NO.222882

    python怎么用c++代码

    大家都知道Python的优点是开发效率高,使用方便,C++则是运行效率高,这两者可以相辅相成,不管是在Python项目中嵌入C++代码,或是在C++项目中用Python实现外围功能,都可能遇到Python调用C++模块的需求. 下面列举出集中c++代码导出成Python接口的方法,一起来学习学习吧。 原生态导出 (推荐学习:Python视频教程) Python解释器就是用C实现,因此只要我们的C++的数据结构能让Python认识,理论上就是可以被直接调用的。我们实现test1.cpp如下 #include Python.hint Add(int x, int y){return x + y;}int Del(int x, int y){return x - y;}PyObject* WrappAdd(PyObject* self, PyObject* args){int x, y;if (!PyArg_ParseTuple(args, ii, x, y)){return NULL;}return Py_BuildValue(i, Add(x, y));}PyObject* WrappDel(PyObject* self, PyObject* args){int x, y;if (!PyArg_ParseTuple(args, ii, x, y)){return NULL;}return Py_BuildValue(i, Del(x, y));}static PyMethodDef test_methods[] = {{Add, WrappAdd, METH_VARARGS, something},{Del, WrappDel, METH_VARARGS, something},{NULL, NULL}};extern Cvoid inittest1(){Py_InitModule(test1, test_methods); } 编译命令如下 g++ -fPIC -shared test1.cpp -I/usr/include/python2.7 -o test1.so -fPIC:生成位置无关目标代码,适用于动态连接; -L path:表示在path目录中搜索库文件,如-L.表示在当前目录; -I path:表示在path目录中搜索头文件; -o file:制定输出文件为file; -shared:生成一个共……

    网友NO.24084
    网友NO.24084

    几种字符类型:char 、wchar_t 、char16_t 、char32_t
    内置类型的机器实现:内置类型如何在内存存放
    将负数转换为无符号类型:结果为无符号数的模加上这个负数
    字面值常量:每个字面值常量都对应一种数据类型、字符串字面值(实际是由常量字符构成的数组),可以指定字面值的类型
    转义序列:回车\r、换行\n
    对象:指一块能存储数据并具有某种类型的内存空间
    初始化:列表初始化、默认初始化
    变量声明和定义的关系:分离式编译、extern
    复合类型:基于其他类型定义的类型
    声明符:声明语句int &r;中,&r为声明符,声明符命名了一个变量,也指定该变量为与基本数据类型(此例为int)有关的某种类型
    引用&引用类型:我们称r为引用或引用类型
    指针:*p为声明符,p是变量名,我们称p为指针或指针变量
    const限定符:常量引用(对常量的引用)、可以将一个常量引用绑定到变量、字面值、表达式(因为不允许通过该引用修改这些对象)
    顶/底层const:执行对象拷贝时的限制
    constexpr:声明常量
    decltype类型指示符:返回表达式的类型
    编写自己的头文件:头文件通常包含那些只能定义一次的实体,如类、const、constexpr变量
    预处理变量:#ifdef、#ifndef、#endif
    术语表:常量表达式、头文件保护符、未定义、void*

    网友NO.26531
    网友NO.26531

    客气地说,《C++ Primer》不适合大学C++基础课堂教学,也不适合初学者入门。
    不客气地说,恐怕你们的大学老师也搞不定《C++ Primer》,更别说拿这本书教学生了。
    更不客气地说,国内能把《C++ Primer》读精、读透的人,能有多少?
    从某个层面说,《C++ Primer》极不适合咱们的“国情”。
    当代学生学习(包括自学)计算机编程语言的“基本国情”是什么?
    恐怕最突出的一点,莫过于 —— 追求IDE的直观效果(虽然他们中的许多人压根儿就不知道“IDE”是什么)。
    计算机软件方面的学习,没个图形界面的东西怎么行?没个窗口,哪里还是什么软件?
    你让我学编程,在哪儿编?在哪儿写?
    在写字板里写?在Word里写?写出来怎么运行?
    写字板和Word能把我写的东西“另存为”.exe文件吗?
    那还不得有个工具啥的?最好来个“txt2exe”或者“doc2exe”!
    不是有那啥“rm2mp4”可以让我下片子转到手机里看的嘛!格式转换嘛!
    听说,有个工具,叫“编译器”,可以把程序变成.exe文件。
    好,咱下载了cl,还有g++,行了吧!
    双击它,唉?怎么有个黑窗口一闪而过呀?!别是中病毒了吧!杀毒杀毒,那啥,360杀一下……
    《C++ Primer》书上说,可以用“C:\directory> cl -GX prog1.cpp”。
    这是啥意思啊?在程序里加一行“C:\directory> cl -GX prog1.cpp”?是加在#include那边,还是加在main(){}里面呀?
    不管加哪儿,我都试过了,没反应啊!保存了再双击打开,还是啥反应也没有呀!
    《C++ Primer》这个大砖头,到底怎么教我编程啊?里面怎么连一个编程窗口也没有呀!!
    —— 诸位看到了吗?这就是咱们学生学编程的“基本国情”。
    IDE、编译、链接 …… 等等这些极为重要的基本概念,很少有被厘清过。
    不夸张地说,现在的大学老师,你去问他“编译”究竟是咋回事,具体怎么操作,能为学生讲清楚的,有多少?
    你不是问“编译”吗?你自己去找书看!
    好嘛,学生屁颠儿屁颠儿地去搞一本《编译原理》来看……
    原来是一个大砖头,现在是两个大砖头,极尽坑爹之能势!
    问题到底出在哪儿?
    问题的根源,恐怕就是在于:学生无法把握整个(哪怕部分的)计算机软件体系的结构性脉络,课堂教育无法给与他们准确和细致的向导。
    对于广大学生来说,计算机软件在他们意识中最感官、最直接的印象,几乎都是从图形界面、游戏、QQ聊天、淘宝网购等等获得的。
    就拿命令行对话模式(一种一维顺序性对话模式)来说,大多数学生对它是极其陌生和难以理解的。他们已经太习惯于图形界面(二维的甚至是三维的(加上时间维度体现出的动态过程))。所以,对于编程这门学科,他们仍然认定IDE甚至是RAD才是学习和操练的基础。
    如果把《C++ Primer》交给这群学生,作为入门教程,他们的反应可想而知。
    《C++ Primer 中文版(第4版)》(人民邮电出版社)是一本16开、足有近千页的大书(售价近百元人民币),可是里面没有任何关于IDE操作的教导。
    更要命的是,对于这些学生 —— 在GUI丛林中泡大的孩子、GUI的中毒者、WWW的滥用者,他们学习编程如果有“明确的”目的的话,那几乎一定就是编写Windows GUI软件:搞个QQ盗号木马似乎遥远了些,但起码也要写出个GUI计算器才行呀!
    《C++ Primer》能满足这样的需求吗?
    用C++去编写Windows GUI程序,即便算是MFC、VCL这样的“捷径”,对于这些学生来说,仍然太过深奥和遥不可及。
    有些学得稍微“深”一点儿的学生,知道Visual Basic可以“编写”GUI程序 —— 其实那种“编写”是基于RAD的 —— 他们便望文生义地将“Visual”与RAD画上等号,于是,他们自然地选择了Visual C++,可是结果必定让他们失望,Visual C++ 从6 到 .Net,没有任何RAD的迹象。
    也就是说,即便他们读懂了《C++ Primer》(虽然这是极难的事情),也无法获得关于RAD的半点“实用知识”;《C++ Primer》也无法提供他们达至MFC、VCL这些实现GUI编程的“捷径”的“捷径”。
    在一个充满虚无感、焦躁习性的世代,《C++ Primer》竟也无法以她的厚重、凝练与深邃,唤醒众人回归理性和沉稳的道路。

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明