C Primer(c primer plus电子书)

  • 时间:
  • 9339人关注

这是一篇关于c primer plus的电子书资源热门专题内容,被405位程序员关注,内容涉及到c、primer、pdf中文版电子书、c primer pdf中文版等,由江高韵编辑整理。

  • C Primer Plus(第六版) 复习题参考答案

    《 C primer Plus 》而作为C语言的经典入门书籍,书上的内容受益颇多。可当为课后习题苦恼不已,这里准备了一份较为完备,准确的习题答案。完备的《C primer plus》的答案,以供初入此道的萌新们参考。需要的朋友可下再试试! 《C Primer Plus(第6版)中文版》可作为C语言的教材,适用于需要系统学习C语言的初学者,也适用于巩固C语言知识或希望进一步提高编程技术的程序员。

    大小:46.1 MBCPrimer

C primer Plus》而作为C语言的经典入门书籍,书上的内容受益颇多。可当为课后习题苦恼不已,这里准备了一份较为完备,准确的习题答案。完备的《C primer plus》的答案,以供初入此道的萌新们参考。需要的朋友可下再试试!

《C Primer Plus(第6版)中文版》可作为C语言的教材,适用于需要系统学习C语言的初学者,也适用于巩固C语言知识或希望进一步提高编程技术的程序员。

展开阅读
  • C Primer Plus(第6版)

    C Primer Plus(第6版)

    本书详细讲解了C语言的基本概念和编程技巧,可作为C语言的教材,适用于需要系统学习C语言的初学者,欢迎免费下载

    大小:216.2 MBC语言

C Primer Plus

C Primer Plus(第六版)电子书封面

读者评价

c-primer-plus-ed6: 基础数据类型 字符串与格式化IO 运算符/表达式/语句 控制语句(循环/分支/跳转) 字符IO与输入验证 函数(递归 &运算符) 数组与指针(VLA 复合字面量) 字符串与字符串函数 存储类别/链接/内存管理 文件IO 结构(struct/union/typedef) 位操作 c预处理器和c库 高级数据表示ADT
深入浅出,细致入微。最不可思议的是,我竟然真的从头到尾读完了它
1.C语言绝对不像一些年长的工程师说得那么难,这一本书几乎把它的知识全部都介绍完了。只是要用C语言写出一些容易维护的代码还真需要点经验和技巧。
2.什么C与指针,C陷阱与缺陷...其实也就讲一些很简单的东西(在看完这本书以后)。
3.看完这本书以后,推荐学习一下设计模式(以学习如何写出容易维护的代码为目的)。
4.编码规范必须要看Misra-C文档,它除了介绍规范本身,还会讲到一些本书没有介绍的C语言规则,如实现定义行为和未定义行为的区别、整型提升等。
5.学习《深入了解计算机系统》可以学习到一些C语言实现的细节,优化方法,内存模型、Cache对程序性能的影响,关键路径分析法在现代处理器的应用,类Unix系统编程入门等知识。

内容介绍

《C Primer Plus(第6版)中文版》详细讲解了C语言的基本概念和编程技巧。《C Primer Plus(第6版)中文版》共17章。第1、2章介绍了C语言编程的预备知识。第3~15章详细讲解了C语言的相关知识,包括数据类型、格式化输入/输出、运算符、表达式、语句、循环、字符输入和输出、函数、数组和指针、字符和字符串函数、内存管理、文件输入输出、结构、位操作等。第16章、17章介绍C预处理器、C库和高级数据表示。本书以完整的程序为例,讲解C语言的知识要点和注意事项。每章末设计了大量复习题和编程练习,帮助读者巩固所学知识和提高实际编程能力。附录给出了各章复习题的参考答案和丰富的参考资料。《C Primer Plus(第6版)中文版》可作为C语言的教材,适用于需要系统学习C语言的初学者,也适用于巩固C语言知识或希望进一步提高编程技术的程序员。

内容节选

C语言菜鸟基础教程之求1到100的和

 

题目:求1+2+3+……+98+99+100
(1)用数学方法求解
(2)编写C语言程序求解

解:
(1)数学方法

S = 1+2+3+……+98+99+100
 = (1+100) + (2+99) + (3+98) + …… + (49+52) + (50+51)
 = 101 * 50
 = 5050

(2)C语言编程

#include <stdio.h>

int main()
{
  int sum = 0; // 赋初值
  for(int i = 1; i <= 100; i++)
  {
    sum = sum + i;
  }
  
  printf("total is %d\n", sum);
}

运行结果:

total is 5050

分析:
(1)第一次循环

i = 1, sum = sum + i = 0 + 1 = 1,这里右边的sum的值为初值0,将1赋给左边的sum后,sum的最新值变成了1

(2)第二次循环

i = 2, sum = sum + i = 1 + 2 = 3, 这里右边的sum的值已经通过上一步的计算变成了1。把3赋值给左边的sum后,sum的最新值

就成了3

(3)第三次循环

i = 3, sum = sum + i = 3 + 3 = 6, 这里右边的sum的值已经通过上一步的计算变成了3。把计算结果6赋值给左边的sum后,sum的最新值就成了6

(4)第四次循环

i = 4, sum = sum + i = 6 + 4 = 10, 这里右边的sum的值已经通过上一步的计算变成了6。把计算结果10赋值给左边的sum后,sum的最新值就成了10

(5)……这样执行一百次后,得到的结果为5050

新知识点:

