浏览本商品所属分类:首页 > 计算机 > 程序设计 > C/C++/C# > C++
《C++捷径教程(第3版) 》
C++捷径教程(第3版)
作者:希尔特
译者:
开本:16开
ISBN:730208052
出版社:清华大学出版社
出版日期:2004-02-01
装帧:精装
书夫曼编号:620106
原价: 43
普通会员:40.21  一星会员:39.00
二星会员:38.20  三星会员:37.40

内容简介

书以最易于教学的编排和大量附有细致注解的典型程序示例,从基础知识到最新的高级特性,全面讲解了C++语言。通过本书,读者可以了解C++及C++程序的一般形式,并逐步掌握C++语言的核心内容,包括控制语句、运算符、变量、类和对象、异常处理、模板、名称空间、运行时类型ID和标准模板库等,还能学习到用于.NET编程的扩展关键字。全书内容秉承Herbert一贯的写作风格:简洁、清晰、精准。
Herbert  Schildt是世界顶级程序设计大师,C,C++,Java和C#等主流语言的编程权威,Winodws程序设计专家。他所编著的计算机图书全球销量逾300万册,并被翻译成多种语言流传于世。Herbert所著畅销书籍包括:C++:The  Complete  Reference、C#:The  Complete  Reference、Java  2:The  Complete  Reference等等。
本书是程序设计大师Herbert  Schildt多年开发、教学经验的总结,以实践证明行之有效的方法让您快速精通C++语言。
        本书以最易于教学的编排和大量附有细致注解的典型程序示例,从基础知识到最新的高级特性,全面讲解了C++语言。通过本书,?琳呖梢粤私釩++及C++程序的一般形式,并逐步掌握C++语言的核心内容,包括控制语句、运算符、变量、类和对象、异常处理、模板、名称空间、运行时类型ID和标准模板库等,还能学习到用于.NET编程的扩展关键字。全书内容秉承Herbert一贯的写作风格:简洁、清晰、精准。
        本书为C++编程入门读物,面向没有编程经验的程序设计及C++语言的初学者,适合作为高等院校计算机专业相关课程教材,也可为广大编程爱好者深入学习C++及其他面向对象语言打下坚实的基础。


顾客评论
>>浏览该商品的全部评论 >>我要发表评论

目录

