首页  思维导图  详情

c语言基础

2020-09-18 23:38:19   0  举报





仅支持查看

AI智能生成

c语言基础

C语言

作者其他创作

大纲/内容

1.c语言简介和历史

计算机和编程语言

什么是计算机语言

程序是用特殊的编程语言写出来表达如何解决问题的

不是用编程语言来和计算机交谈，而是描述要求它如何做事情的过程或方法

算法

定义

计算的步骤

程序的执行

解释

借助一个程序，那个程序能试图理解你的程序然后按照你的要求执行

编译

将程序翻译成计算机能懂的语言（机器语言），然后程序就能直接执行了

解释语言vs编译语言

1.语言本身无法编译/解释之分

2.常用的执行方式而已

3.解释型语言有特殊的计算能力

例如：可以在运行中进行修改

4.编译型语言有确定的运算性能

c语言

c语言的历史与发展

c语言是从B语言发展而来

Bcpl是从FORTRAN发展而来

B语言精炼，接近硬件，但过于简单，无数据类型

最初的c语言只是位描述和实现UNIX操作系统提供一种工作语言而设计

语言支持指针间接方式

c语言受到PL/l的影响，还和PDP-ll的机器用语言有很大的关系

1973年11月，第四版的Unix发布，全是由c语言编写、

c语言与版本-标准

经典c

又被称为“K&R the C”， 1978 年，Dennis Ritchie 和 Brian Kernighan 合作推出了《The C Programming Language》的第一版(按照惯例，经典著作一定有简称，该著作简称为 K&R)，书末的参考指南 (Reference Manual) 一节给出了当时 C 语言的完整定义，成为那时 C 语言事实上的标准，人们称之为 K&R C。从这一年以后，C 语言被移植到了各种机型上，并受到了广泛的支持，使 C 语言在当时的软件开发中几乎一统天下。

'83或ANSIC

1983年，美国国家标准协会（ANSI）成立委员会，定制第一个c语言标准草案

c89（ANSI）

1989年ANSI发布c89，在1990年国际标准化组织ISO（International Organization for Standardization，ISO）接受了ANSI的标准

c90（ISO）

随后，《The C Programming Language》第二版开始出版发行，书中内容根据 ANSI C(C89)进行了更新。1990 年，在 ISO/IEC JTC1/SC22/WG14 (ISO/IEC 联合技术第 I 委员会第 22 分委员会第 14 工作组) 的努力下，ISO 批准了 ANSI C 成为国际标准。于是 ISO C(又称为 C90) 诞生了。除了标准文档在印刷编排上的某些细节不同外，ISO C(C90) 和 ANSI C(C89) 在技术上完全一样。

c95

ISO 在 1994、1996 年分别出版了 C90 的技术勘误文档，更正了一些印刷错误，并在1995 年通过了一份 C90 的技术补充，对 C90 进行了微小的扩充，经过扩充后的 ISO C 被称为 C95

c99

<ul><li>2001、2004年先后进行了两次技术修正（TC1和TC2）。 ISO/IEC 9899:1999(及其技术修正)被称为 C99 </li><li>C99是C89(及1995基准增补1)的扩充。本书的叙述以C99标准为依据。本书中程序基本上都可以在目前所用的编译系统(如VC++ 6.0，Turbo C++ 3.0,GCC)上编译和运行 </li></ul>

c语言用在哪里

操作系统

嵌入式系统

驱动系统

底层驱动

图形引擎，图像处理，声音效果

编译 -> 运行

c语言需要编译才能运行（需要下面中的一个） <ul><li>编译器 </li><li>编辑器 </li><li>IDE(集成开发环境) </li></ul>

<ul><li>上机输入与编辑源程序 </li><li>对源程序进行编译 </li><li>与库函数连接 </li><li>运行目标程序 </li></ul>

c语言主要特点

语言表达能力强

具有数据类型构造能力和结构化的程序控制结构

语言简洁，紧凑使用方便灵活

能使编译程序产生执行效率较高的代码

可编写移植性较好的程序

结构化程序设计方法

采用自顶向下，逐步求精的程序设计方法

使用三种基本控制结构造程序

结构化程序设计的主要设计语言

原则：自顶向下，逐步细化，模块化设计

2.简单的程序

iinclude<stdio,h> #include<stdlib.h> int main(void) {     //输出一句话    print（“hello”); }

注释

功能：让别人能看懂代码

符号

单行注释

/**/

多行注释（块注释)

注意：注释的结尾不确定

主函数

应用程序入口，操作系统调用程序的接口

注意：一个项目只有一个主函数

单个文件只能出现一个

多个文件只能一个文件夹一个

常见的五种格数

int main(void) {       return 0; }

 c语言标准主函数模式（c99）

void表示不接受任何函数

无void表示参数类型和数量不确定

int main(int argc,char* argv[]) {            return 0; }

c/c++标准主函数形式，使用命令参数

int main() {     return 0； }

c++标准主函数形式

main() {}

老标准（c89）支持的写法，现在也可以写。但尽量不要写

void main() { }