sum = sum + i可以写成sum += i,都是让sum和i相加后,把新的值赋给sum。
以后编程尽量使用+=这种方式。
理由:C语言要通过编译器编译,在编译器没开启优化的情况下,两种写法是完全等价的;编译器开启了优化后,+=的执行速度可能会快一点。(这个先有点印象即可,目前不用深入了解)

作业:
(1)调试上面的程序。每次运行到右大括号时,把鼠标悬在sum上面,观察sum的值。
上面的程序会循环100次,调试的时候,循环10次左右就可以step out了。

(2)
把sum = sum + i改成sum += i,运行结果

#include <stdio.h>

int main()
{
  int sum = 0; // 赋初值
  for(int i = 1; i <= 100; i++)
  {
    sum += i;
  }
  
  printf("total is %d\n", sum);
}

(3)在纸上默写这个程序。

目录

  • 第1章 初识C语言     1
  • 1.1 C语言的起源         1
  • 1.2  选择C语言的理由        1
  • 1.2.1 设计特性    1
  • 1.2.2 高效性         1
  • 1.2.3 可移植性    2
  • 1.2.4 强大而灵活         3
  • 1.2.5 面向程序员         3
  • 1.2.6 缺点    3
  • 1.3 C语言的应用范围         3
  • 1.4  计算机能做什么   4
  • 1.5  高级计算机语言和编译器   5
  • 1.6  语言标准        6
  • 1.6.1 第1个ANSI/ISO C标准     6
  • 1.6.2 C99标准     6
  • 1.6.3 C11标准     7
  • 1.7  使用C语言的7个步骤        7
  • 1.7.1 第1步:定义程序的目标         8
  • 1.7.2 第2步:设计程序     8
  • 1.7.3 第3步:编写代码     8
  • 1.7.4 第4步:编译     8
  • 1.7.5 第5步:运行程序     9
  • 1.7.6 第6步:测试和调试程序         9
  • 1.7.7 第7步:维护和修改代码         9
  • 1.7.8 说明    9
  • 1.8  编程机制        10
  • 1.8.1 目标代码文件、可执行文件和库    10
  • 1.8.2 UNIX系统   11
  • 1.8.3 GNU编译器集合和LLVM项目 13
  • 1.8.4 Linux系统   13
  • 1.8.5 PC的命令行编译器   14
  • 1.8.6 集成开发环境(Windows)      14
  • 1.8.7 Windows/Linux    15
  • 1.8.8 Macintosh中的C        15
  • 1.9  本书的组织结构   15
  • 1.10 本书的约定 16
  • 1.10.1 字体  16
  • 1.10.2 程序输出  16
  • 1.10.3 特殊元素  17
  • 1.11 本章小结      17
  • 1.12 复习题 18
  • 1.13 编程练习      18
  • 第2章 C语言概述      19
  • 2.1  简单的C程序示例        19
  • 2.2  示例解释        20
  • 2.2.1 第1遍:快速概要     21
  • 2.2.2 第2遍:程序细节     21
  • 2.3  简单程序的结构   28
  • 2.4  提高程序可读性的技巧        28
  • 2.5  进一步使用C         29
  • 2.5.1 程序说明    30
  • 2.5.2 多条声明    30
  • 2.5.3 乘法    30
  • 2.5.4 打印多个值         30
  • 2.6  多个函数        30
  • 2.7  调试程序        32
  • 2.7.1 语法错误    32
  • 2.7.2 语义错误    33
  • 2.7.3 程序状态    34
  • 2.8  关键字和保留标识符   34
  • 2.9  关键概念        35
  • 2.10 本章小结      35
  • 2.11 复习题 36
  • 2.12 编程练习      37
  • 第3章 数据和C 39
  • 3.1  示例程序        39
  • 3.2  变量与常量数据   42
  • 3.3  数据:数据类型关键字        42
  • 3.3.1 整数和浮点数    43
  • 3.3.2 整数    43
  • 3.3.3 浮点数         43
  • 3.4 C语言基本数据类型    44
  • 3.4.1 int类型        44
  • 3.4.2 其他整数类型    47
  • 3.4.3 使用字符:char类型         50
  • 3.4.4 _Bool类型  54
  • 3.4.5 可移植类型:stdint.h和inttypes.h 55
  • 3.4.6 float、double和long double      56
  • 3.4.7 复数和虚数类型         60
  • 3.4.8 其他类型    60
  • 3.4.9 类型大小    62
  • 3.5  使用数据类型        63
  • 3.6  参数和陷阱   63
  • 3.7  转义序列示例        64
  • 3.7.1 程序运行情况    65
  • 3.7.2 刷新输出    65
  • 3.8  关键概念        66
  • 3.9  本章小结        66
  • 3.10 复习题 67
  • 3.11 编程练习      68
  • 第4章 字符串和格式化输入/输出   71
  • 4.1  前导程序        71
  • 4.2  字符串简介   72
  • 4.2.1 char类型数组和null字符 72
  • 4.2.2 使用字符串         73
  • 4.2.3 strlen()函数         74
  • 4.3  常量和C预处理器        76
  • 4.3.1 const限定符       78
  • 4.3.2 明示常量    78
  • 4.4 printf()和scanf()     80
  • 4.4.1 printf()函数 80
  • 4.4.2 使用printf()         81
  • 4.4.3 printf()的转换说明修饰符 83
  • 4.4.4 转换说明的意义         87
  • 4.4.5 使用scanf()         92
  • 4.4.6 printf()和scanf()的*修饰符        95
  • 4.4.7 printf()的用法提示     97
  • 4.5  关键概念        98
  • 4.6  本章小结        98
  • 4.7  复习题   99
  • 4.8  编程练习        100
  • 第5章 运算符、表达式和语句 103
  • 5.1  循环简介        103
  • 5.2  基本运算符   105
  • 5.2.1 赋值运算符:=  105
  • 5.2.2 加法运算符:   107
  • 5.2.3 减法运算符:-   107
  • 5.2.4 符号运算符:-和      107
  • 5.2.5 乘法运算符:*  108
  • 5.2.6 除法运算符:/   110
  • 5.2.7 运算符优先级    110
  • 5.2.8 优先级和求值顺序    112
  • 5.3  其他运算符   113
  • 5.3.1 sizeof运算符和size_t类型       113
  • 5.3.2 求模运算符:% 114
  • 5.3.3 递增运算符:          115
  • 5.3.4 递减运算符:--  118
  • 5.3.5 优先级         118
  • 5.3.6 不要自作聪明    119
  • 5.4  表达式和语句        120
  • 5.4.1 表达式         120
  • 5.4.2 语句    120
  • 5.4.3 复合语句(块)         123
  • 5.5  类型转换        124
  • 5.6  带参数的函数        127
  • 5.7  示例程序        129
  • 5.8  关键概念        130
  • 5.9  本章小结        130
  • 5.10 复习题 131
  • 5.11 编程练习      134
  • 第6章 C控制语句:循环 137
  • 6.1  再探while循环     137
  • 6.1.1 程序注释    138
  • 6.1.2 C风格读取循环 139
  • 6.2 while语句      140
  • 6.2.1 终止while循环  140
  • 6.2.2 何时终止循环    141
  • 6.2.3 while:入口条件循环        141
  • 6.2.4 语法要点    141
  • 6.3  用关系运算符和表达式比较大小        143
  • 6.3.1 什么是真    144
  • 6.3.2 其他真值    145
  • 6.3.3 真值的问题         146
  • 6.3.4 新的_Bool类型  147
  • 6.3.5 优先级和关系运算符         148
  • 6.4  不确定循环和计数循环        150
  • 6.5 for循环  151
  • 6.6  其他赋值运算符: =、-=、*=、/=、%=    155
  • 6.7  逗号运算符   156
  • 6.8  出口条件循环:do  while   159
  • 6.9  如何选择循环        161
  • 6.10 嵌套循环      162
  • 6.10.1 程序分析  163
  • 6.10.2 嵌套变式  163
  • 6.11 数组简介      164
  • 6.12 使用函数返回值的循环示例      166
  • 6.12.1 程序分析  168
  • 6.12.2 使用带返回值的函数       169
  • 6.13 关键概念      169
  • 6.14 本章小结      170
  • 6.15 复习题 170
  • 6.16 编程练习      174
  • 第7章 C控制语句:分支和跳转      177
  • 7.1 if语句     177
  • 7.2 if else语句     179
  • 7.2.1 另一个示例:介绍getchar()和putchar() 180
  • 7.2.2 ctype.h系列的字符函数   182
  • 7.2.3 多重选择else  if       184
  • 7.2.4 else与if配对     186
  • 7.2.5 多层嵌套的if语句     187
  • 7.3  逻辑运算符   190
  • 7.3.1 备选拼写:iso646.h头文件      191
  • 7.3.2 优先级         192
  • 7.3.3 求值顺序    192
  • 7.3.4 范围    193
  • 7.4  一个统计单词的程序   194
  • 7.5  条件运算符:?:    196
  • 7.6  循环辅助:continue和break       198
  • 7.6.1 continue语句      198
  • 7.6.2 break语句  200
  • 7.7  多重选择:switch和break  202
  • 7.7.1 switch语句 204
  • 7.7.2 只读每行的首字符    205
  • 7.7.3 多重标签    206
  • 7.7.4 switch和if  else        208
  • 7.8 goto语句        208
  • 7.9  关键概念        211
  • 7.10 本章小结      211
  • 7.11 复习题 212
  • 7.12 编程练习      214
  • 第8章 字符输入/输出和输入验证   217
  • 8.1  单字符I/O:getchar()和putchar()       217
  • 8.2  缓冲区   218
  • 8.3  结束键盘输入        219
  • 8.3.1 文件、流和键盘输入         219
  • 8.3.2 文件结尾    220
  • 8.4  重定向和文件        222
  • 8.5  创建更友好的用户界面        226
  • 8.5.1 使用缓冲输入    226
  • 8.5.2 混合数值和字符输入         228
  • 8.6  输入验证        230
  • 8.6.1 分析程序    234
  • 8.6.2 输入流和数字    234
  • 8.7  菜单浏览        235
  • 8.7.1 任务    235
  • 8.7.2 使执行更顺利    235
  • 8.7.3 混合字符和数值输入         237
  • 8.8  关键概念        240
  • 8.9  本章小结        240
  • 8.10 复习题 241
  • 8.11 编程练习      241
  • 第9章 函数 243
  • 9.1  复习函数        243
  • 9.1.1 创建并使用简单函数         244
  • 9.1.2 分析程序    245
  • 9.1.3 函数参数    247
  • 9.1.4 定义带形式参数的函数    248
  • 9.1.5 声明带形式参数函数的原型    249
  • 9.1.6 调用带实际参数的函数    249
  • 9.1.7 黑盒视角    250
  • 9.1.8 使用return从函数中返回值    250
  • 9.1.9 函数类型    252
  • 9.2 ANSI C函数原型    253
  • 9.2.1 问题所在    253
  • 9.2.2 ANSI的解决方案        254
  • 9.2.3 无参数和未指定参数         255
  • 9.2.4 函数原型的优点         256
  • 9.3  递归        256
  • 9.3.1 演示递归    256
  • 9.3.2 递归的基本原理         258
  • 9.3.3 尾递归         258
  • 9.3.4 递归和倒序计算         260
  • 9.3.5 递归的优缺点    262
  • 9.4  编译多源代码文件的程序   262
  • 9.4.1 UNIX    263
  • 9.4.2 Linux    263
  • 9.4.3  DOS命令行编译器     263
  • 9.4.4 Windows和苹果的IDE编译器 263
  • 9.4.5 使用头文件         263
  • 9.5  查找地址:&运算符     267
  • 9.6  更改主调函数中的变量        268
  • 9.7  指针简介        269
  • 9.7.1 间接运算符:*  270
  • 9.7.2 声明指针    270
  • 9.7.3 使用指针在函数间通信    271
  • 9.8  关键概念        274
  • 9.9  本章小结        275
  • 9.10 复习题 275
  • 9.11 编程练习      276
  • 第10章 数组和指针   277
  • 10.1 数组      277
  • 10.1.1 初始化数组       277
  • 10.1.2 指定初始化器(C99)    281
  • 10.1.3 给数组元素赋值       282
  • 10.1.4 数组边界  282
  • 10.1.5 指定数组的大小       284
  • 10.2 多维数组      284
  • 10.2.1 初始化二维数组       287
  • 10.2.2 其他多维数组  288
  • 10.3 指针和数组 288
  • 10.4 函数、数组和指针      290
  • 10.4.1 使用指针形参  293
  • 10.4.2 指针表示法和数组表示法       294
  • 10.5 指针操作      295
  • 10.6 保护数组中的数据      298
  • 10.6.1 对形式参数使用const     299
  • 10.6.2 const的其他内容     300
  • 10.7 指针和多维数组 302
  • 10.7.1 指向多维数组的指针       304
  • 10.7.2 指针的兼容性  305
  • 10.7.3 函数和多维数组       306
  • 10.8 变长数组(VLA)        309
  • 10.9 复合字面量 312
  • 10.10 关键概念   314
  • 10.11 本章小结   315
  • 10.12 复习题        316
  • 10.13 编程练习   317
  • 第11章 字符串和字符串函数   321
  • 11.1 表示字符串和字符串I/O   321
  • 11.1.1 在程序中定义字符串       322
  • 11.1.2 指针和字符串  328
  • 11.2 字符串输入 329
  • 11.2.1 分配空间  329
  • 11.2.2 不幸的gets()函数    330
  • 11.2.3 gets()的替代品 331
  • 11.2.4 scanf()函数        336
  • 11.3 字符串输出 337
  • 11.3.1 puts()函数 338
  • 11.3.2 fputs()函数        339
  • 11.3.3 printf()函数        339
  • 11.4 自定义输入/输出函数         340
  • 11.5 字符串函数 342
  • 11.5.1 strlen()函数       342
  • 11.5.2 strcat()函数       343
  • 11.5.3 strncat()函数    345
  • 11.5.4 strcmp()函数     346
  • 11.5.5 strcpy()和strncpy()函数   351
  • 11.5.6 sprintf()函数      356
  • 11.5.7 其他字符串函数       357
  • 11.6 字符串示例:字符串排序 359
  • 11.6.1 排序指针而非字符串       360
  • 11.6.2 选择排序算法  361
  • 11.7 ctype.h字符函数和字符串         362
  • 11.8 命令行参数 363
  • 11.8.1 集成环境中的命令行参数       365
  • 11.8.2 Macintosh中的命令行参数    365
  • 11.9 把字符串转换为数字 365
  • 11.10 关键概念   368
  • 11.11 本章小结   368
  • 11.12 复习题        369
  • 11.13 编程练习   371
  • 第12章 存储类别、链接和内存管理       373
  • 12.1 存储类别      373
  • 12.1.1 作用域       374
  • 12.1.2 链接  376
  • 12.1.3 存储期       376
  • 12.1.4 自动变量  377
  • 12.1.5 寄存器变量       380
  • 12.1.6 块作用域的静态变量       381
  • 12.1.7 外部链接的静态变量       382
  • 12.1.8 内部链接的静态变量       386
  • 12.1.9 多文件       386
  • 12.1.10 存储类别说明符    387
  • 12.1.11 存储类别和函数    389
  • 12.1.12 存储类别的选择    389
  • 12.2 随机数函数和静态变量      390
  • 12.3 掷骰子 393
  • 12.4 分配内存:malloc()和free()       396
  • 12.4.1 free()的重要性 399
  • 12.4.2 calloc()函数       400
  • 12.4.3 动态内存分配和变长数组       400
  • 12.4.4 存储类别和动态内存分配       401
  • 12.5 ANSI C类型限定符      402
  • 12.5.1 const类型限定符     403
  • 12.5.2 volatile类型限定符 404
  • 12.5.3 restrict类型限定符 405
  • 12.5.4 _Atomic类型限定符(C11) 406
  • 12.5.5 旧关键字的新位置  406
  • 12.6 关键概念      407
  • 12.7 本章小结      407
  • 12.8 复习题 408
  • 12.9 编程练习      409
  • 第13章 文件输入/输出      413
  • 13.1 与文件进行通信 413
  • 13.1.1 文件是什么       413
  • 13.1.2 文本模式和二进制模式  413
  • 13.1.3 I/O的级别         415
  • 13.1.4 标准文件  415
  • 13.2 标准I/O        415
  • 13.2.1 检查命令行参数       416
  • 13.2.2 fopen()函数       416
  • 13.2.3  getc()和putc()函数  417
  • 13.2.4 文件结尾  418
  • 13.2.5 fclose()函数       419
  • 13.2.6 指向标准文件的指针       419
  • 13.3 一个简单的文件压缩程序 419
  • 13.4 文件I/O:fprintf()、fscanf()、fgets()和fputs() 421
  • 13.4.1 fprintf()和fscanf()函数     421
  • 13.4.2 fgets()和fputs()函数         422
  • 13.5 随机访问:fseek()和ftell() 423
  • 13.5.1 fseek()和ftell()的工作原理      424
  • 13.5.2 二进制模式和文本模式  425
  • 13.5.3 可移植性  425
  • 13.5.4 fgetpos()和fsetpos()函数         426
  • 13.6 标准I/O的机理  426
  • 13.7 其他标准I/O函数       427
  • 13.7.1 int ungetc(int c, FILE *fp)函数  427
  • 13.7.2 int fflush()函数  428
  • 13.7.3 int setvbuf()函数       428
  • 13.7.4 二进制I/O:fread()和fwrite()         428
  • 13.7.5 size_t fwrite()函数    429
  • 13.7.6 size_t fread()函数     430
  • 13.7.7 int feof(FILE *fp)和int ferror(FILE *fp)函数      430
  • 13.7.8 一个程序示例  430
  • 13.7.9 用二进制I/O进行随机访问   433
  • 13.8 关键概念      435
  • 13.9 本章小结      435
  • 13.10 复习题        435
  • 13.11 编程练习   437
  • 第14章 结构和其他数据形式   439
  • 14.1 示例问题:创建图书目录 439
  • 14.2 建立结构声明      441
  • 14.3 定义结构变量      441
  • 14.3.1 初始化结构       442
  • 14.3.2 访问结构成员  443
  • 14.3.3 结构的初始化器       443
  • 14.4 结构数组      444
  • 14.4.1 声明结构数组  446
  • 14.4.2 标识结构数组的成员       447
  • 14.4.3 程序讨论  447
  • 14.5 嵌套结构      448
  • 14.6 指向结构的指针 449
  • 14.6.1 声明和初始化结构指针  450
  • 14.6.2 用指针访问成员       451
  • 14.7 向函数传递结构的信息      451
  • 14.7.1 传递结构成员  451
  • 14.7.2 传递结构的地址       452
  • 14.7.3 传递结构  453
  • 14.7.4 其他结构特性  454
  • 14.7.5 结构和结构指针的选择  458
  • 14.7.6 结构中的字符数组和字符指针       458
  • 14.7.7 结构、指针和malloc()     459
  • 14.7.8 复合字面量和结构(C99)    462
  • 14.7.9 伸缩型数组成员(C99)         463
  • 14.7.10 匿名结构(C11)  465
  • 14.7.11 使用结构数组的函数    466
  • 14.8 把结构内容保存到文件中 467
  • 14.8.1 保存结构的程序示例       468
  • 14.8.2 程序要点  470
  • 14.9 链式结构      471
  • 14.10 联合简介   472
  • 14.10.1 使用联合         472
  • 14.10.2 匿名联合(C11)  473
  • 14.11 枚举类型   474
  • 14.11.1 enum常量       475
  • 14.11.2 默认值    475
  • 14.11.3 赋值         475
  • 14.11.4 enum的用法  476
  • 14.11.5 共享名称空间         477
  • 14.12 typedef简介       478
  • 14.13 其他复杂的声明        479
  • 14.14 函数和指针        481
  • 14.15 关键概念   487
  • 14.16 本章小结   487
  • 14.17 复习题        488
  • 14.18 编程练习   490
  • 第15章 位操作   493
  • 15.1 二进制数、位和字节 493
  • 15.1.1 二进制整数       494
  • 15.1.2 有符号整数       494
  • 15.1.3 二进制浮点数  495
  • 15.2 其他进制数 495
  • 15.2.1 八进制       495
  • 15.2.2 十六进制  496
  • 15.3 C按位运算符       496
  • 15.3.1 按位逻辑运算符       497
  • 15.3.2 用法:掩码       498
  • 15.3.3 用法:打开位(设置位)       498
  • 15.3.4 用法:关闭位(清空位)       499
  • 15.3.5 用法:切换位  499
  • 15.3.6 用法:检查位的值  500
  • 15.3.7 移位运算符       500
  • 15.3.8 编程示例  501
  • 15.3.9 另一个例子       503
  • 15.4 位字段 505
  • 15.4.1 位字段示例       506
  • 15.4.2 位字段和按位运算符       509
  • 15.5 对齐特性(C11)        515
  • 15.6 关键概念      516
  • 15.7 本章小结      516
  • 15.8 复习题 517
  • 15.9 编程练习      518
  • 第16章 C预处理器和C库        521
  • 16.1 翻译程序的第一步      521
  • 16.2 明示常量:#define      522
  • 16.2.1 记号  525
  • 16.2.2 重定义常量       525
  • 16.3 在#define中使用参数         525
  • 16.3.1 用宏参数创建字符串:#运算符    527
  • 16.3.2 预处理器黏合剂:##运算符  528
  • 16.3.3 变参宏:...和_ _VA_ARGS_ _  529
  • 16.4 宏和函数的选择 530
  • 16.5 文件包含:#include    531
  • 16.5.1 头文件示例       531
  • 16.5.2 使用头文件       533
  • 16.6 其他指令      534
  • 16.6.1 #undef指令       534
  • 16.6.2 从C预处理器角度看已定义  534
  • 16.6.3 条件编译  535
  • 16.6.4 预定义宏  539
  • 16.6.5 #line和#error   540
  • 16.6.6 #pragma    540
  • 16.6.7 泛型选择(C11)    541
  • 16.7 内联函数(C99)        542
  • 16.8 _Noreturn函数(C11)      544
  • 16.9 C库       544
  • 16.9.1 访问C库  544
  • 16.9.2 使用库描述       545
  • 16.10 数学库        546
  • 16.10.1 三角问题         547
  • 16.10.2 类型变体         548
  • 16.10.3 tgmath.h库(C99)      550
  • 16.11 通用工具库        550
  • 16.11.1 exit()和atexit()函数        550
  • 16.11.2 qsort()函数      552
  • 16.12 断言库        556
  • 16.12.1 assert的用法 556
  • 16.12.2 _Static_assert(C11)  557
  • 16.13 string.h库中的memcpy()和memmove() 558
  • 16.14 可变参数:stdarg.h 560
  • 16.15 关键概念   562
  • 16.16 本章小结   562
  • 16.17 复习题        562
  • 16.18 编程练习   563
  • 第17章 高级数据表示       567
  • 17.1 研究数据表示      567
  • 17.2 从数组到链表      570
  • 17.2.1 使用链表  572
  • 17.2.2 反思  576
  • 17.3 抽象数据类型(ADT)       576
  • 17.3.1 建立抽象  577
  • 17.3.2 建立接口  578
  • 17.3.3 使用接口  581
  • 17.3.4 实现接口  583
  • 17.4 队列ADT      589
  • 17.4.1 定义队列抽象数据类型  590
  • 17.4.2 定义一个接口  590
  • 17.4.3 实现接口数据表示  591
  • 17.4.4 测试队列  598
  • 17.5 用队列进行模拟 600
  • 17.6 链表和数组 605
  • 17.7 二叉查找树 608
  • 17.7.1 二叉树ADT       608
  • 17.7.2 二叉查找树接口       609
  • 17.7.3 二叉树的实现  611
  • 17.7.4 使用二叉树       624
  • 17.7.5 树的思想  628
  • 17.8 其他说明      629
  • 17.9 关键概念      630
  • 17.10 本章小结   630
  • 17.11 复习题        630
  • 17.12 编程练习   631
  • 附录A 复习题答案      633
  • 附录B 参考资料 665
  • B.1  参考资料I:补充阅读 665
  • B.2  参考资料II:C运算符 667
  • B.3  参考资料III:基本类型和存储类别   671
  • B.4  参考资料IV:表达式、语句和程序流       675
  • B.5  参考资料V:新增C99和C11的ANSI C库        679
  • B.6  参考资料VI:扩展的整数类型   714
  • B.7  参考资料VII:扩展字符支持      716
  • B.8  参考资料VIII:C99/C11数值计算增强      720
  • B.9  参考资料IX:C和C 的区别     726