目      录  第1章    C    的发展历程 1                                      1.1    C    的起源 1                                      1.1.1    C的诞生 1                                      1.1.2    对C    的需求 3                                      1.1.3    C    的诞生 3                                      1.2    C    的发展 4                                      1.3    什么是面向对象程序设计 5                                      1.3.1    封装 5                                      1.3.2    多态 5                                      1.3.3    继承 6                                      1.3.4    C    实现OOP 6                                      1.3.5    C    与Java和C# 6                                      第2章    C    概览 8                                      2.1    第一个C    程序 8                                      2.1.1    键入程序 9                                      2.1.2    编译程序 9                                      2.1.3    运行程序 9                                      2.1.4    逐行解释 10                                      2.2    处理语法错误 12                                      2.3    第二个C    程序 12                                      2.4    一个更实际的例子 13                                      2.5    一种新的数据类型 14                                      2.6    快速回顾 15                                      2.7    函数 15                                      2.8    函数的参数 16                                      2.8.1    函数返回值 18                                      2.8.2    函数main     19                                      2.8.3    C    函数的通用形式 19                                      2.9    输出选项 20                                      2.10    两个简单的命令 20                                      2.10.1    if  语句 20                                      2.10.2    for  循环 21                                      2.11    代码块 22                                      2.12    分号与定位 23                                      2.13    缩进编排 24                                      2.14    C    中的关键字 24                                      2.15    C    的标识符 25                                      2.16    标准C    库 25                                      第3章    基本数据类型 26                                      3.1    变量的声明 27                                      3.1.1    局部变量 27                                      3.1.2    形式参数 28                                      3.1.3    全局变量 28                                      3.2    类型修饰符 29                                      3.3    字面量 32                                      3.3.1    十六进制与八进制的字面量 33                                      3.3.2    字符串字面量 33                                      3.3.3    字符转义序列 34                                      3.4    变量的初始化 34                                      3.5    运算符 36                                      3.5.1    算术运算符 36                                      3.5.2    增量运算与减量运算 37                                      3.5.3    关系运算符与逻辑运算符 38                                      3.6    表达式 41                                      3.6.1    表达式中的类型转换 41                                      3.6.2    bool类型的转换 41                                      3.6.3    强制转换 42                                      3.6.4    空格与圆括号 43                                      第4章    程序控制语句 44                                      4.1    if  语句 44                                      4.1.1    条件表达式 45                                      4.1.2    嵌套  if  语句 46                                      4.1.3    if-else-if  梯状结构 47                                      4.2    for  循环 48                                      4.2.1    for循环的变形 49                                      4.2.2    省略循环组成部分 50                                      4.2.3    无限循环 51                                      4.2.4    延时循环 51                                      4.3    switch语句 51                                      4.4    while  循环 54                                      4.5    do-while循环 55                                      4.6    使用continue 56                                      4.7    用break跳出循环 57                                      4.8    嵌套循环 58                                      4.9    使用goto语句 58                                      4.10    综合应用 59                                      第5章    数组和字符串 61                                      5.1    一维数组 61                                      5.2    字符串 64                                      5.3    字符串库函数 66                                      5.3.1    strcpy 66                                      5.3.2    strcat 67                                      5.3.3    strcmp 67                                      5.3.4    strlen 68                                      5.3.5    使用空字符作为终止符 69                                      5.4    二维数组 70                                      5.5    多维数组 71                                      5.6    数组初始化 72                                      5.7    字符串数组 75                                      第6章    指针 79                                      6.1    什么是指针 79                                      6.2    指针运算符 80                                      6.2.1    基本类型的重要性 81                                      6.2.2    通过指针赋值 82                                      6.3    指针表达式 82                                      6.3.1    指针的数学运算 83                                      6.3.2    指针的比较运算 84                                      6.4    指针和数组 84                                      6.4.1    对指针使用下标 86                                      6.4.2    指针和数组可否互换 87                                      6.5    指针与字符串字面量 87                                      6.6    指针比较的示例 88                                      6.7    指针数组 89                                      6.8    空指针约定 91                                      6.9    多重间接 91                                      6.10    指针带来的问题 93                                      6.10.1    未初始化的指针 93                                      6.10.2    无效的指针比较运算 93                                      6.10.3    忘记复位指针 94                                      第7章    函数,  第一部分:基础知识 96                                      7.1    函数的作用域准则 96                                      7.1.1    局部变量 96                                      7.1.2    形式参数 101                                      7.1.3    全局变量 101                                      7.2    传递指针和数组 102                                      7.2.1    用指针调用函数 103                                      7.2.2    用数组调用函数 104                                      7.2.3    传递字符串 106                                      7.3    argc和argv:函数main    的参数 107                                      7.4    return语句 110                                      7.4.1    从函数中返回 110                                      7.4.2    返回值 111                                      7.4.3    void  函数 112                                      7.4.4    返回指针的函数 113                                      7.5    函数原型 114                                      7.6    头文件:进一步的学习 115                                      7.7    递归 116                                      第8章    函数,  第二部分:引用,  重载和默认参数 119                                      8.1    两种参数传递的方法 119                                      8.1.1    C    如何传递参数 119                                      8.1.2    用指针实现引用调用 120                                      8.2    引用参数 121                                      8.2.1    返回引用 123                                      8.2.2    创建有界数组 126                                      8.2.3    独立引用 127                                      8.2.4    使用引用的一些限制 127                                      8.3    函数的重载 128                                      8.4    函数的默认参数 130                                      8.4.1    默认参数与重载 132                                      8.4.2    正确使用默认参数值 133                                      8.5    函数重载与歧义性 133                                      第9章    更多的数据类型与运算符 136                                      9.1    限定符const和volatile   136                                      9.1.1    const 136                                      9.1.2    volatile 138                                      9.2    存储类型限定符 139                                      9.2.1    auto 139                                      9.2.2    extern 139                                      9.2.3    static变量 141                                      9.2.4    register变量 143                                      9.3    枚举 145                                      9.4    typedef 148                                      9.5    更多运算符 148                                      9.6    按位运算符 148                                      9.6.1    与.  或.  异或和非 149                                      9.6.2    移位运算符 152                                      9.7    运算符? 153                                      9.8    复合赋值运算 154                                      9.9    逗号运算符 155                                      9.10    多重赋值运算 155                                      9.11    使用sizeof 156                                      9.12    使用new和delete进行动态分配 156                                      9.12.1    对动态分配的内存进行初始化 158                                      9.12.2    分配数组的内存 159                                      9.13    优先级综述 161                                      第10章    结构与联合 162                                      10.1    结构 162                                      10.1.1    访问结构成员 164                                      10.1.2    结构数组 164                                      10.1.3    一个简单的库存信息示例程序 165                                      10.1.4    传递结构参数 170                                      10.1.5    结构的赋值 170                                      10.1.6    结构指针与箭头运算符 171                                      10.1.7    结构的引用 174                                      10.1.8    在结构中的数组和结构 175                                      10.1.9    位域 176                                      10.2    联合 178                                      10.3    用sizeof来保证可移植性 182                                      10.4    转入面向对象程序设计 182                                      第11章    类 184                                      11.1    类的基本概念 184                                      11.2    进一步学习类的成员访问 187                                      11.3    构造函数和析构函数 189                                      11.3.1    参数化构造函数 191                                      11.3.2    另一种初始化方法 194                                      11.4    类与结构的关系 195                                      11.5    联合与类 197                                      11.6    内联函数 197                                      11.7    对象数组 200                                      11.8    对象指针 202                                      11.9    对象引用 203                                      第12章    类的深入学习 204                                      12.1    友员函数 204                                      12.2    重载构造函数 207                                      12.3    动态初始化 208                                      12.4    对象赋值 210                                      12.5    将对象传递给函数 211                                      12.5.1    构造函数.  析构函数和对象传递 212                                      12.5.2    传递对象时一个潜在的问题 213                                      12.6    返回对象 215                                      12.7    创建和使用复制构造函数 217                                      12.7.1    复制构造函数与参数 218                                      12.7.2    复制构造函数与初始化 219                                      12.7.3    在返回对象时使用复制构造函数 220                                      12.8    关键字this 222                                      第13章    运算符的重载 223                                      13.1    使用成员函数重载运算符 223                                      13.1.1    使用成员函数重载一元运算符 225                                      13.1.2    运算符重载的技巧与限制 230                                      13.2    非成员运算符函数 230                                      13.3    深入学习赋值运算符 236                                      13.4    重载[  ]   239                                      13.5    重载         241                                      13.6    重载其他的运算符 242                                      13.7    运算符重载的另一个示例 243                                      第14章    继承 247                                      14.1    继承的介绍 247                                      14.2    基类的访问控制 249                                      14.3    使用保护成员 251                                      14.4    多重继承 255                                      14.5    构造函数.  析构函数和继承 256                                      14.5.1    何时执行构造函数和析构函数 256                                      14.5.2    将参数传递给基类构造函数 258                                      14.6    授权访问 261                                      14.7    虚基类 263                                      第15章    虚函数与多态 267                                      15.1    指向派生类型的指针 267                                      15.2    虚函数 269                                      15.2.1    虚函数的继承 271                                      15.2.2    为什么需要虚函数 273                                      15.2.3    虚函数的简单应用 273                                      15.2.4    纯虚函数与抽象类 276                                      15.3    早绑定与晚绑定 278                                      第16章    模板 279                                      16.1    通用函数 279                                      16.2    显式重载通用函数 281                                      16.2.1    重载函数模板 283                                      16.2.2    模板函数使用标准参数 283                                      16.2.3    通用函数的限制 284                                      16.3    通用类 285                                      16.3.1    使用两个通用数据类型的示例 287                                      16.3.2    创建一个通用数组类 288                                      16.3.3    在通用类中使用标准类型的参数 289                                      16.3.4    模板类使用默认参数 290                                      16.3.5    类的显式特例化 292                                      第17章    异常处理 293                                      17.1    异常处理的基础 293                                      17.1.1    异常类 297                                      17.1.2    使用多个catch语句 298                                      17.2    异常处理的选项 299                                      17.2.1    捕获所有的异常 299                                      17.2.2    对函数中抛出异常的限制 301                                      17.2.3    再次抛出异常 302                                      17.3    处理运算符new抛出的异常 303                                      17.4    重载new和delete 305                                      第18章    C    的I/O系统 309                                      18.1    旧式和现代C    的I/O系统 309                                      18.2    C    流 309                                      18.3    C    中的流类型 310                                      18.4    重载I/O运算符 311                                      18.4.1    创建插入符 312                                      18.4.2    使用友员函数重载插入符 313                                      18.4.3    重载提取符 314                                      18.5    格式化I/O 316                                      18.5.1    使用ios的成员函数来格式化数据的I/O 316                                      18.5.2    使用I/O操控符 319                                      18.5.3    创建你自己的操控符函数 321                                      18.6    文件I/O 323                                      18.6.1    打开和关闭一个文件 323                                      18.6.2    文本文件的读与写 324                                      18.6.3    无格式的二进制I/O 325                                      18.6.4    数据块的读写 327                                      18.6.5    检测EOF 328                                      18.6.6    文件比较的示例程序 328                                      18.7    其他的二进制I/O函数 330                                      18.8    随机访问 331                                      18.9    检测I/O状态 333                                      18.10    定制的I/O与文件 334                                      第19章    运行时类型识别与强制转换运算符 336                                      19.1    运行时类型识别(RTTI) 336                                      19.1.1    运行时类型识别的简单应用 339                                      19.1.2    typeid可以应用于模板类 341                                      19.2    强制转换运算符 343                                      19.2.1    dynamic_cast 344                                      19.2.2    const_cast 348                                      19.2.3    static_cast 349                                      19.2.4    reinterpret_cast 349                                      第20章    名字空间和其他高级主题 351                                      20.1    名字空间 351                                      20.1.1    名字空间的基本概念 351                                      20.1.2    using 354                                      20.1.3    匿名名字空间 355                                      20.2    std名字空间 356                                      20.3    函数指针 357                                      20.4    类的静态成员 361                                      20.5    const成员函数和mutable 362                                      20.6    显式构造函数 363                                      20.7    成员初始化语法 365                                      20.8    关键字asm 367                                      20.9    链接指定 367                                      20.10    成员指针运算符.*和->*   368                                      20.11    创建转换函数 370                                      第21章    标准模板库 372                                      21.1    STL概览 372                                      21.2    容器类 374                                      21.3    vector 375                                      21.3.1    使用迭代器访问vector 379                                      21.3.2    在vector中插入和删除元素 380                                      21.3.3    在vector中保存对象 381                                      21.4    list 384                                      21.4.1    list排序 387                                      21.4.2    list合并 388                                      21.4.3    在list中存储对象 389                                      21.5    map 391                                      21.6    算法 395                                      21.6.1    统计 397                                      21.6.2    删除和替换元素 398                                      21.6.3    反序 400                                      21.6.4    序列的变形 400                                      21.6.5    探讨其他的算法 401                                      21.7    string类 401                                      21.7.1    string的一些成员函数 404                                      21.7.2    将字符串放入其他容器中 407                                      21.8    关于STL的最后思考 408                                      第22章    C    预处理器 409                                      22.1    #define 409                                      22.2    #error 412                                      22.3    #include 412                                      22.4    条件编译指令 413                                      22.4.1    #if,  #else,  #elif和#endif 413                                      22.4.2    #ifdef与#ifndef 415                                      22.4.3    #undef 415                                      22.4.4    使用defined 416                                      22.5    #line 416                                      22.6    #pragma 417                                      22.7    预处理器运算符#和## 417                                      22.8    预定义的宏 418                                      22.9    最后的思考 419                                      附录A    基于C的I/O 420                                      A.1    C的I/O系统使用流 420                                      A.2    函数printf    和scanf     421                                      A.3    C的文件系统 426                                      A.4    fseek    与随机访问I/O 432                                      A.5    fprintf    和fscanf     433                                      A.6    删除文件 433                                      附录B    使用旧的C    编译器 434                                      附录C    .NET对C    的受控扩展 436                                      C.1    .NET中的扩展关键字 436                                      C.2    扩展预处理指令 438                                      C.3    属性attribute 438                                      C.4    编译受控C    代码 438


C++捷径教程(第3版) -相关图书
·数据库理论及应用基础
·俄罗斯经济转轨与转轨时期经济论
·科学练声(第二版)
·西班牙语三百句
·日语三百句
·基础物理化学(上册)
·韩国三百句
·印度尼西亚三百句
·神木大保当—汉代城址与墓葬考古报告
·阿拉伯语三百句
·中国纵横:一个汉学家的学术探索之旅
·中级汉语口语 上册
·蓼怀堂琴谱 一函四册
·研露楼琴谱 一函四册
·二香琴谱 一函四册
·曼谷开门
·手机短信:整蛊专家
·手机短信。没事逗你乐
·中国流行语2005发布榜
·高二地理试卷(下学期)
未分类图书 网站地图 全部分类