这种主函数写法逻辑上复合，而且很多系统支持，但是考虑到代码的移植性，建议用标准的形式进行书写。

return 0；

0表示正常结束

逻辑的连贯性

标准规定

头文件

#include<stdio.h>

标注输入输出头文件

就是让函数是可用的

输入输出 后面会有详细解释

printf

内置函数

常用的函数，是编译器中定义好的

增加程序的效率

不是所有的编译器都有，还是加上头文件好

算法

变量和常量

变量

定义

其值可以改变的量称为变量

变量的三要素

变量名：每个变量都应该有一个名字

变量的数据类型：每个变量都应该具有一个数据类型（在定义是指定）内存中占据一定的存储空间

变量的值：变量对应的存储空间中存放的数

使用变量的基本规则

变量必须先定义，后使用

所有变量必须在第一条可执行语句前定义

定义一个变量

变量格式：数据类型变量名称;                  数据类型变量名称 = 值； -- 一条申明语句可以声明若干同类型的变量

变量初始化

定义

在定义一个变量的时候要赋值

格式

单个变量：类型名称变量名称 = 初始值；

int price= 0；

组合变量:

int price = 0 ,amoum = 100;

变量的赋值

定义

将某一数值赋给某个变量的过程，称为赋值

例如

int a = 1；

其中“=”是赋值运算符

变量的输入输出

输入

scanf函数进行输入

格式

scanf("%数据类型",&变量名);

标识符

定义

标识符就是程序员自己规定的具有特定含义的词，比如类名称，属性名称，变量名等

标识符的命名规则

标识符由字母（A-Z,a-z）、数字（0-9）、下划线“_”组成，并且首字符不能是数字， 但可以是字母或者下划线

不能把C语言关键字作为用户标识符

标识符对大小写敏感，即严格区分大小写。一般对变量名用小写，符号常量命名用大写

标识符命名应做到“见名知意”，例如，长度（length），求和、总计（sum），圆周率（pi）……

常量

定义

值不能被改变的量称为常量

例如

int const *p; /* 定义的就是常量 */ int * const p; /* 定义的还是常量 */

const是一个修饰符，const的属性表示这个变量值一旦初始化就不能在修改

int a = 1；

1就是一个常量

宏常量（符号常量）

一般采用大写字母表示

格式

#define 标识符字符串

例如 #include <stdio.h> #define PRICE 30 void main( ) { int num,total; num=101; total=num*PRICE; printf("total=%d\n",total); return; }

运算符和表达式

运算符

算术运算符

定义：用来进行变量计算的符号

加法运算符，或正值运算符。如3+5、+3

减法运算符，或负值运算符。如5-2、-3

%

模运算符，或称求余运算符，%两侧均应为整型数据，如7%4的值为3）。只能对整型或字符型数据进行运算。

（除法运算符，如5/3）。两个整数相除结果为整数，如5/3的结果为1，舍去小数部分。同样的1/2=0。

乘法运算符，如3*5

自增运算符

只能用于变量，不能用于常量或表达式。结合方向（自右向左）

前置自增

在使用i之前，先使i的值加1