展开阅读
  • C++Primer题解

    C++Primer题解

    c++primer题解 作者:ClovisL.Tondo译者:侯捷 华中理工大学 出版日期:2002年9月 作者CLOVISL.TONDO,TTTECHWORKS,INC.的总裁。这家公司提供C,C++,NUIX工具等技术训练,以其他公司为主要客户,并提供书稿给技术 出版。TONDO博士也是《THECAN-SWERBOOK》的作者,以及其他8本书籍的协同作者,写作范围涵盖C、驱动程序、MAKE、数据结构。

    大小:6.23 MBC++

作者CLOVIS L.TONDO,T&T TECH WORKS,INC. 的总裁。这家公司提供C,C++,NUIX工具等技术训练,以其他公司为主要客户,并提供书稿给技术 出版。TONDO博士也是《THE C AN-SWER BOOK》的作者,以及其他8本书籍的协同作者,写作范围涵盖C、驱动程序、MAKE、数据结构。

展开阅读
  • C++ Primer Plus(第6版)中文版习题解答

    C++ Primer Plus(第6版)中文版习题解答

    《C Primer Plus(第6版)中文版习题解答》是超级畅销书《C Primer Plus(第6版)中文版》的配套习题答案,针对书中的复习题和编程练习,给出了解题思路和答案。 《C Primer Plus(第6版)中文版习题解答》共分为18章,每一章的主题与《C Primer Plus(第6版)中文版》完全一致。每章开篇采用思维导图的方式列出本章的知识点,然后对每章的重点内容进行了梳理总结,*后则对每章中的复习题和编程练习进行了分析并给出了解答思路,确保读者在彻底夯实理论知

    大小:103 MBC++

