C 编程总结
C 编程基础
选择变量标准：够用就好，不是越大越好
int x;占用两个字节
long y; 占4个字节的空间
短整型常量：-32768~32767 认为它是int型，它可以赋值给int型和long int类型
长整型：long int
如果某一计算机的C版本确定的short int 与int 型数据在内存中占据的长度相同，则它的表示范围与int相同。因此一个
int型的常量也同时是一个short int 型的常量，可以赋值给int型或short int 型变量
常量中无 unsigned型，但是一个非负值的整常量可以赋给unsigned型的整常量，只要它的范围不超过变量的表示范围。
长整型常量：数据后加一个l或L
例子：
main()
{
int x;
x=10*9*8*7*4*....*1;
printf("%d",x);
}
Linux下可以正常运行，windows出现溢出。
int 换成long int ,%d换成%ld 结果会如何？
单精度float:内存占4个字节 有效数字：6~7
双精度double:内存8个字节 有效数字：15~16
long double ：内存16个字节 有效数字：18~19
用sizeof来判断当前数据类型所占用的内存空间，不同系统所占用的空间不同
字符变量：字符变量用来存放字符常量，注意一个字符变量只能存放一个字符，用一个字节来存放一个字符，如 char
name='a'; name='\034'; ASCII码 name='\n'; name='\x65';c=65;c=0101;c=0x41;
int a=1,b=2;定义变量并初始化。
数组：在内存分配若干连续空间给数组 a[n] n必须为常量表达式
a[5]={0,1,2,3,4};
static int a[]={1,2,3};
static 型数组不进行初始化时，如果是数值类型数值默认为0，如果是字符型数组默认为空字符'\0'(ASCII为0的字符）
auto 型数组不进行初始化时，编译器不为其自动指定初始值。其初始值为系统分配给数组各元素的内存单元原来的值，这
个值是不可预知的。
二维数组：元素在内存排列顺序为按行存放。
a[2][3] 表示有两个一维数组 ，每个数组长度为3. a[0][0] a[0][1] a[0][2]
分行初始化： static int a[3][4]={{1,2,3,4},{...},{...},{...}}数组的数组，一行行赋值
字符串处理函数
#include"string.h"
char * strcpy(char *dest,const char *src); 字符串拷贝，从前往后复制。将src赋值到字符数组dest，返回被复制的
字符串
src可以是字符数组名，字符串常量或字符指针变量。
若dest字符指针变量，要给该指针变量赋初值。dest应该用数组名，不用&取地址
例子：
static char a[10]="abcdefghi";
b[]="happy"; strcpy(a,b); 内存情况happy\0ghi\0
用printf输出的时候,碰到\0则表示字符串结束，则为happy
字符串长度函数 unsigned int strlen(const char *str) 字符串实际长度，不包括'\0';
char s1[5];
gets(s1);//从键盘获取字符串
函数默认返回整型
1)auto型：有形式参数、函数内变量、分程序变量，进入程序自动分配内存，不长期占用内存
2）static 长期占用内存 分全局静态和局部静态
3)register:使用频率高的变量定义为register型，可以提高运行速度
4)extern:引用 extern 类型 变量名； 如果某一个模块要用到另外一个模块 文件的全局变量，要用extern说明
指针的用法(重点和难点）
1.数据在内存中的存储方式：
按数据类型给在内存为其分配一定数量的存储单元(字节)；
2.内存单元的地址
内存单元的编号，与变量名对应
int a,b; char c; float x; a,b为内存空间的外号
4.变量的”直接访问“方式
按变量的地址（即变量名）存取变量值的方式。
5.变量的间接访问
将变量的地址放在另一个内存单元，先到另一个内存单元中取得变量的地址，再由
变量的地址找到变量并进行数据存取。
int i;
int *pointer=&i;
变量pointer为指针变量，存放的是变量i的内存地址，我们说pointer指向i
6.指针的概念
一个变量的地址称为该变量的指针
7.指针变量
专门用于存储其他变量地址的变量。
指针与指针变量的区别，就是变量值与变量的区别。
指针变量的值：另一个变量在内存当中的地址
指针变量的类型：和所指变量的类型一致。
指针变量的名字：名字和普通变量相同
指针变量的赋值：指针变量名=&变量名 &为取地址符
方式二： 指针变量=另一个指针变量
对指针进行自加，根据数据类型进行移动
int *p int 占两个字节空间，p++移动两个字节
数组的名字就是一个指针变量，指向数组的首地址
指针的指针
指向指针变量的指针
定义形式：类型 **变量名
变量名为指针的指针，指向另外一个指针
例如：int i,*p,**q;
i=30;
p=&i;
q=&p;
指针与函数
1）指针做函数的参数(*) 传值调用：形参变化，实参不受影响。 传引用调用：实参和形参都变化
2)指针函数 （返回类型为指针类型）
返回值是指针类型的函数，称为指针函数。
定义形式： 类型标识符 *函数名(参数表)
int *a(int x,float y); a 是函数名，调用它后得到一个指向整型数据的指针
3）指向函数的指针（函数在内存也有块地址，通过指针来引用函数，指向函数的首地址）
函数名代表函数的入口地址
定义方式：类型 （*指针变量名)();
eg:int (*p)();
int max(){};
int (*p)();
p=max; 使用是使p指向max函数的入口地址，可以通过(*p)(参数）来调用max函数。
指针与数组
1）指向一维数组的指针
定义：类型 *指针变量名
数组名代表数组的首地址
指向数组元素的指针变量的赋值；指针变量=数组某一元素的地址；
eg:int a[10],*p;
p=a; 或p=&a[0]; 两者结果一样 a+1或p+1指向第二个元素。
a+9或p+9指向第10个元素，不仅仅移动一个位置，是移动一个数组元素的位置
或p=&a[4];
p=p+1;新p指向数组的下一个元素。 意味着p比原来的P的地址多d个字节（d为一个数组元素所占的字节数）
引用一个数组元素：a[i]形式； 指针法：*(a+i)或*(p+i);(重点和难点）
p++合法，但是a++不合法(a是数组名，代表数组的首地址，是常数地址）
要注意指针变量的当前值
x=*p++;（尽量少出现这种形式）
*与++是同级运算，等价于先计算*p,为x赋值a[0];p在自增1，指向下一个元素a[1];
*(p++)与*(++p);
*(p++)先取*p的值，后使p加1
*(++p)先使p加1，后取*p的值
（*p)++ 是内容加1,p不变
2）指向多维数组的指针
eg: int a[3][4],*p=a,*q=a[0];
表示形式 含义 地址
a,p 二维数组第0行首地址 2000
a[0],*(a+0),*a,q 第0行0列元素地址 2000
a+1,q+1 第1行首地址 2008
a[1],*(a+1),q[1] 第一行第0列地址 2008
a[i]+j,*(a+i)+j,
&a[i][j],p[i]+j,*(p+i)+j 第i行第j列地址
*(对应的地址) 第i行第j列的元素
3）指向字符串的指针
字符串的表示形式：
a.用字符数组实现： static char string[]="I Love China!";
b.用字符指针实现： char *p;
char *s="I Love China!";
例子：统计单词个数
#include<stdio.h>
#include<string.h>
main()
{
int stat(char *p);/*函数说明*/
char s[80];
int k;
printf("please input string:\n");
gets(s); /*输入一个字符串*/
k=stat(s); /*函数调用*/
printf("%d\n",k);
}
int stat(char *p) /*函数定义*/
{
int i,k,word;
for(i=0,word=0,k=0;*(p+i)!='\0';i++)
if(*(p+i)==' ') /*遇到了空格*/
word=0; /*处于非单词状态*/
else if(word==0) /*遇到了单词的第一个字母*/
{
k++;
word=1;
}
return(k);
}
范例：
1.输出变量的地址
int a=0;
printf("%x\n",&a);
2.指针变量的截断
main()
{
int a=0x12345678;
short *b=NULL;
b=&a;
printf("a=%x,*b=%x,&a=%x,b=%x",a,*b,&a,b);
}
输出结果：a=12345678,*b=5678,&a=13ff7c,b=13ff7c
a的值低位存在低地址，高位存在高地址，计算从低位开始读。
示意图： &a的地址，连续占4个字节 13ff7c 78 存一个字节
13ff7d 56 存一个字节
13ff7e 34 存一个字节
13ff7f 12 存一个字节
从低位往高位读，b=&a,b为short型，它占两个字节，故取前两位
3.强制类型转换
*（int *)b 对short 型的b转换为int 型的b ,就可以得到正确结果
main()
{
int a=0x12345678;
short *b=NULL;
b=&a;
printf("a=%x,*b=%x,&a=%x,b=%x",a,*（int *)b,&a,b);
}
输出结果：a=12345678,*b=12345678,&a=13ff7c,b=13ff7c
4.指针自加1
main()
{
int a =0x12345678;
int *ap=NULL
short *b=NULL;
ap=&a;
b=(short *)ap;
b++;
printf("a=%x,*ap=%x,*b=%x,&a=%x,ap=%x,b=%x\n",a,*ap,*b,&a,ap,b);
}
输出结果：a=12345678,*ap=12345678,*b=1234,&a=13ff7c,ap=13ff7c,b=13ff7e
5.void 指针和空指针
short *b=NULL;
#define NULL ((void *)0)
void 型指针可以指向任何变量，但是，void指针不能做增减运算。
main()
{
void *a=NULL;
float b=0;
a=&b;
*a=*a+1; //不能修改值，因为不知道类型，不能进行字节对应，编译通不过
}
空指针为赋值为NULL的指针，NLL的定义为#define NULL ((void *)0)
printf("NULL=%d\n",NULL);输出为0
6.使用指针引用二维数组
short array[2][2];
*(*(array+1)+1)
数组指针
类型说明符 (*指针变量名)[长度]
类型说明符表示该指针变量所指向数组的数据类型，“*”表示定义的变量为指针类型
“长度”表示二维数组的列长度，即二维数组的列数
（* 指针变量名）两边的括号不能少
#include<stdio.h>
#define M 3
#define N 4
void main(void)
{
int i,j;
short array[M][N]={0,1,2,3,4,5,6,7,8,9,10,11};
short (*pst)[N]=NULL;
pst=array;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
printf("%4d ",*(*pst+j));
pst++;
}
printf("\n");
}
指针数组 int *parray[5];
指针数组可以指向二维数组
6.内存分配
指针与内存分配
int *p=NULL;
p=(int *)malloc(100);为指针P分配了一个长度为100字节的内存区域
用free(p)释放。
需要包含#include<malloc.h>或#include<stdlib.h>
1 #include<stdio.h>
2 #include<malloc.h>
3 void main(void)
4 {
5 char *p=NULL;
6 p=(char *)malloc(100);
7 p=p+5;//错误语法，不能改变
8 printf("please input your string:");
9 scanf("%s",p); //遇到空格停止读入
gets(p);//按回车停止读入，在linux下会出现警告提示
10 printf("your input is :%s\n",p);
free(p);
p=NULL;//记住这条，保护性赋值
11 }
结构体和共用体
结构：将不同数据类型、但相互关联的一组数据，组合成一个有机整体使用，C语言提供一种称为“结构”的数据结构。
定义结构体：
struct 结构体类型名
{
类型标识符 成员名1；
类型标识符 成员2；
}；分号不能少
struct student
{
;
定义结构体类型变量的定义
形式：struct 结构体名 结构体变量名表
eg:struct student stu1,stu2;
或 struct student
{
}student1,student2;
结构体可以嵌套。
共用体
使几个不同的变量占用同一段的内存空间的结构称为共用型，一种特殊的结构体
定义：
union 共用类型名
{成员列表；}；
共用变量的定义--与结构体变量的定义类似
1）间接定义；先定义类型，再定义变量。
union [data] {int i; //data可以省略
char ch;
float f;}un1,un2,un3;
共用体变量占用的内存空间等于最长成员的长度，而不是各个成员长度之和。
特点
1)系统采用覆盖技术，实现共用变量各成员内存共享，所以在某一时刻，存放的和起作用的是最后一次
存入的成员值。
2）由于所有成员共享一内存空间，故共用体变量与其各成员的地址相同。不能对共用变量进行初始化。
枚举型
枚举型的定义： enum 枚举类型名{取值表};
eg:enum weekdays {sum,Mon,Tue,Wed,Thu,Fri,Sat};
枚举变量的定义：与结构变量类似
a.间接定义：enum weekdays workday;
b.直接定义:enum [weekdays]{sum,Mon,Tue,...Sat}workday;
说明：枚举仅仅适用于取值有限的数据。取值表中的值称为枚举元素，其含义由程序解释。
枚举元素作为常量是有值的：定义时的顺序号（从0开始），所以枚举元素可以进行比较，比较规则是：
序号大者为大。
用type定义类型
可以使用typedef定义已有类型的别名。该别名与标准类型名一样
定义已有类型别名的方法如下：
1）按定义变量的方法，写出定义体 float f;
2）按变量名换成别名 float REAL;
3）在定义体最前面加上typedef, typedef float REAL;
Example :给如下所示的结构体类型struct date定义一个别名DATE；
struct date{int year,month,day;};
在定义体最前面加上typedef: 如：typedef struct date{} DATE;
typedef与#define 有相似之处，但是两者是不同的：前者是由编译器在编译时处理的，后者由编译预
处理器在编译预处理时处理的，而且只能作简单的字符串替换
位段结构
有时候 存储1个信息不必占用一个字节，只需二进制的1（或多个）位就够。如果仍用结构体类型，则造成空间的浪
费。
需要使用位段类型。
1.位段的概念与定义
是一种特殊的结构类型，其所有成员均以二进制位为单位定义长度，并称为成员位段。
例如CPU的状态寄存器，按位段定义：
struct status
{
unsigned sign: 1;/*符号标志*/
unisgned zero: 1;/*零标志*/
unsigned carry: 1;
unsigned parity: 1;
unsigned : 0; /*长度为0的无名位段*/
unsigned parity: 1;
unsigned half_carry: 1;
unsigned negative: 1;
} flags;
原来6个标志位是连续存储在一个字节中的。由于加入了一个长度为0的无名位段，所以其后的3个位段，从下
一个字节开始存储，一共占用2个字节。
2.一个位段必须存储在一个存储单元中（通常为1字节），不能夸两个。如果本单元不够容纳某位段，则从下一个单元
开始存储该位段。
3.可以用%d,%x,%u,%o来格式字符，以整数形式输出位段。
4.在数值表达式中引用位段时，系统自动将位段转换为整型数。
预处理命令
1)执行宏定义(宏替换）
定义： #define 宏名 串（宏体）
如： #define PI 3.14159
宏定义后，该程序中的宏名就代表了该字符串
说明：#undef终止宏定义的作用域； #undef PI;
宏定义的嵌套
#define R 3.0
#define PI 3.14159
#define L 2*PI*R
带参数的宏定义：
#define 宏名（ 参数列表） 字符串
#define S(a,b) a*b
宏体中的形参按从左到右的顺序被实参替换
引用宏只占编译时间，不占运行时间
#define squ(n) n*n
main()
{
printf("%f\n",27.0/squ(3.0));
}程序输出结果为：27.00000
类似于：27.0/3.0*3.0 仅仅进行字符串的替换
2）包含文件#include
一个源文件可以将另一个源文件的全部内容包含进来
#include命令有两种格式：
a.#include<文件名>
包含标准头文件(/usr/include下的）
b.#include "文件名"
包含自定义的头文件（在当前目录）
3）条件编译
可以用于调试。
a.控制条件为常量表达式的条件编译
#if 常量表达式 为真的时候编译，否则程序段不编译
程序段
#endif
比写if条件进行判断要好，生成的二进制文件要小点
#if 常量表达式
程序段1
#else
程序段2
#endif
b.形式二
#ifdef 标识符
程序段
#endif
当标识符在该条件编译结构前已定义时，程序被编译。
#ifdef 标识符
程序段1
#else
程序段2
#endif
形式三：
#ifndef
程序段1
#else
程序段2
#endif