例如：     j=++i; (i的值加1，再赋给j

后置自增

在使用i之后，使i的值加1

例： j=i++; (先将i的赋给j，然后i在加1)

自减运算符

前置自减

在使用i之前，先使i的减1

例如： j=--i; (i的值加1，再赋给j)

后置自减

在使用i之后，使i的值减1

例： j=i++; (先将i的值赋给j，，然后i减1)

常用的标准数学函数

关系运算符

大于

小于

等于

大于等于

小于等于

不等于

逻辑运算符

！ 

逻辑非（相当于其他语言中的NOT）

逻辑与（相当于其他语言中的AND）

| |

逻辑或（相当于其他语言中的OR）

位运算符

定义：位运算是指进行二进制位的运算

用处

在系统软件中，常要处理二进制位的问题

例如 将一个存储单元中的各二进位左移或右移一位，两个数按位相加等

右移

a>>2 表示将a的各二进位右移2位。移到右端的低位被舍弃，对无符号数，高位补0

如a=017时： a为 00001111， a>>2为 00000011      11（此二位舍弃） 右移一位相当于除以2，右移n位相当于除以2n 。

左移

用来将一个数的各二进位全部左移若干位

例如： a=a<<2 将a的二进制数左移2位，右补0。若a=15，即二进制数00001111， 左移2位得00111100，即十进制数60

取反

~是一个单目（元）运算符，用来对一个二进制数按位取反，即将0变1，1变0。  例如~025是对八进制数25（即二进数00010101）按位求反。

例如~025是对八进制数25（即二进数00010101）按位求反。             a= 0000000000010101         ~a= 11111111111101010

按位或

参加运算的两数据，按二进位进行“或”运算。如果两个相应的二进位中只要 有一个为1，该位的结果值为1。即0|0=0；0|1=1；1|0=1；1|1=1。

例如：060|017             00110000 (|)         00001111             00111111

按位异或

异或运算符也称XOR运算符。它的规则是若参加运算的两个二进位相同，则结 果为0（假）；不同则为1（真）。即0^0=0；0^1=1；1^0=1；1^1=0；

00111001 （十进制数57，八进制数071） （^） 00101010 （十进制数42，八进制数052）           00010011 （十进制数19，八进制数023）

按位与

参加运算的两数据，按二进位进行“与”运算。如果两个相应的二进位都为1， 则该位的结果值为1，否则为0。即0&0=0；0&1=0；1&0=0；1&1=1；

例如：3&5=？。       3=00000011 (&) 5=00000101            00000001

注意点

位运算符中除“～”以外，均为双目（元）运算符。

运算量只能是整型或字符型的数据，不能为实型数据

不同长度的数据进行位运算 如果两个数据长度不同（例如long型和short型）进行位运算时（如a&b，而a为long型，b为short型），系统会将二者按右端对齐。如果b为正数，则左侧16位补满0。若b为负数，左端应补满1。如果b为无符号整数型，则左侧添满0

例题

【例3.6】将一个short整数a对应的二进制位从右端开始的4～7位二进制取出来组成另一个数。 #include <stdio.h> void main() { unsigned a,b,c,d; scanf("%o",&a); b=a>>4; c=~(~0<<4); d=b&c; printf("%o,%d\n%o,%d\n",a,a,d,d); return; }

子主题

赋值运算符

定义：赋值符号“=”就是赋值运算符，它的作用是将一个数据赋给一个变量

=  即其扩展运算符

就是进行赋值

复合的赋值运算符

算术运算符和赋值运算符

在应用中经常碰到“a=a+3”等情况，在C中允许将它变为“逆波兰”式情况，即“a+=3”，以提高运行效率

位运算符和赋值运算符

位运算符与赋值运算符可以组成复合赋值运算符 -- 例如，a&=b相当于a=a&b。a<<=2相当于：a=a<<2

<<=

>>=

条件运算符

？：

表达式为：表达式1？表达式2：表达式3

例如: 1、max=(a>b)?a:b 就是将a和b二者中较大的一个赋给max。 2、min=(a<b)?a:b 就是将a和b二者中较小的一个赋给min。

逗号运算符

，

指针运算符

*和&

求字节运算符

sizeof()

求不同的数据类型占的字节数

强制类型转换运算符

(数据类型)

强制数据类型转换

含义：可以利用强制类型转换运算将一个表达式转换成所需类型。

一般形式

（类型名）（表达式）

例如： (double)a //将a转换成double型 (int)(x+y) //将x+y的值转换成整型

注意

需要说明的是在强制类型转换时，得到一个所需类型的中间变量，原来变量的类型未发生变化

例题

#include <stdio.h> void main( ) { float x; int i; x=3.6; i=(int)x; //进行类型的强制转换 printf("x=%f,i=%d\n",x,i); }

成员运算符

.  →

通过符号指定结构或者联合中的某个成员，进行操做

下标运算法

[]

表达式

简介：表达式是用运算符号将，常量，变量，函数等连接成有意义的式子           表达式是操作数和运算符的结合体，它产生一个单一的值，操作数在表达式中是被运算的对象

赋值表达式

定义：由赋值运算符将一个变量和一个表达式连接起来的式子称为赋值表达式。

一般形式为

〈变量〉〈赋值运算符〉〈表达式〉。

运算过程

对赋值表达式求解的过程是：将赋值运算符右侧的“表达式”的值赋给左侧的变量。

例如

a=b=c=5 //赋值表达式值为5，a、b、c值均为5

a=5+(c=6) //表达式值为11，a的值为11，c的值为6

a=(b=4)+(c=6) //表达式值为10，a的值为10，b等于4，c等于6

逗号表达式

一般形式为

表达式1，表达式2，表达式3，……，表达式n

例如

x=(a=3,6*3) //第1个表达式 x=a=3,6*a //第2个表达式 - 第1个是赋值表达式，将一个逗号表达式的值赋给x，x的值等于18。 第2个是逗号表达式，它包括一个赋值表达式和一个算术表达式，x的值为3。

printf("%d,%d,%d"，a，b，c)； 上一行中的“a，b，c”并不是一个逗号表达式，它是printf函数的3个参数，参数间用逗号间隔。 - 如果改写为： printf("%d,%d,%d"，(a，b，c)，b，c)； 则“(a，b，c)”是一个逗号表达式，它的值等于c的值

例题

#include <stdio.h> void main( ) { int a,b,c; c=(a=2,b=5,a++,++b,a+b); printf("c=%d\n",c); return; }  -- 解题思路： 括号中 1.先给a和b都进行赋值 2.a++ 等于3 3.++b 等于6   这里不用考虑前置和后置，因为不是赋值和输出 4.a+b 等于9

关系表达式

介绍

用关系运算符将两个表达式（可以是算术表达式、关系表达式、逻辑表达式、赋值表达式、字符表达式）连接起来的式子

内容

关系表达式运算出的结果为0和非0

o表示假，即该关系不成立

非0，表示真，即该关系成立

逻辑表达式

介绍

用逻辑运算符将关系表达式或逻辑量连接起来的有意义的式子

简介

逻辑表达式的值应该是一个逻辑量“真”或“假”。C语言编译系统以数值1代表“真”， 以0代表“假”，但在判断一个量是否为“真”时，以0代表“假”，以非0代表“真”

逻辑运算符两侧的运算对象不但可以是0和1，或者是0和非0的整数，也可以是任何类型的数 据。可以是字符型，实型或指针型等。系统最终以0和非0来判定它们属于“真”或“假”。

例如： 5>3&&2||8<4-!0

在逻辑表达式的求解中，并不是所有的逻辑运算符都被执行，只是在必须执行下一个逻辑运算 符才能求出表达式的解时，才执行该运算符

例如

① a&&b&&c 只有a为真（非0）时，才需要判别b的值，只有a和b都为真的情况下才需要判 别c的值。只要a为假，就不必判别b和c（此时整个表达式已确定为假）。如果a为真，b为假， 则不判别c，整个表达式运算结果。 ② a||b||c 只要a为真（非0），就不必判断b和c；只有a为假，才判别b；a和b都为假才判别c。

例题

【例3.5】逻辑运算符的应用。 #include <stdio.h> void main( ) { int x=4,y=5,z,m; z=(x++==5) && (++y); printf("z=%d,x=%d,y=%d\n",z,x,y); m=(x++) || (++y); printf("m=%d,x=%d,y=%d\n",m,x,y); return; }

条件表达式

含义：条件表达式由条件运算符构成，并常用条件表达式构成一个赋值语句。

一般形式

x=<表达式1>?<表达式2>:<表达式3> 其意义是： 先求解表达式1，若为非0（真），则求解表达式2，将表达式2的值赋给x。 若为0(假)，则求解表达式3，将表达式3的值赋给x。口诀：前真后假。

例如： min=(a<b)?a:b; 相当于： if（a<b）    min = a; else     min =b; 效果是将a、b中较小的那个赋给min。

多个表达式

x=<表达式1>?<表达式2>:<表达式3>?<表达式4>:<表达式5>··· 执行顺序是从右到左依次判断再求出最后的x，即所谓的右结合性。

例如： a>b?a:c>d?c:d 应理解为 a>b?a:(c>d?c:d) 这也就是条件表达式嵌套的情形,即其中的表达式3又是一个条件表达式.

注意：此表达式后边无需加 “；”。

优先级

在表达式求值时，先按运算符的优先级别高低次序执行

优先次序（常见的）

算术运算符>关系运算符>赋值运算符 - 关系运算符前（<,<=,>,>=）的优先级别相同，（！=，==）优先级相同，前4种高于后2种。

逻辑运算符 (1) ！（非）→算术运算符→关系运算符→&&（与）→||（或）。

例如： (a>b)&&(x>y) //可写成a>b&&x>y (a= =b)||(x= =y) //可写成 a= =b||x= =y (!a)||(a>b) //可写成!a||a>b

所有的优先级

子主题

结合型

算术运算符的结合方向为“自左至右的结合方向”又称“左结合性”，即运算对象先与左面的运算符结合。例如：-a+b

输入和输出

C语言本身不提供输入输出语句，输入输出的操作是C标准函数库中提供了输入和输出函数

输出

定义：是以计算机主机位主体而言的。从计算计向输出设备（如显示器，打印机等）输出数据称为输出

输入

定义：从输入设备（如键盘，磁盘，光盘等）向计算机输入数据称为输入

标准输入输出函数

putchar（输出字符），getchar（输入字符），printf（格式输出），scanf（格式输入），puts（输出字符串），gets（输入字符串）

printf函数

一般格式

printf(“格式控制”，输出表列);

例如：printf("数字是  %d",a);

“格式控制”：是用双撇号括起来的一个字符串，称为”转换控制字符串“，简称”格式字符串“它包括两个信息

格式声明

作用：是将输出的诗句转换为指定的格式然后输出。

格式：格式声明式由%号开头的如%d，%f等

普通字符

作用：需要字符即需要在输出时原样输出的字符。例如双撇号中的汉字逗号空格等

输出表列：是程序需要输出的一些数据，可以是常量，变量或表达式

格式符

作用：对应不同的类型的数据要使用不同的格式声明

数据输出的格式符

d 格式符

用来输出一个十进制的整数

输出整形是%d

输出长整形是%ld

输出双长整形是%lld

特殊使用

指定输出数据的宽度，而这种格式是指定输出数据的宽域

printf("%5d",5);

输出数据占5列，而输出的数据显示在第5列的右侧

f 格式符

用来输出实数（包括单，双精度，长双精度）以小数形式输出

特殊使用

指定数据宽度和小数位数用%m.nf

printf("%5.2f",5.555);

输出的数据占5列，其中包括两个小数

字符输出的格式符

c 格式符

用来输出一个字符

特殊使用

字符输出也可以使用宽域

一个整数也可按字符型输出。在输出这个整数前,系统会将其转换成ASCII码 -- 当数字超过ASCII码的范围是就会减去255在循环查找一遍

例如： short a = 123; printf("%c",a);

例如： short a =555; prinf("%c",a);

s 格式符

用来输出一个字符串

C语句的作用和分类

三种基本结构

顺序结构

顺序结构就是按照顺序自上向下运行

选择结构

含义

选择结构用于判断给定的条件，根据判断的结果判断某些条件，根据判断的结果来控制程序的流程。

选择语句

if语句

关键词

else

if语句是可以嵌套使用的

一般形式

if(表达式)    语句1；

if(表示式)   语句1； else    语句2；

表达式可以是：关系表达式，逻辑表达式，数组表达式

语句：简单的语句，复合语句，另一个if语句等

最常见的3种if语句形式

1. if (表达式) 语句1 (没有else子句)

2. if (表达式) 语句1 else 语句2 (有else子句)

3. if（表达式１）语句１ else if（表达式２）语句２ else if（表达式３）语句３ ┆ else if（表达式ｍ）语句ｍ else 语句m+1 (在else部分又嵌套了多层的if语句)

switch语句

含义：是c语言中的开关语句

用法：switch语句的作用是根据表达式的值，使流程转到不同的语句

三个关键词

switch

case

标签的作用，用来标志一个位置

default

标签的作用，用来标志一个位置

一般式

switch语句的一般形式： switch（表达式） { case 常量1 ：语句1； case 常量2 ：语句2； ┇ ┇ ┇ case 常量n ：语句n； default : 语句n+1； }

注意点

表达式是整数，和字符型数据

语句中的常量1到常量n不能相同

当没查找到相同的语句时可以使用default来进行输出提示语句

例如

#include<stdio.h> int main() { double score;printf("请输入分数：\n"); scanf("%lf",&score);switch((int)(score/10)) //switch((int)score/10)出现严重错误 { case 10: case 9:printf("A(最好)\n");break; case 8:printf("B(优秀)\n");break; case 7:printf("C(良好)\n");break; case 6:printf("D(及格)\n");break; case 5: case 4: case 3: case 2: case 1: case 0:printf("E(不及格)\n");break; default:printf("Error!\n"); } }

循环结构

while语句

特点：先判断条件表达式，后执行循环体语句

一般形式

while (表达式) //循环条件 {      语句          //循环体 }

do while语句

特点:先执行循环体，在判断循环条件是否成立

一般形式为

do{        语句            //循环语句 }             while (表达式)；//判断条件

while和do while的不同点

#include <stdio.h> int main( ) { int i,sum=0; scanf("%d",&i); printf("i = %d\n",i); while(i<=10) { sum=sum+i; i++; } printf("sum=%d\n",sum); do { sum=sum+i; i++; }while(i<=10); printf("sum=%d\n",sum); }

当i<=10为真时

当i<=10为假时

当while后面的表达式的第一次的值为“真”时，两种循环得到的结果相同；否则不相同

for语句

一般形式

for(表达式1；表达式2；表达式3)   {             语句 }

表达式1：初始条件，只执行一次 表达式2：循环条件，用来判定是否继续循环| 表达式3：循环变量增值，使循环能结束

注意点

部分的表达式可以省略 如: for(；表达式2；表达式3) for(；表达式2；)

变量的定义可以与循环变量无关   如： for (sum=0 ; i<=100; i++)       sum=sum+i;

两边的表达式可以是逗号表达式 如  for(sum=0,i=1 ; i<=100; i++)        sum=sum+i;    for(i=0,j=100 ; i<=j; i++,j-- )        k=i+j；

执行步骤

(1) 求解表达式1 (2) 求解表达式2，若值为真，执行循环体语句，再转第(3)步。若为假，则结束循环 (3) 求解表达式3 (4) 转回第(2)继续执行

循环的嵌套

一个循环体内又包含另一个完整的循环结构称为循环的嵌套

三种循环可互相嵌套

合法形式  

while() {     ...     while()    {        ...     } }

do { do {...} while(); }while();

for(;;) {    for(::)     {...} }

(4) while( )    (5) for(;;)         (6) do     {…                  { …                  {…        do{…}            while( )          for(;;)        while( ) ;         { }                  { }        {…}                 …                  }     }                    }                     while( );

N-S流程图

子主题

break和continue语句

break

从循环体内跳出，即提前结束循环，接着执行循环下面的语句.

continue

用来结束本次循环，即跳过循环体中下面尚未执行的语句，判定是否执行 下一次循环。

区别

continue语句只结束本次循环，而不是终止整个循环的执行。

break语句结束整个循环过程，不再判断执行循环的条件是否成立。

数据类型

基本数据类型

数值类型

整形常量

就是1，2，3，4，5，6

当写个整数，默认就是int类型的数据，或者计算机会以int类型处理它

基本整形int

整数，在目前绝大多数机器上占4个字节。TC2中是2个字节

短整形short int

一般2个字节长。通常简写为short

长整形long int 

一般是4个字节长。通常简写为long

双长整形 long long int

一般是8字节，取值范围-2*63~（-2*63-1），通常简写long long

signed

用来修饰int、short和long，说明他们是有符号的整数（正整数、0和负整数）。一般缺省都是有符号的，所以这个修饰符通常省略

unsigned

用来修饰int、short和long，说明他们是无符号的整数（正整数和0）

浮点型（实型）常量

单精度 float

双精度 double

复数浮点型 float_complex,        double_comple,          long long_comple

番外

指数形式

介绍

由十进制数，加阶码标志“e”或“E”以及阶码( 只能为整数，可以带符号)组成。

格式

a E n(a为十进制数，n为十进制整数)， 其值为a×10n 如：2.1E5(等于2.1×105)。

隐式类型转换

横向向左的箭头表示必定的转换，如字符数据必定先转换为整数， short型转换为int型，float型数据在转换时一律先转换成双精度型。

纵向箭头表示运算对象为不同类型时转换的方向。例如int型与double型 数据进行运算，先将int型的数据转换成double型, 然后在两个同类型（d ouble型）数据间进行运算，结果为double型。

将实型数据（包括单、双精度）赋给整型变量时，舍弃实数的小数部分。 - 如i为整型变量，执行“i=3.56”的结果是使i的值为3，在内存中以整型形式存储。

将整型数据赋给单、双精度变量时，数值不变，但以浮点数形式存储到变量中 - 如将23赋给float变量f,即f=23，先将23转换成23.00000，再存储在f中。

将一个double型数据赋给float变量时，截取其前面7位有效数字，存放到float变量的存储单元（32位）中。 - 如： float f; double d=123.456789e100; f=d; // 编译提示：conversion from 'double ' to 'float ', possible loss of data 将一个float型数据赋给double变量时，数据不变，有效位数扩展到16位，在内存中以64位（bit）存储。

字符型数据赋给整型变量时，由于字符只占1个字节，而整型变量为4个字节，因此将字符数据（8位）放到整型变量低8位中

将一个int、short、long型数据赋给一个char型变量时，只将其低8位原封不动地送到char型变量 -- 例如： int i=289; char c=’a’; c=i; c的值为33，如果用“% c”输出c，将得到字符“！”（其ASCII码为33）。

字符型

char

介绍

字符型常量是用单引号括起来的一个字符

特点

(1) 字符常量只能用单引号括起来，不能用双引号或其他括号

(2) 字符常量只能是单个字符，不能是字符串(双引号括起来的内容称为字符串)。

(3) 字符可以是字符集中任意字符。

定义

转义字符是一种特殊的字符常量

特点

转义字符以反斜线“＼”开头，后跟一个或几个字符。转义字符具有特定的含义， 不同于字符原有的意义，故称“转义”字符。

转义的图片

布尔型

bool

指针（*）

前述

指针是一个值为内存地址的变量（或数据对象）

指针类型

基本数据类型的指针

char,short,int,long,longlong,float,double

指针的定义和使用

声明指针变量

什么是指针变量

是用来存放另一个变量的地址（即指针）的变量

例如 int *p;

形式:数据类型类型 +*+指针变量名;

int表示p装的地址对应的空间的数据类型

*表示p是一个指针变量

p指针的名字

指针指向空间

<ul><li>指针就是装地址的变量，变量就要赋值，即一定要装一块空间的地址，或者指向一块空间，才能被使用。</li><li>不装地址的指针以叫野指针。 </li><li>指针变量可以赋值，指针的指向在程序执行中可以改变（例如：指针p在执行中某时刻指向变量x，在另一时刻也可以指向变量y） </li></ul>

初始化

int a = 12;   int *p = &a;

赋值(简介运算符_)

int a = 12; int  *p;  p = &a;

注意点

1.指向是什么意思

装哪块地址，就指向哪块空间

2.类型一定要对应上

类型决定这指针的读写方式

3.指针不能与现有变量同名

4.指针变量的命名规则要与其他变量命名规则一样

5.指针可以存放C语言中任何基本数据类型，数组和其他所有高级数据结构的地址

6.应该指针指定一个地址后才能在语句中使用指针

通过指针操作所指向的空间

1.指向其他空间

p = &a; p = &b;

2.通过地址间接操作指向的空间

对内存的操作就三种：读写取地址

读

int a = 12; int *p = &a; printf("%d",*p);

输出的*与定义的时候*是一样的

定义的时候属于标记

这个时候是标记运算符、

写

int a = 12; int *p = &a; *p = 12345; scanf("%d",a);

取地址

p就是指向空间的地址，&p是p变量自己的地址

内存操作符

3.类型决定内存操作

所指向的空间是什么类型，那么*p就一次操作多大的内存空间

数组元素指针

所谓数组元素的指针就是数组元素的地址

数组指针的一些操作

定义数组元素的指针

知识拓展

在应用数组元素的时候可以使用下标法也可以使用指针法 -- 下标法：就是使用数组的下标如a[3]. 指针法：就是通过数组的指针来调用数组的数据 --- 但是指针法占内存少，运行速度高

操作

初始化

指向数组

例如： int a[10] = {1,2,3,4,5}; int * P = &a或&a[0];

指向数组的元素

例如： int a[10] = {1,2,3,4,5}; int * P = &a[1]或a+4;

赋值型

指向数组

例如： int a[10] = {1,2,3,4,5}; int * P; p = &a或&a[0];

指向数组的元素

例如： int a[10] = {1,2,3,4,5}; int * P; p = &a[1]或a+4;

注意点

数组名不代表整个数组，只代表数组首个元素的地址

引用数组元素时指针的运算

假设p是数组的a[0] 可以访问第i个数组元素 加i个整数（用+）  例如：p+i; 减i个整数（用-）    例如：p-i; -- 访问下一个元素 加等于运算：如p+=; 自加运算：如p++，++p; -- 访问上一个元素 减等于运算：如p-=； 自减运算：如p--,--p;

指针的大小

内存申请与释放

变量与空间

宏观上分析，多个程序同时执行是什么情况

所有程序/软件的运行，是由操作系统统一调配的，操作系统是程序的运行环境

运行中的多个程序之间，内存是不交叉的

程序结束，操作系统还要释放其使用的资源

微观上分析，就是我们程序里定义的变量，申请的空间（之一）

 变量

申请在哪块内存区域？

由谁申请

什么时候释放

由谁释放

比如 int a = 2; int a[23]; 

过程

数组都是内存的栈区存储

什么是栈（堆栈）区

栈区

特点

内存由系统申请，在变量生命周期结束时由系统释放

生命周期

定义到释放

不时所有的变量在程序结束时（软件关闭时）才释放，服务器为例子

堆区

特点

由我们随时申请，由我们自己随时释放

全局区

字符常量区

代码区

栈区和堆区的对比

栈区变量

由系统申请并释放

分析：也就是程序运行时候，系统要多个任务，就时检测变量时否该释放类了。直白点就是cpu要抽时间执行这部分功能

所以，如果这种变量比较多，不加节制的定义的话，cpu额外的工作量就会加大，程序的运行效率就会降低。

堆区变量

由我们自己申请，由我们自己随时释放

实际运用中

限制我们使用大小，默认大小是1m（不同的编译器是不同的）

stack overflow 爆栈了

堆栈等于栈

默认数值这个大小是可以修改的，但是尽量不要修改。

堆区内存分配（malloc）与释放（free）

malloc'

功能

在堆区申请指定大小的连续的一段空间，并返回该空间的首地址

理论上，32位系统最大申请4G，64位系统最大16tb（由安装内存决定）。

函数原型

void * malloc(size_t size);

举例

int *p =(int *)malloc(4);

int *p p = (int *)malloc(4);

malloc

函数名字

函数参数

要申请的字节数

size_t 

32位编译器环境 unsigned int

sizeof size_t 4字节

64位编译器环境 unsigned int

 sizeof size_t 8字节

整形表达式

无符号后缀是u

2*2

sizeof(int)

写个小数

系统会个你转换成帧数，所以还是写整数

头文件

stdlib.h malloc.h

两个都要写

对申请空间三种情况进行讨论

malloc(正常)

malloc(0)

malloc得到可用空间首地址，0表示该地址起多少个空间可用

malloc(极限)

申请失败返回NULl就是0，没申请到，这个一般内存不够用了

怎么避免

在申请空间时，要在指针前进行判断，并做一些提示

直接使用NULL指针是崩溃的

强制类型转换

(类型*)

malloc就是返回的void*，所以要转换成想要的类型在操作

vs可以不加，有的编译器不加就会报错

定义指针p的使用

所申请的空间无初始化方式

空间全部赋值

使用for循环

例如： for （int i = 0；i<10;I++）             {                         p[i] =0;                          }

使用函数memset

使用头文件 memory.h

例如：memset(p,1,40) 第一个参数：指针名 第二个参数：赋值的大小 第三个参数：指针空间大小

int a; int *p =&a; *p1 ==a;

int *p2 =(int*)malloc(4); //相当于&a，malloc的空间没有名字 *p == 这个空间 //相当于a

注意点

1.千万不能越界

比如要申请四字节当int使用，不能申请三个，但是申请多了也是可以的（不过尽量不要这样）

注意边界

2. 一个指针指向了一块堆空间，千万不也能在指向另一块

会导致内存丢失，造成内存泄露

丢失会继续占用

如果循环就完蛋了

当用一个新的指针记录这个地址后，原来的指针就可以解放

free

函数原型

void free(void *memblock);

释放内存

在我们不用的位置释放内存，如果不释放就一直保存在那

例子

free(p); 变量是指针名

返回值

void表示无返回值，主函数void表示无参数，也就是啥都不用管，直接free(p);

参数

要释放的空间指针

注意点

free后的指针，但是空间不能使用

所以，一般指针释放后，赋值一个null；

没有具体指向的指针，叫野指针 

不能重复释放同一块空间

不能释放栈区空间

一定要释放头指针

崩溃

运行中的崩溃，一定是某一行具体的代码引起的

运行结束的崩溃，基本就是内存越界操作了，很难查找

至关重要的一点

malloc的空间在程序结束的时候，系统会自动释放所malloc的内存。那为什么还要free()?

服务器会给你重启的机会吗

用户使用软件也不会一直重启

基本数据类型申请

int *p = (int*)malloc(4); short *p1 = (short*)malloc(sizeof(short)); float *p2 = (float*)malloc(4); double *p3 = (double*)malloc(8); long *p4 = (long*)malloc(sizeof(long));

子主题

数组malloc的申请

申请一位数组

一维数组的特点

一段连续的空间，数组名字是首元素的首地址

思考

那我们malloc一段空间，然后记住首地址，不就是一个数组了嘛

定义

int* p = (int*)malloc(sizeof(int)*5);  4*5

p第一个元素的地址，p+1就是第二个元素的地址......

定义的时候是初始化的值

malloc不能初始化

可以使用memset赋值成0

赋值成任意值要使用循环

访问

*(p+0) == *p  *(p+2)  *(p+3)  *(p+4)  

公式*(p+n) =p(n)

p(0)  p(1)  p(2)  p(3)  p(4)

malloc的数组与int a[3]这种栈区数组的区别

使用

定义有点不一样，使用一模一样，free

malloc的数组可任意指定长度

int  a;                 scanf("%d",&a);         malloc(a);

可以在运行过程种指定任意大小

动态数组，动态分配空间

int a[2]; 就不一样了，个数在定义时候确定，以后就不能修改

虽然又变长数组的标准，但是支持的编译器不多

只要定义好了，这个p就是跟二维数组的int a[2]的a一模一样，千万不能越界

一维数组指针接这个空间

int (*p)[5] = (int(*)[5])malloc(4*5);

可类比一维数组

int a[5];              int (*p)[5] = &a;

那么

*p == a

所以

访问

*(p+0) ==** p  *(*p+1) *(*p+2) *(*p+3) *(*p+4)

公式 *(*p+n)=(*p)[n]

(*p)[0] (*p)[1] (*p)[2] (*p)[3] (*p)[4]

二维数组指针接这个空间

int(*p)[2][3] = (int (*)[2][3])malloc(2*3*4);

可类比一维指针

int a[2][3];                 int (* p )[2][3] = &a;

*p ==a

访问

*(p+0) ==** p  *(*p+1) *(*p+2) *(*p+3)  *(*p+4)

公式 *(*p+n)=(*p)[n]

(*p)[0][0] (*p)[0][1] (*p)[0][2] (*p)[1][0] (*p)[1][1] (*p)[1][2]

calloc realloc

功能

申请一段空间数组

void *calloc（size_t num,size_t size）;

例子

int *p =(int *)calloc(5,4);

头文件

<stdlib.h>和<malloc.h>

特点

每个元素会被初始化成0

*的四种作用

声明的时候有*，表示指针变量

*+地址，表示地址操作符

数字*数字表述乘法

注释

函数类型

函数类型用来定义函数，描述一个函数的接口，包含函数返回值的数据类型和参数的类型

构造类型

数组([])

含义

就是一组具有固定数目的、有序的、类型相同的数据的集合。 根据数组下标的多少，数组可以分为一维数组和多维数组。

图片

一维数组

格式

数据类型数组名[常量表达式]

数据类型：任一种基本数据类型或构造数据类型

数组名：用户自定义的数组名字，其定名规则与变量名定名规则一样，都需遵循标识符定名规则

常量表达式：表示元素的个数即数组长度

[]:下标运算符单目运算符 优先级(1) 左结合 不能用( )

数组的初始化

完全初始化

就是定义的时候就给所有的空间进行赋值

int a[5] = {1, 2, 3, 4, 5};

int a[] = {1, 2, 3, 4, 5}; 可以不写常量

部分初始化

只使用了一部分空间

int a[5] = {1, 2};

使用输入函数

通过手动键盘输入赋值

# include <stdio.h> int main(void) { int a[5] = {0}; //数组清零初始化 int i; printf("请输入5个数:"); for (i=0; i<5; ++i) { scanf("%d", &a[i] ); } for (i=0; i<5; ++i) { printf("%d\x20", a[i]); } printf("\n"); return 0; }

使用表达式赋值

int a[10] = {1,2,3,4,5} a[4]=a[3]+2;

数组的使用

数组必须先定义，然后使用。

数组元素的表示形式为：数组名[下标] -- 下标可以是整型常量或整型表达式

C语言规定只能逐个引用数组元素而不能一次引用整个数组

注意

数组名不能与其它变量名相同

不能在方括号中用变量来表示元素的个数，但可以是符号常数或常量表达式

#define FD 5 void main() { int a[3+2],b[7+FD]; …… }

方括号中常量表达式表示数组元素的个数。 如int a[5]: 数组a有5个元素，其下标从0开始，分别为a[0],a[1],a[2],a[3],a[4]。

允许在同一个类型说明中说明多个数组和多个变量。 例如： int a,b,c,d,k1[10],k2[20];