《C Primer Plus(第6版)中文版习题解答》是超级畅销书《C Primer Plus(第6版)中文版》的配套习题答案,针对书中的复习题和编程练习,给出了解题思路和答案。 《C Primer Plus(第6版)中文版习题解答》共分为18章,每一章的主题与《C Primer Plus(第6版)中文版》完全一致。每章开篇采用思维导图的方式列出本章的知识点,然后对每章的重点内容进行了梳理总结,*后则对每章中的复习题和编程练习进行了分析并给出了解答思路,确保读者在彻底夯实理论知识的同时,进一步提升实际编程能力。 作为《C Primer Plus(第6版)中文版》的配套参考书,《C Primer Plus(第6版)中文版习题解答》特别适合需要系统学习C 语言的初学者阅读,也适合打算巩固C 语言知识或者希望进一步提高编程技术的程序员阅读。

1.畅销书《C Primer Plus(第6版)中文版》官方配套习题解答,C 编程的良好伴侣; 2.思维导图式解读C 各章知识点,对复习题和编程练习进行了详细的剖析,*后给出了解题思路和代码实现; 3.北师大名师讲解。 《C Primer Plus(第6版)》在之前版本的基础之上进行了全新升级,涵盖了C 语言的新进展以及C 11标准的详细内容。与之前的版本一样,其目标依然是为读者提供一本入门型、条理清晰、见解深刻的C 语言教程。 为了锻炼并提升读者的动手编程能力,《C Primer Plus(第6版)》除了在每章正文中包含了大量短小精悍的实例之外,还在每章末尾提供了颇有深度的综合性的复习题和编程练习题。本书编者对这些复习题和编程练习给出了自己的理解和解答。 本书每章开篇先采用思维导图的形式给出了本章涵盖的知识点,然后采用简练的文字梳理了每章涉及的理论内容,*后对复习题和编程练习进行了详细的剖析,*后给出了解题思路和代码实现。 作为《C Primer Plus(第6版)》的理想学习伴侣,本书可以切实提升C 语言初学人员的编程技能,掌握C 语言编程的精髓,为后期的程序开发之路打下坚实基础。

