1. 什么是程序: 程序是用来完成特定功能的一系列指令
指针是一个变量, 其值为另一个变量的地址, 即, 内存位置的直接地址. 就像其他变量或常量一样, 您必须在使用指针存储其他变量地址之前, 对其进行声明.
要理解指针就要先理解计算机的内存. 计算机内存会被划分为按顺序编号的内存单元. 每个变量都是存储在内存单元中的, 称之为地址.
- #include <stdio.h>
- int main ()
- {
- int var = 20; /* 实际变量的声明 此时的 VAR 这个变量是存在某个地址的, 地址对应某个内存单元, 该单元中存储了数据 20 */
- int *ip; /* 指针变量的声明 定义了一个指针 即一个内存单元的地址变量 */
- ip = &var; /* 在指针变量中存储 var 的地址 就是将地址值赋值给指针这个变量 *$* 在指针变量中存储的地址 利用 & 符号直接输出了 var 所存储的数据的内存单元的地址 */
- printf("Address of var variable: %p\n", &var );
- /* 在指针变量中存储的地址 ip 代表的是这个赋值到的地址的值 所以输出的是地址值 */
- printf("Address stored in ip variable: %p\n", ip );
- /* 使用指针访问值 *ip 代表的是定义到这个内存单元之后, 内存单元中所存储的数据的值也就是将 20 赋值给 var 中 20 这个值 */
- printf("Value of *ip variable: %d\n", *ip );
- return 0;
- }
指针是一个变量, 所以可以使用任何合法的变量名. 在大多数的操作系统上, 程序不允许访问地址为 0 的内存, 因为该内存是操作系统保留的.
然而, 内存地址 0 有特别重要的意义, 它表明该指针不指向一个可访问的内存位置.
但按照惯例, 如果指针包含空值(零值), 则假定它不指向任何东西.
所有指针在创建时都要初始化, 如果不知道他指向什么就讲 0 赋值给他. 必须初始化指针, 没有被初始化的指针被称为失控指针(野指针).
- #include <stdio.h>
- int main ()
- {
- int *p = 0;
- int a ;
- p = &a;
- printf ("输入一个数字 \ n");
- scanf ("%d",p);
- printf("%d\n",*p);
- }
实例定义了变量 a 和指针变量 p.p = &a; 表示指针变量指向了变量 a,p 中存放的地址为 a 的地址 &a,*p 所指的是 p 中存放的地址 a 内存单元中的值.
- /* 按照偏移值访问函数形参内容实验 *$/ 二级指针
- void Pros(char* a,int b,int e,char et)
- {
- char **p=&a;
- //a==*p
- printf("%p %p %p %p \n%p\n",&a,p,a,*p,&b);
- printf("%s\n",*p);
- p++;
- printf("%d\n",*p);
- p++;
- printf("%d\n",*p);
- p++;
- printf("%c\n",*p);
- return;
- }
- // 一级指针访问
- void Test(char* a,int b)
- {
- char *p=(char*)&a;
- //a!=*p;
- //printf("%p %p %p %p\n",&a,p,a,*p);
- //printf("%p\n",&b);
- // 得出结果一级指针自加 + 1 二级指针自按照元素内容大小自加
- //printf("%d %p\n",*(++p),p);
- //printf("%d %p\n",*(p+8),p+8);
- //a=a[0]一个 printf 函数以'\0'结束
- // 此时 p=&a 把元素首地址给了 p 或者说 a 只记录一个元素首地址的地址
- // 同等汇编语句 a:db 'Hello' b:db '16'
- // 所以 p=&a != p=a ;
- /*
- char *a="Hello";
- char *b=(char*)&a;
- printf("%p %p %p %p",&a,b,a,&(a[0]));
- *$/printf("%c %p %p\n",*a,a,&(a[0]));
- //printf("%c %p %p\n",*(a+1),a+1,&(a[1]));
- printf("%c\n",*(*(char**)p));
- //if p=a; *p=a;
- p=a;
- printf("%s",p);
- return;
- }
- int main()
- {
- //Pros("Hello",5,66666,'a');
- Test("Hello",16);
- // 指针转换问题
- /*
- char *a="Hello";//&a 变量里面存储着 a 所指向的变量地址
- //char **p=&a;
- char *b=(char*)&a;
- char **p=&a;
- printf("%p %p %p %p\n",&a,b,a,*b);
- printf("%p %c\n",&(*a),*(&(*(a+1))));
- printf("%p %c\n",a,*a);// 此时 a->H,*a=H;
- printf("%p %c\n",(*p),*(*p));
- //p=&a,*p=a 所指向的第一个元素的地址还需要一解才能访问正确数据
- // 所以 1 级指针需要解 2 次 所以进行强制转换
- printf("%c \n",*(*(char**)b));
- // 原试解 现在 b=&a,*b= &a->a 所以如果此时想正确访问 H 必须在解
- */
- return 1;
- }
参考地址
指针的一些复杂说明:
int p; -- 这是一个普通的整型变量
int *p; -- 首先从 p 处开始, 先与 * 结合, 所以说明 p 是一个指针, 然后再与 int 结合, 说明指针所指向的内容的类型为 int 型. 所以 p 是一个返回整型数据的指针.
int p[3] -- 首先从 p 处开始, 先与[] 结合, 说明 p 是一个数组, 然后与 int 结合, 说明数组里的元素是整型的, 所以 p 是一个由整型数据组成的数组.
int *p[3]; -- 首先从 p 处开始, 先与 [] 结合, 因为其优先级比 * 高, 所以 p 是一个数组, 然后再与 * 结合, 说明数组里的元素是指针类型, 然后再与 int 结合, 说明指针所指向的内容的类型是整型的, 所以 p 是一个由返回整型数据的指针所组成的数组.
int (*p)[3]; -- 首先从 p 处开始, 先与 * 结合, 说明 p 是一个指针然后再与 [] 结合(与 "()" 这步可以忽略, 只是为了改变优先级), 说明指针所指向的内容是一个数组, 然后再与 int 结合, 说明数组里的元素是整型的. 所以 p 是一个指向由整型数据组成的数组的指针.
int **p; -- 首先从 p 开始, 先与 * 结合, 说是 p 是一个指针, 然后再与 * 结合, 说明指针所指向的元素是指针, 然后再与 int 结合, 说明该指针所指向的元素是整型数据. 由于二级指针以及更高级的指针极少用在复杂的类型中, 所以后面更复杂的类型我们就不考虑多级指针了, 最多只考虑一级指针.
int p(int); -- 从 p 处起, 先与 () 结合, 说明 p 是一个函数, 然后进入 () 里分析, 说明该函数有一个整型变量的参数, 然后再与外面的 int 结合, 说明函数的返回值是一个整型数据.
int (*p)(int); -- 从 p 处开始, 先与指针结合, 说明 p 是一个指针, 然后与 () 结合, 说明指针指向的是一个函数, 然后再与 () 里的 int 结合, 说明函数有一个 int 型的参数, 再与最外层的 int 结合, 说明函数的返回类型是整型, 所以 p 是一个指向有一个整型参数且返回类型为整型的函数的指针.
int *(*p(int))[3]; -- 可以先跳过, 不看这个类型, 过于复杂从 p 开始, 先与 () 结合, 说明 p 是一个函数, 然后进入 () 里面, 与 int 结合, 说明函数有一个整型变量参数, 然后再与外面的 * 结合, 说明函数返回的是一个指针, 然后到最外面一层, 先与 [] 结合, 说明返回的指针指向的是一个数组, 然后再与 * 结合, 说明数组里的元素是指针, 然后再与 int 结合, 说明指针指向的内容是整型数据. 所以 p 是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数.
2. 语言的分类:
低级语言: 机器语言, 汇编语言
高级语言: C,BASIC.....
面向对象的语言: C++,VB,JAVA...
高级语言编写的程序有两种方式被翻译成计算机能识别的目标程序:
(1)编译执行是将源程序翻译为一个可执行的目标程序, 该目标程序脱离编译环境和源程序, 独立存在和执行
(2)解释执行是将源程序逐句解释成二进制指令, 解释一句执行一句, 不生成可执行文件, 执行速度比编译方式慢
3. C 语言的历史: http://baike.baidu.com/link?url=mXLO7rAwbGhOj1EXGIBbo5RxfK11KnCceJo28XS1339s2TIwtLnRngqyc9pdzMa1H2572-1RxS3Flofhx03PJvFo50lDunjF2H9Kl_bnWnQmHjmJZEqetECLuP6ZmM7NGXs-vSbscOQhHxy_zShbl_
4. 计算机系统结构: -- 冯. 诺依曼
(1)计算机由控制器, 运算器, 存储器, 输入设备和输出设备 5 个部分构成
(2)计算机用二进制, 指令和数据均以二进制数形式表示和存放
(3)计算机按照程序规定的顺序将指令从存储器中取出, 并逐条执行
程序设计的本质: 设计能够利用计算机的 5 个部分完成特定任务的指令序列
5. 算法及其特性, 表示方法:
定义: 解决一个问题所采用的一系列步骤
特性: 有穷性, 确定性, 输入, 输出, 可行性
表示方法: 自然语言, 伪代码, 流程图, N-S 流程图
6. 结构化程序设计方法:
(1)程序组织结构化(原则是对任何程序都以顺序结构, 选择结构, 循环结构作为基本单元进行组织)
(2)程序采用自顶向下, 逐步细化, 功能模块化的方法
- ASCII: http://baike.baidu.com/link?url=ighZHnhgup_L70abLa_qNS1bMp4lIbmzYXXGr1Cpqnx69UcbtQfGBg9wAIZI9tnyD2kcJbnr4bAw67i1kxQ5MXtqpcg2cSz7dVG9xeyegyM2LSxl88P8YSCXTiGTORNt6T2Taf6LgT8UUk6f1EcmVh7RFwUpeno1ldF2VwqvTVm
- void main(int argc, char *argv[])
argc: 命令行中参数的个数
argv[ ]: 指针数组, 每个元素指向命令行中的字符串
C 程序由函数构成且至少包括一个 main()函数, 而 man 函数只能有两个参数, 一般写为 argc 和 argv 这种形式, 可在操作命令状态下, 调用 main 函数
其实大部分时间不写, 也不调用 main 函数
2016 年 10 月 31 日 21:23:34
大一的课本看了一下, 感觉没什么干货, 找到了以前自己写的两本笔记本, 每天跟新笔记本的内容
一本是在大一暑假自学郝斌视频的时候记录的, 另外一本是在大二上图书馆找的书自己整理的, 以后的内容会结合两本一起更新.
1. 什么是程序: 程序是用来完成特定功能的一系列指令
2. 语言的分类:
低级语言: 机器语言, 汇编语言
高级语言: C,BASIC.....
面向对象的语言: C++,VB,JAVA...
高级语言编写的程序有两种方式被翻译成计算机能识别的目标程序:
(1)编译执行是将源程序翻译为一个可执行的目标程序, 该目标程序脱离编译环境和源程序, 独立存在和执行
(2)解释执行是将源程序逐句解释成二进制指令, 解释一句执行一句, 不生成可执行文件, 执行速度比编译方式慢
3. C 语言的历史: http://baike.baidu.com/link?url=mXLO7rAwbGhOj1EXGIBbo5RxfK11KnCceJo28XS1339s2TIwtLnRngqyc9pdzMa1H2572-1RxS3Flofhx03PJvFo50lDunjF2H9Kl_bnWnQmHjmJZEqetECLuP6ZmM7NGXs-vSbscOQhHxy_zShbl_
4. 计算机系统结构: -- 冯. 诺依曼
(1)计算机由控制器, 运算器, 存储器, 输入设备和输出设备 5 个部分构成
(2)计算机用二进制, 指令和数据均以二进制数形式表示和存放
(3)计算机按照程序规定的顺序将指令从存储器中取出, 并逐条执行
程序设计的本质: 设计能够利用计算机的 5 个部分完成特定任务的指令序列
5. 算法及其特性, 表示方法:
定义: 解决一个问题所采用的一系列步骤
特性: 有穷性, 确定性, 输入, 输出, 可行性
表示方法: 自然语言, 伪代码, 流程图, N-S 流程图
6. 结构化程序设计方法:
(1)程序组织结构化(原则是对任何程序都以顺序结构, 选择结构, 循环结构作为基本单元进行组织)
(2)程序采用自顶向下, 逐步细化, 功能模块化的方法
- ASCII: http://baike.baidu.com/link?url=ighZHnhgup_L70abLa_qNS1bMp4lIbmzYXXGr1Cpqnx69UcbtQfGBg9wAIZI9tnyD2kcJbnr4bAw67i1kxQ5MXtqpcg2cSz7dVG9xeyegyM2LSxl88P8YSCXTiGTORNt6T2Taf6LgT8UUk6f1EcmVh7RFwUpeno1ldF2VwqvTVm
- void main(int argc, char *argv[])
argc: 命令行中参数的个数
argv[ ]: 指针数组, 每个元素指向命令行中的字符串
C 程序由函数构成且至少包括一个 main()函数, 而 man 函数只能有两个参数, 一般写为 argc 和 argv 这种形式, 可在操作命令状态下, 调用 main 函数
其实大部分时间不写, 也不调用 main 函数
--------------2016 年 11 月 1 日 18:34:38------------
基本类型: 所谓 "基本", 是指其值不可以再分解的数据类型.
整型
实型:
单精度
双精度
字符型
枚举类型
构造类型: 利用现有的一个或多个数据类型构造新的数据类型
数组类型
结构体类型
共用体类型
指针类型: 用于表示某个变量在内存中的地址
空类型: 类型说明符为 void, 常用来定义没有返回值的函数
2. 变量
变量必须先定义后使用. 定义变量时, 系统自动检测出所需要的存储空间大小, 然后为变量分配存储单元
标识符只能由字母, 数字和下划线组成, 且第一个字符必为字母或下划线
变量赋初值:(1)初始化: 在定义变量的同时给变量赋初值
(2)先定义后赋值
3. 常量
(1)字面常量: 整型常量, 实型常量, 字符型常量(必用'')
(2)符号常量: 用一个标识符代表一个常量 #define 标识符 常量
(3)const 常量: 只读常量: const 类型标识符 变量标识符 = 初始化数据
或者 类型标识符 const 变量标识符 = 初始化数据
只能在定义时初始化, 之后不能进行赋值, 有点像 java 里的 final
4. 八进制前缀是 0, 十六进制前缀是 0X
5. 整型数据的输入和输出
(1)标准输入输出文件
- #include<stdio.h>
- #include: 预处理命令, 将头文件包含到用户的源程序
stdio.h: 标准输入输出头文件, 提供输入和输出函数的原型
(2)printf 的用法:
- printf("字符串")
- printf("输出控制符", 输出参数)
- printf("输出控制符 1 输出控制符 2.....", 输出参数 1, 输出参数 2.....)
个数必须匹配
printf("输出控制符 非输出控制符(如转义字符)", 输出参数)
为什么需要输出控制符:
如 01 组成的代码可以表示数据也可以表示指令
如果 01 组成的代码表示数据, 那么同样的 01 代码组合以不同的输出就有不同的输出结果
(3)scanf 用法:
将从键盘输入的字符转化为输入控制符所规定格式的数据, 然后存入以输入参数的值为地址的变量中
- scanf("输入控制符", 输入项地址列表)
- scanf("非输入控制符 输入控制符", 输入参数)
非输入控制符必须原样输入
例: scanf("m%d",&i)
若键盘敲入: m123n, 则输出 i 显示 123
- scanf("%d,%d,%d",&i,&j,&k);
- printf("i = %d,j = %d, k = %d",i , j, k);
若键盘敲入: 1(空格)2(空格)3
则输出: i = 1,j = (乱码, 不可预知),3 = (乱码)
所以输入的字符不会丢弃
scanf("%c",&a); 会记录回车符, 即'\n'也会输入到 a 中, 但 %s 就不会,%s 以空格和回车作为结束
6. 整型数据在内存中的存储方式
以补码的形式存储, 正数的源码, 反码, 补码一样; 负数的补码 = 反码 + 1
7. 实型常量与变量
名称 位数 有效数字
- float 32 6~7
- double 64 15~16
- long double 64 15~16
浮点数的有效数字位决定数据的精度
浮点型数据非准确存储
实型数据的输入和输出:
m.n m 为域宽 n 为精度
高精度与低精度运算, 结果为高精度
8. 实型数据在内存中的存储方式
有效位数之外的将舍弃, 因此有效数字的位数决定精度
将一个实属表示成小数部分和指数部分, 分别存放
如:+123.567
+ 123567 + 3
数的符号位 | 数字部分 | 指数的符号位 | 指数
9. 字符型常量, 转义字符与变量
(1) 字符常量: 用''将其括起来
(2) 转义字符:"\" 后跟一个字符, 代表一个特殊控制字符
(3) 字符型变量: char, 一个字符型变量占一个字节的内存空间, 可存放一个字符
字符型数据的输入输出:
(1)基本输入输出函数: i = getchar(),putchar(i)
(2) 格式输入输出函数: scanf,printf
字符串用 "" 括起来, 包括转义字符
10. 运算优先级
算数> 关系> 赋值> 逻辑
逗号表达式: 表达式 1, 表达式 2.... 表达式 n
总表达式的值为右边表达式 n 的值, 且, 是所有级别中最低的
如:
i = 1+1,2+2;//i 为 4
11. 数据类型的转换
(1)隐式转换: 转换使数据的字节长度变长, 精度变高.
如 float 到 double,short 和 char 到 int
赋值时, 等号两边数据精度不同, 则右边变为左边
如: int i = 1.234; //i 为 1
(2)强制类型转换:
(类型名)(表达式)
只将结果进行临时转换, 不改变变量的数据类型
如: double k = 1.234;
- int i = (int)k ; // i 为 1
- int *p;
- p = (int *)malloc(siezof(int)); // 其中 (int *) 是强制类型转换
------------------2016 年 11 月 2 日 23:57:42--------------
1. 逻辑运算符和逻辑表达式
a&&b&&c a 为假时, 不再判断 b,c; 只有 a 真, b 真的情况下, 才判断 c
a || b || c a 为真, 则不再判断 b,c; 只有 a 假, b 假的情况下, 才判断 c
- 2. if
- if(表达式) // 表达式为真, else 后面不跟判断语句
语句;
else //else 总与它前面最近的未配对的 if 配对
语句;
- 3.switch
- switch(变量或常量) // 各个 case 和 default 的先后次序不影响运行
- {
case 常量表达式 : 语句 ; // 可在每个 case 后加 break, 来跳出 switch 否则将执行下一个 case
....... .....
default : 语句; // 若匹配的 case 没有语句, 将执行下一个 case 的语句
}
4. 表达式 1 ? 表达式 2: 表达式 3
1 为真, 则执行 2, 否则执行 3
- 5.while
- while(表达式 P) // 先判断 P, 为真则进入循环
{循环语句} // 在循环语句中要有使 P 为假的语句
- 6.do....while
- do
{循环语句}
- while(表达式 P); //P 为真时, 执行循环
- 7.for
- for(表达式 1; 表达式 2; 表达式 3) // 先执行表达式 1, 通常为赋值; 表达式 2 为真, 则循环; 表达式 3 通常改变循环变量
{循环语句} // 三个表达式均能省, 但';'不行
8. break
(1)跳出 switch 结构, 并继续执行 switch 结构之后的语句
(2)跳出最近的循环语句, 并继续执行循环结构之外的语句
(3)不能直接用于 if
continue
结束本次循环, 继续进行下次循环 // 不能直接用于 switch 内
9.goto
无条件转向语句: goto 语句符号;
与 if 组合, 可成为循环体; 在循环体内可跳出循环体;
但 goto 使程序流程无规律, 限制使用
------------------2016 年 11 月 4 日 18:06:24----------------
1. 一维数组的定义:
数据类型 <数组名>[常量表达式] -- 不包括变量
int a[0] ; 返回值为 a[0]的首地址
在对数组全部元素赋初值时, 可以不指定数组的长度, 数组长度与初始化的元素个数相等
如: int a[ ] = {1,2,3} ; 数组长度为 3
定义:(1)为 n 个变量连续分配存储空间
(2)所有的变量数据类型必须相同
(3)所有变量所占字节大小必须相同
初始化:
(1)完全初始化: int a[5] = {1,2,3,4,5} ;
(2)不完全初始化: int a[5] = {1,2,3} ; // 为初始化部分自动天 0
(3)不初始化: int a[5] ; // 所有元素为垃圾值
(4)清零 : int a[5] = {0} ;
只有在定义数组的同时才可以整体赋值, 其他情况下整体赋值都为错
2. 二维数组的定义
数据类型 <数组名>[常量表达式 1][常量表达式 2] // 表达式 1 为行, 表达式 2 为列
若二维数组的所有元素都初始化数值或分行初始化数值时, 第一维度可以为空, 第二维度不能省略
如: int a[][2] = {{1,2},{3,4}} ;
3. 多维数组
不存在多位数组, 因为内存是线性一维的; n 为数组可以当作每个元素是 n-1 维数组的一维数组
4. 字符数组的定义和使用
数组元素在使用时, 仅看作字符类型的变量
(1)字符数组的元素用 %c 格式进行输入输出
(2)字符数组元素可以和其他元素一样处理
(3)未被初始化的元素将被赋值为 0, 即字符 '\0'
5. 字符串数组
字符串依次存放在字符数组中, 在有效字符的后面以'\0'作为结束标志
- char a[] = {"i am"} ;
- char a[] = "i am" ;
(1)使用 %s 进行输入字符串
(2)使用 gets 和 puts 输入输出 gets(s1) gets(2)
6. 字符串处理函数 string.h
(1)strlen(字符串)
用于计算字符串的有效字符的长度
(2)strupr(字符串) 小写变大写
strlur(字符串) 大写变小写 都返回字符串的首地址
(3)strcpy(字符串 1, 字符串 2)
将字符串 2 中的所有字符复制到 1 中, 返回 1 的首地址
1 的长度必须超过 2,2 可以是常量字符, 也可以是字符数组中存放的字符串
(4)strcat(字符数组 1, 字符数组 2)
将 2 连在 1 之后, 并保存在 1 中, 返回 1 的首地址
1 的长度必须大于字符串 1 和 2 的长度之和;
2 可以是常量字符串, 也可以是字符数组中存放的字符串;
1 中的'\0'被删除, 然后连接 2
(5)strcmp(字符串 1, 字符串 2)
比较两个字符串大小. 从左到右依次比较, 知道出现不同字符或'\0'
若 1>2, 则返回值为正; = 返回值为 0;<返回值为负
----------------2016 年 11 月 5 日 23:14:51--------------------
函数是 C 的基本单位
1. 函数的定义
函数类型 <函数名> ([<形参表>])
{
声明部分;
执行语句部分;
}
(1)函数中不能再嵌套定义函数
(2)不论 return 语句返回值为何种类型, 都将自动转换为函数类型
(3)空函数什么都不做
2. 函数调用
函数定义后, 才能调用.
如果函数定义中有形参, 在调用时, 应传递实际参数
函数调用的一般形式:
<函数名> ([<实参表>])
(1)实参与形参的类型, 个数和位置应一一对应
(2)实参与形参的变量名可一致, 也可不一致
若函数写在主函数之后, 需加函数声明 声明时要';'
3. 参数的传递
函数传递的方向是单向传递; 实参和形参所占内存不同
如果实参列表包括了多个实参, 则执行顺序不确定(VC++ 中先右后左)
4. 函数返回值
(1)无论返回值为何种数据类型, 都将自动转换为函数类型
(2)函数类型可以省略, 默认为 int
(3)return 可以退出或结束函数
(4)一个函数有多个 return 语句, 执行哪一个则带回哪一个的返回值
(5)void 函数无返回值
5. 局部变量和全局变量
局部变量: 作用范围只在函数内部的变量, 函数内部定义
全局变量: 函数外部定义, 作用范围从定义位置到该文件结束
(1)若局部变量与全局变量名称相同, 则优先使用局部变量
(2)全局变量在全部执行过程中都占用内存
(3)尽量避免使用全局变量
6. 变量的存储类别和生存期
动态存储方式:(1)函数形式参数 (2)函数内部定义的变量 函数结束时, 释放空间
静态存储方式:(1)全局变量 (2)被 static 定义的局部变量 (静态存储变量默认为 0)
(1)auto: 默认, 现在没什么用了
(2)static: 声明静态局部变量(注意与 JAVA 中的不同)
(3)register: 将变量放入 cpu 内部的寄存器, 从而提高效率
(4)extern: 声明变量是定义在其他文件中的外部变量
静态存储方式定义的内容, 仅能在本函数使用么不能外部引用
7. 文件包含
- #include <stdio.h> : 标准方式(系统直接在存放 C 库函数文件的系统目录寻找)
- #include "stdio.h" : 先在当前目录寻找, 没有再按标准方式寻找
包含系统头文件, 通常用 <>
包含自己编写的文件, 通常用 ""
8. 条件编译: 希望程序中一部分语句只在满足一定条件时才能编译
(1)#ifdef 标识符 // 若标识符在之前已被宏定义过, 则编译 1
程序段 1
#else
程序段 2
- #endif
- (2)
- #ifnded 标识符 // 若标识符在之前没被宏定义过, 则编译 1
程序段 1
#else
程序段 2
- #endif
- (3)
- #if 表达式
程序段 1
#else
程序段 2
#endif
------------------2016 年 11 月 6 日 19:29:29----------------
1. 地址和指针
地址: 内存单元的编号
指针: 内存单元的地址
所以, 地址 == 指针
2. 变量的指针和指向变量的指针变量
变量的指针: 变量的地址
指针变量: 用于存放指针的变量
定义: 类型说明符 * 指针变量名 例: int *a;
与指针相关的运算符: (1) &: 取地址符
(2) * : 指针运算符(取得该指针的内容)
定义中的 * 仅是一个表示, 指出它后面的变量是指针变量
两个指针变量指向同一块连续空间中的不同存储单元, 则可以相减
指针变量只占 4 个字节
3. 数组的指针和指向数组的指针变量
数组名代表数组的首地址, 即第 0 号元素的地址 a == &a[0]
若 p = &a[0] 则 : p+i == a+i ==&a[i]
* 与 ++ 的优先级相同, 所以自右向左: *p++ == *(p++) *++p == *(++p)
4. 多维数组
a[i][j] == *(a[i]+j) == *(*(a+i)+j)
5. 字符串
字符串的表示形式:
(1)用字符数组从存放或处理字符串
char a[] = "I LOVE" ;
(2)用字符指针指向字符串
char *a = "I LOVE" ;
注意:(1)字符指针变量是一个变量, 用于存放字符串的首地址
字符串本身是存放在以该地址为首的一块连续的内存空间中
(2)对字符指针变量赋初值
(3)指针变量未取得确定地址时, 不要用
6. 指针与函数
函数名是函数所占内存的首地址, 也成为函数的指针
指向函数的指针变量:
类型说明符 (* 指针变量名)(函数参数列表);
例: int (*p)(int ,int )
调用: (* 指针变量名)(实参表)
例: int max(int x,int y)
- {.......}
- int main()
- {
- int (*p)(int ,int);
- p = max;
- int a,b,c;
- c = (*p)(a,b);
- .......
- }
函数指针变量进行算数运算符时无意义
指向函数的指针, 可作为函数参数
返回指针值的函数:
类型说明符 * 函数名 (形参表)
7. 指针数组和指向指针的指针
指针数组: 每一个元素都为指针类型
类型说明符 * 数组名[数组长度] int *a[6];
注: int (*p)[3] : P 表示一个指向二维数组的指针变量, 列数为 3
int *p[3] :P 表示一个指针数组, 有三个元素
指向指针的指针:
一个指针变量存放另一个指针变量的地址
类型说明符 ** 指针变量名
注:(1)char **p == char *(*p)
p 是指向一个字符指针变量的指针变量
(2)**p == *(*p)
*P 是取得 p 指向的指针变量,*(*p)取得其值
8. 动态内存分配
- int *p = (int *) malloc(seizeof(int)) ;
- free(p) ;
动态内存由程序员手动分配, 释放, 在堆中分配
静态内存由系统分配, 释放, 在栈中分配
calloc 函数: 一次可以分配 n 块连续空间
调用:(类型说明符 *)calloc(n,size)
区别: malloc 函数不能初始化所分配的内存空间, 但 calloc 可以
calloc 会将分配的内存空间中的每一位都初始化为 0
1. 文件: ASCII 码文件 (文本文件) 与二进制文件
缓冲文件系统与非缓冲文件系统(系统整体效率下降)
2. 文件的操作:
(1)用 fopen 函数打开文件
(2)进行读写操作
(3)用 fclose 函数关闭文件
3. 定义文件类型指针变量:
FILE * 变量名
来源: http://www.bubuko.com/infodetail-2551424.html