精华内容
下载资源
问答
  • c语言从入门到精通
    2020-12-24 11:47:44

    C语言从入门到精通(吐血分享)4

    成功!

    结构体、链表、文件

    数组、字符串

    函数、指针

    三种结构化程序设计

    三种数据类型、六大表达式

    一、简单的程序

    #include 数学函数 命令行

    main() /*主函数*/

    { /*左花括号,函数体的开始 */

    int a,b,c; /*定义语句*/

    a 3; /*执行语句*/

    b 4;

    c a+b;

    printf("a %d,b %d,c %d\n",a,b,c);

    } /*右花括号函数体结束*/

    二、vc++6.0使用

    1.新建

    2.编译

    3.组建

    4.运行

    三、 标识符、常量和变量

    1.标识符:

    1)用途:命名

    2)命名规则:a.字母、数字和下划线组成

    b.第一个必须是字母或下划线

    3)区分大小写

    4)分类:

    a.关键字:代表固定含义,不能另作它用

    b.预定义标识符:预先定义并具有特定含义的标识符

    库函数的名字 (printf) 和预编译处理命令

    (define)

    建议不另作它用

    c.用户标识符

    “见名知意”

    2.常量

    1)定义:程序运行过程中,其值不能被改变的量。

    2)分类:整型常量、实型常量、字符型常量和字符串常量

    3)符号常量

    #define M 5

    #define PI 3.14159

    s PI*r*r;

    3.变量

    1)定义:程序运行过程中,其值可以改变的量

    2)实质:一个变量实质上是代表了内存中的某个存储单元

    3)原则:变量先定义后使用

    四、三种基本数据类型

    1.整型数据

    1)整型常量

    二进制 八进制 十进制 十六进制

    十进制>二、八、十六进制 :除n求余

    二、八、十六进制>十进制 :按权展开

    八进制、十六进制 》二进制

    八进制转化二进制

    1:001 2:010 3:011 4:100 5:101 6:110

    7:111

    十六进制转化为二进制

    1:0001 2:0010 3:0011 4:0100 5:0101

    6:0110 7:0111 8:1000 9:1001 a:1010

    b:1011 c:1100 d:1101 e:1110 f:1111

    2)整型变量

    定义语句的格式

    类型名 变量名;

    整型分类 (有符号、无符号)

    signed unsigned

    表2.1

    <3>整型数据在内存中的存储

    1>最小存储单位:位

    2>1字节 (B) 8个二进制位

    3>在内存中,存储空间右端代表低端,左端代表高端

    4>最高位是符号位

    最高位存放1 》负整数

    最高位存放0 》正整数

    5>正整数:原码

    short a 5;

    0000 0000 0000 0101

    1:

    0000 0000 0000 0001

    在short整型中,最大的正整数

    0111 1111 1111 1111

    + 1

    更多相关内容
  • C语言从入门到精通

    2018-12-24 10:58:17
    C语言从入门到精通,学习C语言较好的一本书,好好学习吧。
  • C语言从入门到精通 (名师精华版)
  • C语言从入门到精通(第5版)PPT电子课件(可供参考).rar
  • 非常好的C语言学习指导书,讲解清晰明白,举例贴切,对问题阐述很清楚,实为一本好书
  • C语言经典编程282例的随书源码;值得收藏、备查与学习。
  • c语言从入门到精通PDF

    千次阅读 2021-05-20 14:39:55
    c语言从入门到精通PDF是一本用来学习c语言的非常实用的书。本书使用通俗的语言,丰富多彩的实例,各种各样的图片,详尽的介绍了C语言进行程序开发应该掌握的各方面知识。并且每个图例旁边都有着详细的注释,使读者...

    c语言从入门到精通PDF是一本用来学习c语言的非常实用的书。本书使用通俗的语言,丰富多彩的实例,各种各样的图片,详尽的介绍了C语言进行程序开发应该掌握的各方面知识。并且每个图例旁边都有着详细的注释,使读者更加轻松的领悟C语言程序开发想精髓,快速提高开发技能。本书十分适合初学者阅读,也适合作为开发人员查阅、参考资料。

    520acedddfd179d9eb2a08c0e63bb803.png

    c语言从入门到精通PDF目录:第1篇 基础知识

    第1章 C语言概述 3

    视频讲解:29分钟

    1.1 C语言发展史 4

    1.1.1 程序语言简述 4

    1.1.2 C 语言历史 4

    1.2 C语言的特点 5

    1.3 一个简单的C程序 6

    1.4 一个完整的C程序 8

    1.5 C语言程序的格式 12

    1.6 开发环境 13

    1.6.1 Turbo C 2.0 13

    1.6.2 Visual C++ 6.0 18

    1.7 小结 24

    第2章 算法 25

    视频讲解:22分钟

    2.1 算法的基本概念 26

    2.1.1 算法的特性 26

    2.1.2 算法的优劣 27

    2.2 算法的描述 27

    2.2.1 自然语言 28

    2.2.2 流程图 28

    2.2.3 N-S流程图 32

    2.3 小结 36

    第3章 数据类型 37

    视频讲解:39分钟

    3.1 编程规范 38

    3.2 关键字 39

    3.3 标识符 39

    3.4 数据类型 41

    3.5 常量 42

    3.5.1 整型常量 42

    3.5.2 实型常量 45

    3.5.3 字符型常量 46

    3.5.4 转义字符 49

    3.5.5 符号常量 49

    3.6 变量 50

    3.6.1 整型变量 50

    3.6.2 实型变量 53

    3.6.3 字符型变量 55

    3.7 变量的存储类别 57

    3.7.1 动态存储与静态存储 57

    3.7.2 auto变量 57

    3.7.3 static 变量 58

    3.7.4 register变量 59

    3.7.5 extern变量 60

    3.8 混合运算 61

    3.9 小结 62

    3.10 实践与练习 62

    第4章 运算符与表达式 63

    视频讲解:29分钟

    4.1 表达式 64

    4.2 赋值运算符与赋值表达式 66

    4.2.1 变量赋初值 66

    4.2.2 自动类型转换 68

    4.2.3 强制类型转换 68

    4.3 算术运算符与表达式 69

    4.3.1 算术运算符 70

    4.3.2 算术表达式 70

    4.3.3 优先级与结合性 71

    4.3.4 自增自减运算符 73

    4.4 关系运算符与表达式 75

    4.4.1 关系运算符 75

    4.4.2 关系表达式 76

    4.4.3 优先级与结合性 77

    4.5 逻辑运算符与表达式 78

    4.5.1 逻辑运算符 79

    4.5.2 逻辑表达式 79

    4.5.3 优先级与结合性 79

    4.6 位逻辑运算符与表达式 81

    4.6.1 位逻辑运算符 81

    4.6.2 位逻辑表达式 81

    4.7 逗号运算符与表达式 82

    4.8 复合赋值运算符 83

    4.9 小结 84

    4.10 实践与练习 85

    第5章 常用的数据输入、输出函数 87

    视频讲解:40分钟

    5.1 语句 88

    5.2 字符数据输入输出 88

    5.2.1 字符数据输出 88

    5.2.2 字符数据输入 89

    5.3 字符串输入输出 91

    5.3.1 字符串输出函数 91

    5.3.2 字符串输入函数 93

    5.4 格式输出函数 94

    5.5 格式输入函数 97

    5.6 顺序程序设计应用 100

    5.7 小结 102

    5.8 实践与练习 103

    第6章 选择结构程序设计 105

    视频讲解:44分钟

    6.1 if语句 106

    6.2 if语句的基本形式 106

    6.2.1 if语句形式 106

    6.2.2 if…else语句形式 109

    6.2.3 else if语句形式 113

    6.3 if的嵌套形式 117

    6.4 条件运算符 119

    6.5 switch 语句 121

    6.5.1 switch语句的基本形式 121

    6.5.2 多路开关模式的switch语句 125

    6.6 if else 语句和switch语句的区别 127

    6.7 选择结构程序应用 129

    6.8 小结 131

    6.9 实践与练习 131

    第 7章 循环控制 133

    视频讲解:41分钟

    7.1 循环语句 134

    7.2 while语句 134

    7.3 do- while语句 137

    7.4 for语句 139

    7.4.1 for语句使用 139

    7.4.2 for循环的变体 143

    7.4.3 for语句中的逗号应用 145

    7.5 3种循环语句的比较 146

    7.6 循环嵌套 147

    7.6.1 循环嵌套的结构 147

    7.6.2 循环嵌套实例 148

    7.7 转移语句 150

    7.7.1 goto语句 150

    7.7.2 break 语句 151

    7.7.3 continue语句 153

    7.8 小结 154

    7.9 实践与练习 154

    第2篇 核心技术

    第8章 数组 157

    视频讲解:1小时7分钟

    8.1 一维数组 158

    8.1.1 一维数组的定义和引用 158

    8.1.2 一维数组初始化 160

    8.1.3 一维数组应用 162

    8.2 二维数组 163

    8.2.1 二维数组的定义和引用 163

    8.2.2 二维数组初始化 165

    8.2.3 二维数组应用 168

    8.3 字符数组 169

    8.3.1 字符数组定义和引用 169

    8.3.2 字符数组初始化 170

    8.3.3 字符数组的结束标志 172

    8.3.4 字符数组的输入和输出 172

    8.3.5 字符数组应用 174

    8.4 多维数组 175

    8.5 数组的排序算法 175

    8.5.1 选择法排序 175

    8.5.2 冒泡法排序 177

    8.5.3 交换法排序 179

    8.5.4 插入法排序 181

    8.5.5 折半法排序 184

    8.5.6 排序算法的比较 186

    8.6 字符串处理函数 187

    8.6.1 字符串复制 187

    8.6.2 字符串连接 188

    8.6.3 字符串比较 190

    8.6.4 字符串大小写转换 192

    8.6.5 获得字符串长度 193

    8.7 数组应用 194

    8.7.1 反转输出字符串 194

    8.7.2 输出系统日期和时间 196

    8.7.3 字符串的加密和解密 198

    8.8 小结 199

    8.9 实践与练习 200

    第9章 函数 201

    视频讲解:55分钟

    9.1 函数概述 202

    9.2 函数的定义 204

    9.2.1 函数定义的形式 205

    9.2.2 定义与声明 206

    9.3 返回语句 208

    9.3.1 从函数返回 208

    9.3.2 返回值 209

    9.4 函数参数 211

    9.4.1 形式参数与实际参数 211

    9.4.2 数组作函数参数 213

    9.4.3 main 的参数 220

    9.5 函数的调用 220

    9.5.1 函数调用方式 221

    9.5.2 嵌套调用 223

    9.5.3 递归调用 226

    9.6 内部函数和外部函数 228

    9.6.1 内部函数 228

    9.6.2 外部函数 230

    9.7 局部变量和全局变量 231

    9.7.1 局部变量 231

    9.7.2 全局变量 234

    9.8 函数应用 236

    9.9 小结 242

    9.10 实践与练习 243

    第10章 指针 245

    视频讲解:1小时2分钟

    10.1 指针相关概念 246

    10.1.1 地址与指针 246

    10.1.2 变量与指针 247

    10.1.3 指针变量 247

    10.1.4 指针自加自减运算 251

    10.2 数组与指针 253

    10.2.1 一维数组与指针 253

    10.2.2 二维数组与指针 257

    10.2.3 字符串与指针 261

    10.2.4 字符串数组 263

    10.3 指向指针的指针 264

    10.4 指针变量做函数参数 268

    10.5 返回指针值的函数 277

    10.6 指针数组做main函数的参数 279

    10.7 小结 280

    10.8 实践与练习 281

    第3篇 高级应用

    第11章 结构体和共用体 285

    视频讲解:40分钟

    11.1 结构体 286

    11.1.1 结构体类型的概念 286

    11.1.2 结构体变量的定义 287

    11.1.3 结构体变量的引用 289

    11.1.4 结构体类型的初始化 292

    11.2 结构体数组 293

    11.2.1 定义结构体数组 293

    11.2.2 初始化结构体数组 295

    11.3 结构体指针 297

    11.3.1 指向结构体变量的指针 297

    11.3.2 指向结构体数组的指针 300

    11.3.3 结构体作为函数参数 302

    11.4 包含结构的结构 305

    11.5 链表 307

    11.5.1 链表概述 307

    11.5.2 创建动态链表 308

    11.5.3 输出链表 310

    11.6 链表相关操作 313

    11.6.1 链表的插入操作 313

    11.6.2 链表的删除操作 315

    11.7 共用体 319

    11.7.1 共用体的概念 319

    11.7.2 共用体变量的引用 320

    11.7.3 共用体变量的初始化 321

    11.7.4 共用体类型的数据特点 322

    11.8 枚举类型 322

    11.9 小结 324

    11.10 实践与练习 324

    第12章 位运算 325

    视频讲解:35分钟

    12.1 位与字节 326

    12.2 位运算操作符 326

    12.2.1 “与”运算符 326

    12.2.2 “或”运算符 328

    12.2.3 “取反”运算符 329

    12.2.4 “异或”运算符 330

    12.2.5 “左移”运算符 332

    12.2.6 “右移”运算符 334

    12.3 循环移位 335

    12.4 位段 338

    12.4.1 位段的概念与定义 338

    12.4.2 位段相关说明 339

    12.5 小结 341

    12.6 实践与练习 341

    第13章 预处理 343

    视频讲解:39分钟

    13.1 宏定义 344

    13.1.1 不带参数的宏定义 344

    13.1.2 带参数的宏定义 346

    13.2 #include指令 347

    13.3 条件编译 349

    13.3.1 #if命令 349

    13.3.2 #ifdef及#ifndef命令 352

    13.3.3 #undef命令 354

    13.3.4 #line命令 354

    13.3.5 #pragma命令 355

    13.4 小结 356

    13.5 实践与练习 356

    第14章 文件 357

    视频讲解:55分钟

    14.1 文件概述 358

    14.2 文件基本操作 358

    14.2.1 文件指针 358

    14.2.2 文件的打开 359

    14.2.3 文件的关闭 360

    14.3 文件的读写 360

    14.3.1 fputc函数 361

    14.3.2 fgetc函数 361

    14.3.3 fputs函数 362

    14.3.4 fgets函数 363

    14.3.5 fprintf函数 364

    14.3.6 fscanf函数 366

    14.3.7 fread函数和fwrite函数 367

    14.4 文件的定位 369

    14.4.1 fseek函数 369

    14.4.2 rewind函数 371

    14.4.3 ftell函数 372

    14.5 小结 375

    14.6 实践与练习 375

    第15章 存储管理 377

    视频讲解:22分钟

    15.1 内存组织方式 378

    15.1.1 内存组织方式 378

    15.1.2 堆与栈 378

    15.2 动态管理 381

    15.2.1 malloc 函数 381

    15.2.2 calloc函数 382

    15.2.3 realloc函数 383

    15.2.4 free函数 384

    15.3 内存丢失 385

    15.4 小结 386

    15.5 实践与练习 386

    第16章 网络套接字编程 387

    视频讲解:39分钟

    16.1 计算机网络基础 388

    16.1.1 IP地址 388

    16.1.2 OSI 七层参考模型 389

    16.1.3 地址解析 389

    16.1.4 域名系统 390

    16.1.5 TCP/IP协议 391

    16.1.6 端口 392

    16.1.7 套接字的引入 393

    16.1.8 网络字节顺序 393

    16.2 套接字概述 393

    16.2.1 套接字概述 393

    16.2.2 TCP的套接字的socket编程 394

    16.2.3 UDP 的套接字的socket编程 395

    16.3 套接字函数 395

    16.3.1 套接字函数介绍 395

    16.3.2 基于TCP的网络聊天程序 402

    16.4 小结 407

    16.5 实践与练习 408

    第4篇 项目实战

    第17 章 学生成绩管理系统 411

    视频讲解:40分钟

    17.1 需求分析 412

    17.2 系统设计 412

    17.3 功能设计 413

    17.3.1 功能选择界面 413

    17.3.2 录入学生成绩信息 415

    17.3.3 查询学生成绩信息 417

    17.3.4 删除学生成绩信息 418

    17.3.5 修改学生成绩信息 420

    17.3.6 插入学生成绩信息 421

    17.3.7 统计学生人数 423

    17.4 小结 424

    附 录 425

    db4f2a8321176aa695b5a946a4873e68.png

    下载地址

    请描述一下您遇到的错误,我们将用火箭般的速度修复

    软件无法下载

    下载后无法使用

    与描述不一致

    其他问题

    网友评论

    0条评论

    4d18d56e3c5d496323de8c5ac6000e1b.png评论需审核后才能显示

    展开全文
  • 我的第①本c语言编程书:C语言从入门到精通
  • C 语言从入门到精通 . . 学习编程没多少技巧 , 多动手 , 勤提问 , 实践出真知 ! 比如说书上举了个例子 , 那么我合上书做做看 , 会出问题吗 ?问题出在哪 , 为什么不能那么做 ? 除了书上的做法还有什么办法达到相同的...
  • C语言是一门面向过程的、抽象化的通用程序设计语言,广泛应用于底层开发。C语言能以简易的方式编译、处理低级存储器。C语言是仅产生少量的机器语言以及不需要任何运行环境支持便能运行的高效率程序设计语言。尽管...
  • C语言从入门到精通-扫描版,带书签
  • C语言学习很棒的资源,里面讲解非常详细, 例子丰富,深入浅出
  • C语言从入门到精通》高清扫描版,经典C语言教材,使用更方便!
  • c语言从入门到精通

    千次阅读 2021-03-27 13:14:10
    进入到c语言的世界 c语言,说白了就是沟通的桥梁,通过合适的语句,表达出想完成的动作 目的出发,写代码的目的是生成可以执行的a.out去完成相应的功能 如何生成可执行程序,包括如下步骤: 预处理 展开头文件/宏...

    这是微观的内存世界,规则而有序
    在这里插入图片描述
    这是以55pv210内部SRAM的内存分布为例的空间规划图
    在这里插入图片描述

    SVC Stack栈区
    Signature符号信息,文字常量区,如:常量字符串
    Global Variable全局变量
    Exception Vector Table异常向量表
    RW/ZI region Heap堆区
    variable size程序代码区

    1.首先,程序最开始执行的是汇编启动代码

    以ARM编程为例
    ARM汇编采用RISC架构,CPU本身不能直接读取内存,而是需要先将内存中的内容加载入CPU中通用寄存器中才能被CPU处理。
    在这里插入图片描述

    基本指令
    ldr内存内容加载入通用寄存器,链接时确定
    adr内存内容加载入通用寄存器,运行时确定
    str寄存器内容存入内存空间
    跳转指令
    .b直接跳转,不返回
    .bl跳转后返回,返回地址放入lr中,便于函数调用
    符号
    @用来做注释
    #放在行首做注释
    标号
    .当前指令的地址
    .word当前地址存放一个数值
    .global给后面添加外部链接属性
    .end标识文件结束
    .include头文件包含
    .arm/.code32声明arm指令

    其他的指令这里就不说了

    汇编初始化栈(满减栈),能使用c语言主要是需要栈

    系统在复位后默认是进入SVC模式的,再直接操作SP。

    #define SVC_STACK	0xd0037d80
    ldr sp, =SVC_STACK
    
    这句初始化了栈空间,从此以后可以使用c语言了
    
    

    2.进入到c语言的世界

    c语言,说白了就是沟通的桥梁,通过合适的语句,表达出想完成的动作

    从目的出发,写代码的目的是生成可以执行的a.out去完成相应的功能

    如何生成可执行程序,包括如下步骤:
    预处理展开头文件/宏替换/去掉注释/条件编译a.i,main.i
    编译检查语法,生成汇编,然后生成汇编a.o,main.o
    链接链接到一起生成可执行程序a.out
    预处理详情

    在这里插入图片描述

    ANSI C标准中几个标准预定义宏:(是双下划线)
    __LINE__:在源代码中插入当前源代码行号;
    __FILE__:在源文件中插入当前源文件名;
    __DATE__:在源文件中插入当前的编译日期
    __TIME__:在源文件中插入当前编译时间;
    __STDC__:当要求程序严格遵循ANSI C标准时该标识被赋值为1;
    __cplusplus:当编写C++程序时该标识符被定义。
    

    思考:可执行程序都可以帮助人们做些什么?

    简单来说,就是帮我们进行大量计算吧,但是数据的类型的多种多样的,如小数和整数就是有差异的

    所以就有了基本数据类型

    有符号整数类型
    类型名称字节数取值范围
    char1-2^7(-128) ~ 2^7-1(127)
    short2-2^15(-32 768) ~ 2^15-1(32 767)
    int4-2^31(-2 147 483 648) ~ 2^31-1(2 147 483 647)
    无符号整数类型
    类型名称字节数取值范围
    unsigned char10 ~ 2^8-1(255)
    unsigned short20 ~ 2^16-1(65 535)
    unsigned int40 ~ 2^32-1(4 294 967 295)
    浮点类型
    类型名称字节数取值范围
    float4-/+3.4e38(精确到6位小数)
    double8-/+1.7e308(精确到15位小数)
    构造类型
    类型名称关键字
    结构体类型struct
    枚举类型enum
    联合类型union
    还包括 指针类型和空类型,后面会说

    ######################################################################################

    有了数据类型后就可以定义变量了

    定义变量的格式非常简单,如下所示:

    数据类型  变量名;
    int a = 0;
    

    定义变量也要遵循命名规则

    在定义变量时,变量名可以是字母、数字和下划线的组合。但是也不是随便的组合,要注意以下几个命名规则:

    变量名的开头必须是字母或下划线,不能是数字
    变量名中的字母是区分大小写的
    变量名绝对不可以是C语言关键字
    变量名中不能有空格

    对于基本数据类型量,按其值是否可变 分为常量和变量两种。

    常量的类型

    在程序执行过程中,其值不发生改变的量称为常量,其值可变的量称为变量。它们可与数据类型结合起来分类
    例如,可分为整型常量、整型变量、浮点常量、浮点变量、字符常量、字符变量
    
    常量说明
    直接常量可以立即拿来用,无需任何说明的量 12,4.6,‘a’
    符号常量可以用一个标识符来表示一个常量,称之为符号常量。#define 标识符 常量
    const常量有时候我们希望定义这样一种变量,它的值不能被改变,const int MaxNum = 100;
    枚举常量除去定义操作之外,任何地方在使用枚举常量时,都不能对其进行赋值操作了,它就相当于一个固定数值了,不能再变。

    上面提到了const, 这里说一下关键字:const的具体作用

    C语言中const的用法
    1.const修饰的变量是只读的,本质还是变量。
    2.const修饰的局部变量是在栈上
    3.修饰指针
    
    C++const的用法:
    1.C++ 中的 const 是一个真正意义上的常量
    2.编译器默认不为const变量分配内存,除非出现以下情况:
    	1.const常量为全局,并且需要在其它文件中使用,会分配存储空间
    	2.当使用&操作符,取const常量的地址时,会分配存储空间
    	3.const int &a = 10; const修饰引用时,也会分配存储空间
    
    
    

    上面提到了枚举常量, 这里说一下关键字:enum的具体作用

    在程序中,可能需要为某些整数定义一个别名
    我们可以利用预处理指令 #define 来完成这项工作
    #define MON  1
    #define TUE   2
    #define WED  3
    #define THU   4
    #define FRI    5
    #define SAT   6
    #define SUN   7
    在此,我们定义一种新的数据类型
    希望它能完成同样的工作。这种新的数据类型叫枚举型
    typedef enum 
    {
         MON=1, TUE, WED, THU, FRI, SAT, SUN
    }DAY;
    1. 枚举型是一个集合,集合中的元素(枚举成员)是一些命名的整型常量,元素之间用逗号,隔开。
    2. DAY是一个标识符,可以看成这个集合的名字,是一个可选项,即是可有可无的项。
    3. 第一个枚举成员的默认值为整型的0,后续枚举成员的值在前一个成员上加1。
    4. 可以人为设定枚举成员的值,从而自定义某个范围内的整数。
    5. 枚举型是预处理指令#define的替代,这句话的很有深意,可以直接枚举变量,不需要名字,因为是预编译
    6. 类型定义以分号;结束。
    
    用typedef关键字将枚举类型定义成别名,并利用该别名进行变量声明:
    

    我知道了,变量可以通过宏定义变为常量,可以通过枚举定义多个常量,但是可不可以把函数函数变为宏定义呢

    我们看下面两段代码

    typedef struct
    {
        uint16_t ecd;
        int16_t speed_rpm;
        int16_t given_current;
        uint8_t temperate;
        int16_t last_ecd;
    } motor_measure_t;
    
    uint8_t rx_data[8];
    
    static motor_measure_t motor_chassis[7];
    
    get_motor_measure(&motor_chassis[i], rx_data);
    

    可以肯定下面两段代码不会影响结果,不过写法不同,对程序运行时间的开销不同

    在这里插入图片描述
    在这里插入图片描述

    说明:在带形参的宏定义中,形式参数不分配内存单元,因此不必作类型定义。而宏调用中的实参有具体的值。要用它去替换(不是传值调用)形参(可以理解为标识符)。因此,做出初步理论,这是完全的替换,需要注意传进去的参数格式,优先级需要考虑,不能影响之后运行结果

    正常调用函数时首先要在栈中为形参和局部变量分配存储空间,然后还要将实参的值复制给形参,接下来还要将函数的返回地址(该地址指明了函数执行结束后,程序应该回到哪里继续执行)放入栈中,最后才跳转到函数内部执行。这个过程是要耗费时间的。
    使用带参宏定义时代码就像代码段,重复调用代码段,付出让代码体积增加的代价,来让运行速度提高

    这两段代码虽然完成了相同的功能,不过,使用函数的define写法,会让人看着不舒服,这里出现了一个新的关键字 “inline”

    内联函数 inline用法解析

    从问题出发

    同样是调用函数,主要问题是栈空间有限,如果栈频繁的使用就会造成因栈空间不足所造成的程序出错问题。
    #define 的虽然是一个办法,不过还有更美观的写法,所以可以使用inline关键字修饰,减少了#define代码写法上所带来的代码量
    

    其实很简单,只需要把函数前面加一个inline即可,如下图所示
    在这里插入图片描述

    注意:inline是一种“用于实现的关键字”,而不是一种“用于声明的关键字”,所以关键字 inline 必须与函数定义体放在一起,而不是和声明放在一起

    变量的类型,这里的静态类型使用到了存储说明符static

    解释一下static的作用

    c语言
     1. c语言中static修饰函数/变量:所有未加static前缀的全局变量和函数都具有全局可见性,其它的源文件也能访问;
     2. static修饰函数和变量时,变量和函数就变成了内部链接,外部不可见,(作用域只在本文件)其他源文件不能访问
     3. c语言中static修饰局部变量:变量没有初始化的话,自动初始化为0
     4. c语言中static修饰全局变量:他与全局变量的区别在于全局变量作用域是全局(所有文件只能定义一个)
     而static修饰的在不同的文件中可以定义相同的名称,因为static作用域在本文件中 
     所以不同文件中的变量名虽然一样 但是他是不同的变量
     
     c++多出来的规则
     c++中static作用兼容修饰c语言的作用最重要的只有一种作用,
     就是static修饰的静态成员是属于这个类,所有对象共享这个静态成员
     
    
    变量位置
    全局变量Global varibal(静态区)
    静态全局变量Global varibal(静态区)
    局部变量栈区
    静态局部变量Global varibal(静态区)

    既然提到了存储说明符,这里将四种存储说明符都说明一下吧

    autoauto被解释为一个自动存储变量的关键字,也就是申明一块临时的变量内存。
    register将变量存在CPU内部寄存器中而不是通过内存寻址访问以提高效率。
    externextern可以置于变量或者函数前,以标示变量或者函数的定义在别的文件中,提示编译器遇到此变量和函数时在其他模块中寻找其定义。

    有了数据类型,定义了变量,我们就可以进行一些简单的操作了,最基础的就是对-> 变量本身 ->进行操作,最基本的是 进制转换

    什么是进制?

    答:逢n进1
    

    计算机是由无数个0和无数个1组成
    我们先由二进制转换

    二进制转八进制方法: 取三合一法,即从二进制的小数点为分界点,向左(或向右)每三位取成一位
    二进制:1010 0100B
    八进制:010 100 100
    		2	4	 4
    最后的结果为244
    
    二进制转十进制方法
    135D = 128D + 7D = 1000 0111B
    去比对最大的数与那个数最接近,该位置1,用余数继续对比,直到为0
    
    11111111二进制
    1286432168421十进制
    二进制转十六进制:取四合一法,即从二进制的小数点为分界点,向左(或向右)每四位取成一位。
    二进制:		1010 0100B
    十六进制:	1010 0100
    			  a    4
    最后结果为a4
    

    变量之间的运算 操作符

    若想进行变量之间的运算,必须要学会操作符

    算术运算符

    +
    -
    *
    /
    %取余

    这里我想到一个问题,如果两个数相加,超过了类型的最大值或是最小值会怎么样?
    猜想:两个情况,1.还为最大值不在加,2.从最小值重新加载
    代码测试

    #include <stdio.h>
    #include <string.h>
    
    int main(void)
    {
    
    	unsigned char a = 255;
    	printf("a = %d.\n", a++);
    	printf("a = %d.\n", a++);
    	printf("a = %d.\n", a++);
    	return 0;
    }
    

    在这里插入图片描述
    猜想二为实践结果
    但是–没有测试呢还是测试一下吧

    #include <stdio.h>
    #include <string.h>
    
    int main(void)
    {
    
    	unsigned char a = 1;
    	printf("a = %d.\n", a--);
    	printf("a = %d.\n", a--);
    	printf("a = %d.\n", a--);
    	return 0;
    }
    

    在这里插入图片描述
    效果相同,大胆猜测,小心求证!

    移位操作符

    <<左移
    >>右移

    位操作符

    & :按位与
    | :按位或
    ^ : 按位异或
    

    这里说一下笔试总会考一些 位操作符在操作寄存器时的特殊作用

    清零用&,置1| ,取反用^
    一般的定义是复位使输出从1回到0;置位使输出从0变为1。
    定义一个unsigned int a;
    将特定位置位:
    	a |=  (0x1<<x)
    将特定位复位:
    	a &= ~(0x1<<x)
    或者将特定位x~y置位
    	a |=   (0x(y-x)1<<x)
    或者将特定位x~y复位
    	a &= (~(0x(y-x)1<<x))
    一般就考这些,其余的也可以通过这些推出来
    

    赋值操作符=

    复合运算符+=,-=,*=,/=,%=,>>=,<<=,&=,|=,^=

    单目操作符=

    逻辑反操作
    -负值
    +正值
    &取地址
    sizeof返回变量或常量、数据类型占用的内存字节数,sizeof(变量/常量) sizeof(数据类型)
    ~对一个数的二进制按位取反
    - -
    ++
    *解引用操作符

    关系运算符>、<、>=、<=、==、!=

    逻辑运算符

    && :两边都必须成立,一边不成立,忽略另一边
    || :两边只要有一边成立,忽略另一边
    ! : 真为假,假为真
    

    三目运算符

    //一般笔试会出一些宏定义比大小,如下图
    #define max(a,b) ((a) > (b) ? (a) : (b))
    #define maxint(a,b) \
    ({int _a = (a), _b = (b); _a > _b ? _a : _b; })
    

    这里会了操作符就要考虑一个问题,这么多操作符,要考虑符号的优先级

    下图为c语言优先级表
    在这里插入图片描述

    至此可以让c语言发挥作用了,跑在板子上可以进行简单的计算了。

    前面说我们可以定义一个数据类型的变量,如果你要定义100个呢,虽然是可以通过数据类型 变量名的方式,不过是不是效率太低了呢

    c语言的发明者也想到了这个问题,于是就创建了数组的概念

    数组就是一些列具有相同类型的数据的集合
    这些数据在内存中依次挨着存放,彼此之间没有缝隙。
    

    一维数组的定义方式

    int a[10];  /* 说明整型数组a,有10个元素 */
    float b[10], c[20];  /* 说明实型数组b,有10个元素,实型数组c,有20个元素 */
    char ch[20];  /* 说明字符数组ch,有20个元素 */
    
    1. 对于同一个数组,其所有元素的数据类型都是相同的。
    2. 数组名的书写规则应符合标识符的书写规定。
    3. 数组名不能与其它变量名相同
    4. 方括号中常量表达式表示数组元素的个数
    5. 不能在方括号中用变量来表示元素的个数,但是可以是符号常数或常量表达式
    6. 允许在同一个类型说明中,说明多个数组和多个变量
    

    一维数组元素的引用

    数组元素也是一种变量, 其标识方法为数组名后跟一个下标。
    组中的顺序号。数组元素的一般形式为:
        数组名[下标]
    其中下标只能为整型常量或整型表达式。如为小数时,C编译将自动取整。例如:
        a[5]
        a[i+j]
        a[i++]
    都是合法的数组元素。
    
    或是使用指针访问地址,这个后面说
    
    
    一维数组的初始化
    1.可以只给部分元素赋初值。当{ }中值的个数少于元素个数时,只给前面部分元素赋值
    int a[10]={0,1,2,3,4};
    表示只给a[0]~a[4]5个元素赋值,而后5个元素自动赋0值。
    
    2.只能给元素逐个赋值,不能给数组整体赋值。例如给十个元素全部赋1值,只能写为:
    int a[10]={1,1,1,1,1,1,1,1,1,1};
    而不能写为:
    int a[10]=1;
    3.如给全部元素赋值,则在数组说明中,可以不给出数组元素的个数。
    int a[5]={1,2,3,4,5};
    可写为:
    int a[]={1,2,3,4,5};
    

    二维数组在后面用到了会说

    到这里简单的类型已经说明完毕

    到这里我会想到很多数组的问题

    1. 数组的大小在定义时就要确认,定义后不可以动态改变 
    2. 数组的类型只能是相同类型,不同类型的数据怎么被多次定义
    3. 数组占有的内存太大,怎么样能节约内存
    

    继续研究c语言

    结构体的引入

    第二个问题:数组的成员类型只能是相同类型,为了解决这个问题,c语言创造者创造了结构体的概念
    结构体内的成员可以为不同类型,仔细想想,也是可以实现的,数据类型保存在内存地址中
    和多次定义把不同类型的变量没有本质差别,所以不同类型数据挨着存放
    也是没有问题的,看文章最开始的图。
    
    intcharfloat 等基本类型组成的。你可以认为结构体是一种聚合类型。
    

    这里出现了C++ 类的概念

    结构体的定义如下所示,struct为结构体关键字
    stu为结构体的类型标志
    member为结构体成员列表,其必须列出其所有成员;
    variable_t为此结构体声明的变量
    
    定义的同时用typedef定义结构体类型
    typedef struct stu {
    // member
     	int a;
     	char b;
     	short c;
     }variable_t; 
    
    同时用typedef定义为一个类型
    

    定义结构体变量

    两种情况
    
    未使用typedef,定义结构体struct variable_t a,b,c;
    使用typedef,定义结构体variable_t a,b,c;

    结构体的大小与内存对齐

    结构体的大小不是结构体元素单纯相加就行的,因为我们主流的计算机使用的都是32bit字长的CPU
    对这类型的CPU取4个字节的数要比取一个字节要高效,也更方便。
    所以在结构体中每个成员的首地址都是4的整数倍的话,取数据元素时就会相对更高效
    这就是内存对齐的由来。可以通过预编译命令
    #pragma pack(n),n=1,2,4,8,16来改变这一系数,其中的n就是你要指定的“对齐系数”。
    
    原则一:结构体中元素是按照定义顺序一个一个放到内存中去的,但并不是紧密排列的。
    从结构体存储的首地址开始,每一个元素放置到内存中时,它都会认为内存是以它自己的大小来划分的,
    因此元素放置的位置一定会在自己宽度的整数倍上开始(以结构体变量首地址为0计算)
    
    原则二:在经过第一原则分析后,检查计算出的存储单元是否为所有元素中最宽的元素的长度的整数倍,
    是,则结束;若不是,则补齐为它的整数倍。
    
    

    在这里插入图片描述
    在这里插入图片描述

    链表的引用

    第一个问题:为了使数组的大小可以随意伸缩,c语言创造者创造了 链表,将数据类型封装成一个铁链,当需要增加大小时,铁链就会两两相扣,动态的增加内存

    动态申请内存的存放位置在堆区
    
    具体实现方法如下(单链表)
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct node //一节铁链
    {
    	int data;
    	struct node *pNext;
    };
    
    struct node * create_node(int data) //创造节点
    {
    	struct node *p = (struct node *) malloc (sizeof(struct node));
    	bzero(p,sizeof(struct node));
    	p->data = data;
    	p->pNext = NULL;
    	return p;
    }
    
    void tail_node(struct node * pHeader,struct node *pnew) //尾插
    {
    	while(NULL != pHeader->pNext)
    	{
    		pHeader=pHeader->pNext;
    	}
    	pHeader->pNext=pnew;
    	
    } 
    
    void header_node(struct node * pHeader,struct node *pnew) //头插
    {
    	pnew->pNext = pHeader->pNext;
    	pHeader->pNext = pnew;
    }
    
    void sphere(struct node * pHeader) //打印
    {
    	while(NULL != pHeader->pNext)
    	{
    		pHeader = pHeader->pNext;
    		printf("%d\n",pHeader->data);
    	}
    }
    int main(void)
    {
    	struct node *pHeader = create_node(0);
    	tail_node(pHeader,create_node(1));
    	header_node(pHeader,create_node(2));
    	sphere(pHeader)}
    

    共用体的引入

    第三个问题:结构体和共用体的区别在于:
    1. 结构体的各个成员会占用不同的内存,互相之间没有影响;而共用体的所有成员占用同一段内存修改一个成员会影响其余所有成员。
    2. 结构体占用的内存大于等于所有成员占用的内存的总和,共用体占用的内存等于最长的成员占用的内存。共用体使用了内存覆盖技术
    同一时刻只能保存一个成员的值,如果对新的成员赋值,就会把原来成员的值覆盖掉。
    
    union data{
         int n;
        char ch;
        short m;
    };
    union data a,;
    

    共用体成员之间会相互影响,修改一个成员的值会影响其他成员,看下图

    在这里插入图片描述

    至此 数据类型基本掌握

    我们由文章第一个内存空间图可知,数据是保存在内存中的,我们可不可以进行访问地址的方式获得数据呢

    简单来说,找到一个地址,获取对应数据

    想法是可行的,内存是规则摆放的,每一比特空间都有特定的地址,无法修改,若内部存入了数据,我们是可以获取地址对应数据的

    指针的引入

    这也是c语言中最核心的部分

    一切都是地址

    所谓指针,也就是内存的地址;所谓指针变量,也就是保存了内存地址的变量。
    

    定义指针变量与定义普通变量非常类似,不过要在变量名前面加星号*,格式为:

    datatype *name;
    datatype *name = value;//value为地址
    

    *表示这是一个指针变量,datatype表示所指向的数据类型(就是这个指针会按照我们定义的这个datatype去解析地址的数据,而不是地址所存的数据类型,不过这个可能报错,需要强制类型转换)

    指针变量也是变量,也是需要给指针变量分配内存的,位置看指针变量定义的位置
    指针变量存放的不是数据,是地址,指针所指向的地址。
    

    关于 *&

    * : 解引用
    & : 取地址
    

    指针变量与普通变量

    int a;
    int *p=&a;
    *p++或p++
    都是加的地址变量,也就是p,因为变量为p。
    所在的字节数为指针变量类型
    这里我们是int *p的int
    所以为4个字节
    

    数组名与数组名取地址的差异

    定义一个整形数组array[10],其中array、&array在不同的情况下代表的地址是不同的。
    
    一般情况下arr代表的是数组首元素的地址,而&arr代表的则是数组的地址。 虽然数组首元素地址与数组地址的内存地址
    相同,但是他们代表的含义却不同,所以对他们进行运算时,所得结果也不同。
    
    array或array[0]数组首元素首地址
    &array整个数组的地址

    sizeof计算数组的差异

    sizeof(&array)4个字节
    sizeof(array)40个字节

    有一个函数与sizeof很像,strlen函数,在头文件#include <string.h>

    关于 strlen 与 sizeof 的区别:
    
    strlen 是函数,sizeof 是运算符。
    strlen 测量的是字符的实际长度,以’\0’ 结束(不包含’\0’ )
    sizeof 测量的是字符的分配大小,如果未分配大小,则遇到’\0’ 结束,如果已经分配内存大小,返回的就是分配的内存大小

    下面代码演示

    char str[] = "Hello World"; //等效在字符最后添加一个'\0'
    char str2[] = {'h', 'e', 'l', 'l', 'o'}; //若这么定义,不在最后添加'\0',则会出错
    char str1[100] = "Hello World";
     
    cout << strlen(str) << endl;  //11
    cout << sizeof(str) << endl;  //12
    cout << sizeof(str1) << endl; //100
    

    指针数组与数组指针

    说明表达式
    指针数组的实质是一个数组,数组中存贮的内容全部都是指针变量int *p[5]
    数组指针的实质是一个指针,指针指向这个数组int(*p)[5]
    ==辨别方法是符号优先级==
    

    结构体指针

    取出结构体指针每个成员的方法

    很多时候用 点运算符(.) 与 箭头运算符(->) 不知道具体差异是什么

    相同点: 右值都是成员名称
    

    不同点

    ..左边是结构体名 或者 (*结构体指针变量)
    ->->左边是指向结构体的指针(结构体指针变量),指针变量就可以指向结构体变量的任意成员

    指针与指针所指向的数据类型完成间接寻址

    整型指针int a;int *p;p=&a;
    数组指针int a[5];int (*p)[5];p=&a;
    函数指针int a(int);int (*p)(int);p=(&)a;

    这三个的共同点是p都是a的首地址。下面是三组类型,类型对应相同,数据的读出与写入按照相同的类型,可以进行间接访问,类型相同是为了与之前的 输入值、返回值 格式对应,才可以进行指针操作

    typedef结合函数指针的用法

    除了基本数据类型,其他的都是用户自定义类型,但是自定义类型有时候太长了,比如函数指针类型
    char* (*pFunc)(char *dest,const char *src)当我们多次使用时就很麻烦,可以用typedef重命名 类型 一个短一点的名字,只是类型的搬运工。例如:

    typedef char* (*pType)(char *,const char *);
    这句话重命名一种类型,新类型也需要用名字,类型的名字叫pType,类型为把名字去掉剩下的
    

    类型:typedef char* (*)(char *,const char *);

    原始方法用重命名类型定义指针变量’p’, 需要把类型写出来,再把指针变量写到类型名字的地方,很麻烦!!
    char* (*p)(char *,const char *);

    简单方法 直接 新类型名 变量名 这么定义。

    typedef char* (*pType)(char *,const char *);
    pType p;
    pType存的是函数地址,
    

    效果是一样的,分析方法,看到重命名类型,直接想到就是个复杂一点的类型而已,用类型名就可以调用,变量名的类型是重命名的类型,也就是上面的类型。

    二重指针指向指针数组解析

    typedef int (init_fnc_t) (void);//定义函数类型
    
    init_fnc_t **init_fnc_ptr;      //二重函数指针
    
    init_fnc_t *init_sequence[] = { //函数指针数组
    	cpu_init,		/* basic cpu dependent setup */
    	board_init,		/* basic board dependent setup */
    	interrupt_init,		/* set up exceptions */
    	env_init,		/* initialize environment */
    	init_baudrate,		/* initialze baudrate settings */
    	serial_init,		/* serial communications setup */
    	console_init_f,		/* stage 1 init of console */
    	display_banner,		/* say that we are here */
    	NULL,
    };
    
    for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
    		if ((*init_fnc_ptr)() != 0) {
    			error 0}
    	}
    
    重点是for循环部分,通过等式将二重指针与函数指针数组取得联系
    
    init_fnc_ptr = init_sequence
    init_fnc_ptr获得 (函数指针) 数组首元素的首地址,通过指向首地址解引用*init_fnc_ptr获得函数地址;
    
    因为数组中的元素的 类型是 int * 类型,也就是指针类型,所以数组存的数据可以看成是强制转化成地址。
    而二重指针的 *init_fnc_ptr 的类型也是 int * 类型,类型相同,通过函数地址直接调用函数
    

    变量、数组、函数的地址

    变量地址数组地址函数地址
    &aa或&a[0]函数名或&函数名

    C程序的执行部分是由语句组成的。程序的功能也是由执行语句实现的。

    到这里开始学习控制语句

    条件判断语句if语句、switch语句;
    循环执行语句do while语句、while语句、for语句;
    转向语句break语句、goto语句、continue语句、return语句。

    条件判断语句

    if(表达式)//表达式为真是1,表达式为假是0;
    	语句1//若只有一句,可以这样写,不需要加{};
    else if
    	语句2else
    	语句n;
    
    //switch语句
    switch (i){
            case 1:printf("1\n"); 	 break;
            case 2:printf("2\n"); 	 break;
            case 3:printf("3\n");	 break;
            case 4:printf("4\n"); 	 break;
            case 5:printf("5\n");  	 break;
            case 6:printf("6\n"); 	 break;
            case 7:printf("7\n");  	 break;
            default:printf("error\n");
    }
    case语句之后增加break语句, 使每一次执行之后均可跳出switch语句,从而避免输出不应有的结果。
    

    循环执行语句

    //do while循环
    //do…while 循环不经常使用,其主要用于人机交互。它的格式是:
    do
    {
        语句;
    }
    while (表达式);
    
    dowhile(表达式)while(表达式) 的执行过程非常相似,唯一的区别是:“dowhile(表达式) 是先执行一次循环体,然后再判别表达式”。
    当表达式为“真”时,返回重新执行循环体,如此反复,直到表达式为“假”为止,此时循环结束
    
    while(表达式)dowhile(表达式) 是否等价?
    
    答案是“不能”。原因十分简单,while(表达式) 循环体内部不一定会执行,当表达式一开始就为假的时候它就不会执行。
    但 dowhile(表达式) 不管表达式开始为真还是为假,循环体内部都会先执行一次。
    

    for循环

    //for 循环的一般形式为:
    for(表达式1; 表达式2; 表达式3){
        语句块
    }
    它的运行过程为:
    
    1. 先执行“表达式1”。
    2. 再执行“表达式2”,如果它的值为真(非0),则执行循环体,为假(为0)结束循环。
    3. 执行完循环体后再执行“表达式3”。
    4. 重复执行步骤 23,直到“表达式2”的值为假,就结束循环。
    上面的步骤中,23 是一次循环,会重复执行,for 语句的主要作用就是不断执行步骤 23

    转向语句

    跳出循环

    使用while或for循环时,如果想提前结束循环(在不满足结束条件的情况下结束循环),可以使用break或continue关键字。

    return 语句是提前结束函数的唯一办法。

    int test(void)
    {
     while(1){  // 外层循环
            while(1){  // 内层循环
                if()
                 continue;//跳过当次循环,进入下次循环
                 break;  //跳出内层循环 
                 return;  //结束函数test
            }
            if()
             continue;//跳过当次循环,进入下次循环
             break;  // 跳出外层循环
             return;  //结束函数test
    	}
    	return;  //结束函数test
    }
    break 关键字用于 whilefor 循环时,会终止循环而执行整个循环语句后面的代码。
    break 关键字通常和 if 语句一起使用,即满足条件时便 ==跳出循环==continue 语句的作用是跳过循环体中剩余的语句而强制进入 ==下一次循环==continue语句只用在 whilefor 循环中,常与 if 条件语句一起使用,判断条件是否成立。
    
    return 表达式;
    return (表达式);
    有没有( )都是正确的,为了简明,一般也不写( )
    
    

    goto语句

    goto 语句是一种无条件流程跳转语句,通常 goto 语句与 if 语句结合使用,
    当满足一定条件时,程序流程跳转到指定标号处,接着往下执行。
    
    语句标识:语句;
    
    #include<stdio.h>
    int main (void){
        pos:
            if(1)
            {
        	    printf ("hello world\n");  //一直打印这句
                goto pos;
            }
        return 0;
    }
    

    volatile关键字

    volatile修饰的变量可能被意想不到的改变,
    每次读取都会从内存中重新读取,
    而不是使用保存在寄存器里的备份
    
    展开全文
  • C语言从入门到精通(第4版)

    千次阅读 2020-12-24 11:47:45
    封面页书名页版权页内容简介如何使用本书开发资源库前言 ...面试资源库目录第1篇 基础知识第1章 C语言概述1.1 C语言的发展史1.1.1 程序语言简述1.1.2 C语言的历史1.2 C语言的特点1.3 一个简单的C程序1.4...

    封面页

    书名页

    版权页

    内容简介

    如何使用本书开发资源库

    前言 Preface

    本书内容

    本书特点

    读者对象

    读者服务

    致读者

    资源包“开发资源库”目录

    第1大部分 实例资源库

    第2大部分 模块资源库

    第3大部分 项目资源库

    第4大部分 能力测试题库

    第5大部分 面试资源库

    目录

    第1篇 基础知识

    第1章 C语言概述

    1.1 C语言的发展史

    1.1.1 程序语言简述

    1.1.2 C语言的历史

    1.2 C语言的特点

    1.3 一个简单的C程序

    1.4 一个完整的C程序

    1.5 C语言程序的格式

    1.6 开发环境

    1.6.1 Visual C++ 6.0

    1.6.2 Visual Studio 2017

    1.7 小结

    第2章 算法

    2.1 算法的基本概念

    2.1.1 算法的特性

    2.1.2 算法的优劣

    2.2 算法的描述

    2.2.1 自然语言

    2.2.2 流程图

    2.2.3 N-S流程图

    2.3 小结

    第3章 数据类型

    3.1 编程规范

    3.2 关键字

    3.3 标识符

    3.4 数据类型

    3.5 常量

    3.5.1 整型常量

    3.5.2 实型常量

    3.5.3 字符型常量

    3.5.4 转义字符

    3.5.5 符号常量

    3.6 变量

    3.6.1 整型变量

    3.6.2 实型变量

    3.6.3 字符型变量

    3.7 变量的存储类别

    3.7.1 静态存储与动态存储

    3.7.2 auto变量

    3.7.3 static变量

    3.7.4 register变量

    3.7.5 extern变量

    3.8 混合运算

    3.9 小结

    3.10 实践与练习

    第4章 运算符与表达式

    4.1 表达式

    4.2 赋值运算符与赋值表达式

    4.2.1 变量赋初值

    4.2.2 自动类型转换

    4.2.3 强制类型转换

    4.3 算术运算符与算术表达式

    4.3.1 算术运算符

    4.3.2 算术表达式

    4.3.3 优先级与结合性

    4.3.4 自增/自减运算符

    4.4 关系运算符与关系表达式

    4.4.1 关系运算符

    4.4.2 关系表达式

    4.4.3 优先级与结合性

    4.5 逻辑运算符与逻辑表达式

    4.5.1 逻辑运算符

    4.5.2 逻辑表达式

    4.5.3 优先级与结合性

    4.6 位逻辑运算符与位逻辑表达式

    4.6.1 位逻辑运算符

    4.6.2 位逻辑表达式

    4.7 逗号运算符与逗号表达式

    4.8 复合赋值运算符

    4.9 小结

    4.10 实践与练习

    第5章 常用的数据输入/输出函数

    5.1 语句

    5.2 字符数据输入/输出

    5.2.1 字符数据输出

    5.2.2 字符数据输入

    5.3 字符串输入/输出

    5.3.1 字符串输出函数

    5.3.2 字符串输入函数

    5.4 格式输出函数

    5.5 格式输入函数

    5.6 顺序程序设计应用

    5.7 小结

    5.8 实践与练习

    第6章 选择结构程序设计

    6.1 if语句

    6.2 if语句的基本形式

    6.2.1 if语句形式

    6.2.2 if…else语句形式

    6.2.3 else if语句形式

    6.3 if的嵌套形式

    6.4 条件运算符

    6.5 switch语句

    6.5.1 switch语句的基本形式

    6.5.2 多路开关模式的switch语句

    6.6 if…else语句和switch语句的区别

    6.7 小结

    6.8 实践与练习

    第7章 循环控制

    7.1 循环语句

    7.2 while语句

    7.3 do…while语句

    7.4 for语句

    7.4.1 for语句使用

    7.4.2 for循环的变体

    7.4.3 for语句中的逗号应用

    7.5 3种循环语句的比较

    7.6 循环嵌套

    7.6.1 循环嵌套的结构

    7.6.2 循环嵌套实例

    7.7 转移语句

    7.7.1 goto语句

    7.7.2 break语句

    7.7.3 continue语句

    7.8 小结

    7.9 实践与练习

    第2篇 核心技术

    第8章 数组

    8.1 一维数组

    8.1.1 一维数组的定义和引用

    8.1.2 一维数组初始化

    8.1.3 一维数组的应用

    8.2 二维数组

    8.2.1 二维数组的定义和引用

    8.2.2 二维数组初始化

    8.2.3 二维数组的应用

    8.3 字符数组

    8.3.1 字符数组的定义和引用

    8.3.2 字符数组初始化

    8.3.3 字符数组的结束标志

    8.3.4 字符数组的输入和输出

    8.3.5 字符数组的应用

    8.4 多维数组

    8.5 数组的排序算法

    8.5.1 选择法排序

    8.5.2 冒泡法排序

    8.5.3 交换法排序

    8.5.4 插入法排序

    8.5.5 折半法排序

    8.5.6 排序算法的比较

    8.6 字符串处理函数

    8.6.1 字符串复制

    8.6.2 字符串连接

    8.6.3 字符串比较

    8.6.4 字符串大小写转换

    8.6.5 获得字符串长度

    8.7 数组应用

    8.7.1 反转输出字符串

    8.7.2 输出系统日期和时间

    8.7.3 字符串的加密和解密

    8.8 小结

    8.9 实践与练习

    第9章 函数

    9.1 函数概述

    9.2 函数的定义

    9.2.1 函数定义的形式

    9.2.2 定义与声明

    9.3 返回语句

    9.3.1 从函数返回

    9.3.2 返回值

    9.4 函数参数

    9.4.1 形式参数与实际参数

    9.4.2 数组作函数参数

    9.4.3 main函数的参数

    9.5 函数的调用

    9.5.1 函数的调用方式

    9.5.2 嵌套调用

    9.5.3 递归调用

    9.6 内部函数和外部函数

    9.6.1 内部函数

    9.6.2 外部函数

    9.7 局部变量和全局变量

    9.7.1 局部变量

    9.7.2 全局变量

    9.8 函数应用

    9.9 小结

    9.10 实践与练习

    第10章 指针

    10.1 指针相关概念

    10.1.1 地址与指针

    10.1.2 变量与指针

    10.1.3 指针变量

    10.1.4 指针自加自减运算

    10.2 数组与指针

    10.2.1 一维数组与指针

    10.2.2 二维数组与指针

    10.2.3 字符串与指针

    10.2.4 字符串数组

    10.3 指向指针的指针

    10.4 指针变量作函数参数

    10.5 返回指针值的函数

    10.6 指针数组作main函数的参数

    10.7 小结

    10.8 实践与练习

    第3篇 高级应用

    第11章 结构体和共用体

    11.1 结构体

    11.1.1 结构体类型的概念

    11.1.2 结构体变量的定义

    11.1.3 结构体变量的引用

    11.1.4 结构体类型的初始化

    11.2 结构体数组

    11.2.1 定义结构体数组

    11.2.2 初始化结构体数组

    11.3 结构体指针

    11.3.1 指向结构体变量的指针

    11.3.2 指向结构体数组的指针

    11.3.3 结构体作为函数参数

    11.4 包含结构的结构

    11.5 链表

    11.5.1 链表概述

    11.5.2 创建动态链表

    11.5.3 输出链表

    11.6 链表相关操作

    11.6.1 链表的插入操作

    11.6.2 链表的删除操作

    11.7 共用体

    11.7.1 共用体的概念

    11.7.2 共用体变量的引用

    11.7.3 共用体变量的初始化

    11.7.4 共用体类型的数据特点

    11.8 枚举类型

    11.9 小结

    11.10 实践与练习

    第12章 位运算

    12.1 位与字节

    12.2 位运算操作符

    12.2.1 “与”运算符

    12.2.2 “或”运算符

    12.2.3 “取反”运算符

    12.2.4 “异或”运算符

    12.2.5 “左移”运算符

    12.2.6 “右移”运算符

    12.3 循环移位

    12.4 位段

    12.4.1 位段的概念与定义

    12.4.2 位段相关说明

    12.5 小结

    12.6 实践与练习

    第13章 预处理

    13.1 宏定义

    13.1.1 不带参数的宏定义

    13.1.2 带参数的宏定义

    13.2 #include指令

    13.3 条件编译

    13.3.1 #if命令

    13.3.2 #ifdef及#ifndef命令

    13.3.3 #undef命令

    13.3.4 #line命令

    13.3.5 #pragma命令

    13.4 小结

    13.5 实践与练习

    第14章 文件

    14.1 文件概述

    14.2 文件基本操作

    14.2.1 文件指针

    14.2.2 文件的打开

    14.2.3 文件的关闭

    14.3 文件的读写

    14.3.1 fputc函数

    14.3.2 fgetc函数

    14.3.3 fputs函数

    14.3.4 fgets函数

    14.3.5 fprintf函数

    14.3.6 fscanf函数

    14.3.7 fread和fwrite函数

    14.4 文件的定位

    14.4.1 fseek函数

    14.4.2 rewind函数

    14.4.3 ftell函数

    14.5 小结

    14.6 实践与练习

    第15章 存储管理

    15.1 内存组织方式

    15.1.1 内存的组织方式

    15.1.2 堆与栈

    15.2 动态管理

    15.2.1 malloc函数

    15.2.2 calloc函数

    15.2.3 realloc函数

    15.2.4 free函数

    15.3 内存丢失

    15.4 小结

    15.5 实践与练习

    第16章 网络套接字编程

    16.1 计算机网络基础

    16.1.1 IP地址

    16.1.2 OSI七层参考模型

    16.1.3 地址解析

    16.1.4 域名系统

    16.1.5 TCP/IP协议

    16.1.6 端口

    16.1.7 套接字的引入

    16.1.8 网络字节顺序

    16.2 套接字基础

    16.2.1 套接字概述

    16.2.2 TCP的套接字的socket编程

    16.2.3 UDP的套接字的socket编程

    16.3 套接字函数

    16.3.1 套接字函数介绍

    16.3.2 基于TCP的网络聊天程序

    16.4 小结

    16.5 实践与练习

    第4篇 项目实战

    第17章 学生成绩管理系统

    17.1 需求分析

    17.2 系统设计

    17.3 功能设计

    17.3.1 功能选择界面

    17.3.2 录入学生成绩信息

    17.3.3 查询学生成绩信息

    17.3.4 删除学生成绩信息

    17.3.5 修改学生成绩信息

    17.3.6 插入学生成绩信息

    17.3.7 统计学生人数

    17.4 小结

    附录 ASCII表

    展开全文
  • 初识C语言 3 什么是C语言 C语言——计算机语言——底层开发——人和计算机交流的语言 4 第一个C语言程序 #include<stdio.h> //包含一个叫stdio.h的文件 //std-标准 standard input output int main...
  • //C语言本身是不会检查数据的越界行为的 //指针使用之前检查有效性 int* p = NULL; if(p != NULL) *p = 10; return 0; } 指针运算 指针+-整数 指针-指针 指针-指针的前提:两个指针指向同一块空间 //指针-...
  • c语言从入门到精通pdf

    千次阅读 2021-05-19 20:04:59
    软件标签: c语言教程《C语言从入门到精通》介绍:本书初学者的角度出发,以通俗易懂的语言,丰富多彩的实例,详细介绍了使用c语言进行程序开发应该掌握的各方面知识.全书共分17章,包括c语言概述,算法,数据类型,运算符...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,338
精华内容 6,535
关键字:

c语言从入门到精通