目录

  • 第 1章 预备知识 1
  • 1.1 C 语言的简介 1
  • 1.2 C 语言的编译过程 1
  • 第 2章 开始学习C  3
  • 2.1 C 程序的基本结构 3
  • 2.2 C 中的基本语句 4
  • 2.3 复习题 5
  • 2.4 编程练习 8
  • 第3章 处理数据 14
  • 3.1 C 语言中的变量及其使用 14
  • 3.2 C 语言中的整型数据 15
  • 3.3 C 语言中的字符类型 15
  • 3.4 C 语言中的浮点型数据 16
  • 3.5 C 语言中的常量和其他数据类型 16
  • 3.6 C 中的数据类型转换和基本运算 16
  • 3.7 复习题 17
  • 3.8 编程练习 21
  • 第4章 复合类型 28
  • 4.1 C 语言中的数组 28
  • 4.2 C 语言中的字符串 29
  • 4.3 C 语言中的结构体和结构体数组 29
  • 4.4 C 语言中的指针 30
  • 4.5 C 语言中的指针和数组 30
  • 4.6 复习题 31
  • 4.7 编程练习 35
  • 第5章 循环和关系表达式 45
  • 5.1 C 语言中的表达式 45
  • 5.2 while循环和do...while循环 46
  • 5.3 for循环 46
  • 5.4 二维数组和嵌套的循环 47
  • 5.5 标准输入/输出和循环 47
  • 5.6 复习题 47
  • 5.7 编程练习 50
  • 第6章 分支语句和逻辑运算符 59
  • 6.1 if条件语句 59
  • 6.2 if...else语句 60
  • 6.3 switch语句和break、continue 60
  • 6.4 复习题 61
  • 6.5 编程练习 65
  • 第7章 函数——C 的编程模块 80
  • 7.1 函数的原型和定义 80
  • 7.2 函数调用中的按值传递 81
  • 7.3 以数组和指针作为函数的参数 81
  • 7.4 字符串、二维数组和函数 82
  • 7.5 参数传递中的结构体 82
  • 7.6 递归函数与函数指针 82
  • 7.7 复习题 83
  • 7.8 编程练习 87
  • 第8章 函数探幽 103
  • 8.1 引用变量和引用参数 103
  • 8.2 函数的默认参数与重载 104
  • 8.3 函数模板 104
  • 8.4 函数的重载解析 105
  • 8.5 复习题 105
  • 8.6 编程练习 110
  • 第9章 内存模型和名称空间 121
  • 9.1 C 语言的多文件编译 121
  • 9.2 C 中的变量存储方式 122
  • 9.3 C 中的名称空间 122
  • 9.4 复习题 123
  • 9.5 编程练习 128
  • 第 10章 对象和类 138
  • 10.1 面向对象和类 138
  • 10.2 C 中类的访问控制 139
  • 10.3 构造函数和析构函数 139
  • 10.4 复习题 140
  • 10.5 编程练习 144
  • 第 11章 使用类 161
  • 11.1 类的友元函数 161
  • 11.2 运算符重载 162
  • 11.3 类的类型转换 163
  • 11.4 复习题 163
  • 11.5 编程练习 167
  • 第 12章 类和动态内存分配 194
  • 12.1 类中的静态数据成员和函数 194
  • 12.2 类中的动态存储形式 195
  • 12.3 类中成员函数的返回对象问题 195
  • 12.4 复习题 196
  • 12.5 编程练习 200
  • 第 13章 类继承 222
  • 13.1 C 中的继承 222
  • 13.2 继承中的多态性和虚函数 223
  • 13.3 静态联编和动态联编 224
  • 13.4 继承中的其他知识点 225
  • 13.5 复习题 225
  • 13.6 编程练习 229
  • 第 14章 C 中的代码重用 246
  • 14.1 类的继承和包含关系 246
  • 14.2 私有继承和受保护的继承 247
  • 14.3 多重继承 247
  • 14.4 对象的初始化问题 248
  • 14.5 类模板(模板类) 248
  • 14.6 复习题 249
  • 14.7 编程练习 253
  • 第 15章 友元、异常和其他 274
  • 15.1 友元类和类的嵌套 274
  • 15.2 异常与异常处理 275
  • 15.3 异常类和异常规范 276
  • 15.4 运行阶段类型识别 277
  • 15.5 复习题 277
  • 15.6 编程练习 280
  • 第 16章 string类和标准模板库 294
  • 16.1 C 中的string类 294
  • 16.2 智能指针模板类 295
  • 16.3 STL中的容器类 295
  • 16.4 STL中的迭代器和通用算法 296
  • 16.5 复习题 297
  • 16.6 编程练习 301
  • 第 17章 输入、输出和文件 317
  • 17.1 C 中的I/O流 317
  • 17.2 文件I/O 318
  • 17.3 复习题 319
  • 17.4 编程练习 323
  • 第 18章 探讨C 新标准 340
  • 18.1 移动语义和右值引用 340
  • 18.2 lambda函数和可变参数模板 341
  • 18.3 复习题 342
  • 18.4 编程练习 347
展开阅读
  • C++ Primer Plus(第6版)

    C++ Primer Plus(第6版)

    畅销20余年的C++编程入门教程 近百万程序员的C++编程启蒙教程 技术大牛案头常备的工具书 针对C++11标准库更新 蔡学镛 孟岩 高博倾力推荐

    大小:162.4 MBC++编程

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
展开阅读

相关教程

  • java可以写C语言编译器吗

    用java是可以写bai语言编译器的,用任何du语言工具写都可以。 各语言开发zhi工具间只有开发效率的差dao异,没有可行不可行的区别。 编译器其实就是一个翻译工具,它可以把代码直接翻译成二进制文件交给CPU执行(二进制指令就是CPU的指令集,当然可以直接操作内存),当然,这个二进制文件需要符合操作系统的可执行文件的格式(PE格式或ELF格式)才能执行。 1、编译器就是把c语言程序翻译为一种叫做目标文件的中间表示形式,然后交给汇编器,翻译

    阅读详情
  • c语言定义数组跟java一样吗

    java的数组其实是一个对象,因为其中不只是包含数据信息,还包括数组的长度等其他信息,一般现在只用到了长度信息,举个简单的例子,c语言中,int a[5],要用for循环来为每个数组元素赋值,只能for(i=0;i5;i++) scanf(%d,a[i]);而在java中,可以这样,int[] a=new int[5],for(i=0;ia.length;i++) system.out.println(a[i]); 1、首先,java中一切皆对象。当然包括数组了。 java在声明数组的时候不能加数量的.只

    阅读详情
  • java能编译成c语言吗

    用java是可以写语言编译器的,用任何语言工具都可以写。编译器就是一种把文本(源码)按语言语义的规则翻译成字节码的一套程序。 通常不像Java跨平台,确定目标平台是什么,比如是x86、ARMS、MIPS、JVM,操作系统环境是什么,然后编写输出生成所在环境下能运行的字节码。各语言开发工具间只有内开发效率的差异容,没有可行不可行的区别。 1、编译器其实就是一个翻译工具,它可以把代码直接翻译成二进制文件交给CPU执行(二进制指令就是CPU的指令集

    阅读详情
  • Java能写C语言编译器吗

    用java是可以写语言编译器的,用任何语言工具写都可以。各语言开发工具间只有开发效率的差异,没有可行不可行的区别。 编译器其实就是一个翻译工具,它可以把代码直接翻译成二进制文件交给CPU执行(二进制指令就是CPU的指令集,当然可以直接操作内存),当然,这个二进制文件需要符合操作系统的可执行文件的格式(PE格式或ELF格式)才能执行。 1、Java可以写C语言编译器,编译器就是一种把文本(源码)按语言语义的规则翻译成字节码的一套程序。

    阅读详情
  • 学java前需要学c语言吗

    虽然很多人都说C语言是基础,但是你也要相信学校开的课也是有它的原因的,首先C语言和Java完全是不同的两种语言,一种是面向过程编程的,一种是面对对象编程的,虽然说如果你前期学过C语言,对于Java的入门可能比较容易些,毕竟你接触过编程,一些变量,函数(Java中叫方法)等都有所理解,但是,即使你没学过,也是比较容易的,学没学过可能就是前期理解的快慢的区别,针对后期来说(学校的课程也到不了Java的后期,你要是感兴趣可以去深入一

    阅读详情
  • Java能写C语言编译器吗

    用java是可以写语言编译器的,用任何语言工具写都可以。各语言开发工具间只有开发效率的差异,没有可行不可行的区别。 编译器其实就是一个翻译工具,它可以把代码直接翻译成二进制文件交给CPU执行(二进制指令就是CPU的指令集,当然可以直接操作内存),当然,这个二进制文件需要符合操作系统的可执行文件的格式(PE格式或ELF格式)才能执行。 1、Java可以写C语言编译器,编译器就是一种把文本(源码)按语言语义的规则翻译成字节码的一套程序。

    阅读详情
  • java能代替C语言吗

    java不会代替C语言,C语言和Java语言都是目前IT领域内使用非常广泛的编程语言,C语言目前主要应用在嵌入式开发、操作系统开发和容器开发等领域,而Java语言则可以应用在Web开发、大数据开发、Android开发和各种服务端开发领域,可以说C语言和Java语言的应用场景还是有较为明显的区分的。从初学者的角度来看,C语言和Java语言都是不错的选择。 1、C语言目前仍在一些领域里坚挺,在操作系统、虚拟机和设备驱动程序开发方面,它可能是永远的王者。但是

    阅读详情
  • C语言程序中对二叉树数据结构的各种遍历方式

    这篇文章主要介绍了举例讲解C语言程序中对二叉树数据结构的各种遍历方式,先序中序后序二叉树遍历几乎成了最老生常谈的数据结构基础知识,的朋友可以参考下

    阅读详情