C语言联合、枚举、宏函数、结构体、函数

2015-06-23

共用体－－联合

union A//共用体

{

int x;

double y;

} A;

struct B//结构体 占16个字节 根据最大的来分。

{

int x;

double y;

} B;

//根据哪个数据类型多，然后保证数据够用原则，对齐原则。

printf("A=%lu\n",sizeof(A));／／8

printf("B=%lu\n",sizeof(B));//16

枚举－－－－－

enum关键词

enum A

{

x,

y,

z

};

enum A a;

a.x = 1;

a.y = 2;

printf(“z=%d”,a.z);

预处理指令－－－－－

#include预处理指令，可以理解为替换 . 宏替换

#define A 10 小规模替换，10替换为A 宏的值不可以修改。

宏函数

#define max(a,b) a > b?a:b

i = 1;

max(++i,++i); = 4;

++i>++i?++i:++i;//执行宏替换

#undef max 取消宏

#define A 10

#if A == 10

#else if A == 20

#else

#endif

#ifndef B//不存在B

#define B 10

#endif

#ifdef B//存在B

#endif

文件－－－－－－－－－

fprintf()和fscanf()处理文件

fwrite()和fread()处理二进制文件

FILE * pf = fopen("a.txt", "w”);//w 写文件 a追加写文件。

int id,score;

char name[20];

if (pf==NULL) {

printf("error\n");

}else{

for (int i = 0; i < 3; i++) {

printf("id=");

scanf("%d",&id);

printf("name=");

scanf("%s",name);

printf("score=");

scanf("%d",&score);

fprintf(pf, "%d\t%s\t%d\n",id,name,score);

}

}

－－－－文件读取

for (int i = 0; i < 3; i++) {

fscanf(pf, "%d\t%s\t%d\n",&id,name,&score);

printf("%d\t%s\t%d\n",id,name,score);

}

while (!feof(pf)) {

fscanf(pf, "%d\t%s\t%d\n",&id,name,&score);

printf("%d\t%s\t%d\n",id,name,score);

}

printf("%d\n\n",feof(pf));//feof为1是结束，0不结束。查找文件里面的条目数

二进制文件－－－－－－－

void f_write()

{

int a[5] = {111,222,333,444,555};

FILE *pf = fopen("a.bin", "wb");

if (pf == NULL) {

printf("error\n");

}else{

fwrite(a, sizeof(int), 5, pf);

fclose(pf);

}

}




void f_read()

{

int a[5]={0};

FILE *pf=fopen("a.bin", "rb");

if (pf == NULL) {

printf("error\n");

}else{

fread(a, sizeof(int), 5, pf);

}

for (int i = 0; i < 5; i++) {

printf("%d\t",a[i]);

}

fclose(pf);

}

-----------------------------

#include<string.h>

char str[100];

char * p=gets(str);

printf(“str=%s”,str );

二维字符数组－－－－－

char *p = “abcd” ;

char str[10];

printf(“p=%s”,p);

scanf(“%s”,str);

内存管理－－－－－

代码区

栈区

堆区（自由存储区）

静态存储区（全局区）

常数区

int * p = NULL;

p = malloc(4);//malloc 传入字节。

malloc(sizeof(int));

malloc

堆区内存没有变量名称的。

free(p);//释放p指向的堆区的内存。 不是释放栈区p的内存。

int *p = NULL;

long *pl=NULL;

p = malloc(sizeof(int));

pl = malloc(sizeof(long));

*p = 100;

*pl = 200;

printf("p=%d,pl=%ld\n",*p,*pl);// 100,200

free(p);

free(pl);

printf("p=%d,pl=%ld\n",*p,*pl);//0,200

free以后，p和pl指向的堆区内存，被标记为空闲内存，但是内存还在，如果使用的话，还是可以使用的，但是这种情况很危险，因为其他人也可以操作这个内存。

p = realloc(p,10);//对已分内存重新划分。原来的值不变

结构体－－－－－－－－

自定义数据类型

struct student

{

int id;

char name[20];

int math;

Date birthday;//结构体嵌套结构体

}p1,p2;//可直接定义 结构体变量

typedef｛｝ Date；／／定义别名

sizeof(p1);//所有字节相加。

结构体型的指针－－－－

struct student*p=&stu;//(*p).id,

p->id=p->id;指针结构体时需要用➡️访问。




-------------------------------

函数:

1.模块化 （函数），函数是C语言中最小的模块。

函数是一段用函数规范化形式表示并能够完成一定功能的代码。

函数包含：

函数头：返回类型，函数名称，参数列表

函数体：

（1）生产

（2）维护

int add(int a,int b)//int 返回值类型，add函数名称，int a,int b参数列表,是调用者向被调用者传递数据的接口。

{

int c = a+b;

return c;//返回值，被调用者向调用者传递数据的接口。

}//函数体

int z = add(2,4);//被调用者

void A();

int B(){return 0 ;};

参数可有可无。如果为void不需要return，如果有返回值类型，必须要有return返回值。

函数功能：1、使程序模块化 2、代码的复用

变量的作用域：

void a(int x,int y)//x,y也是内部变量

{

int z = 0；//内部变量

z = x+y;

printf(“z=%d\n”,z);

}

一、内部变量：在函数体内定义的变量叫做内部变量。也称作局部变量。

1.存储区域：栈区。

2.作用域：函数体内。

3.生命周期：函数运行过程。

C语言内存管理 分区管理，分5个区域，代码去，栈区，堆区，全局区，常数区。

代码区：程序执行先执行代码区。

栈区：内部变量存放在栈区。栈区内存自动管理。

堆区：内存管理为手动管理。

全局区域：存放全局变量。

常数区：存放常量。

内存两种状态：1.空闲状态。2.正在使用状态。

内存使用的步骤：1.申请内存。2.分配内存。3.使用内存。4.释放内存。

函数的运行过程:函数执行原理。

栈区；变量名 变量值 地址

m 0 0x1000

a 100 0x1004

b 200 0x1008

add函数栈区： 使用完后进行释放。操作系统回收。标记为空闲内存。

变量名 变量值 地址

x 100 0x2000

y 200 0x2004

z 300 0x2008

函数在代码区域。

二.外部变量：在函数外部定义的变量叫外部变量，也叫全局变量。

int n = 0;

int main……..

存储区域，全局区。

作用域，整个程序。

声明周期，整个程序。

int n = 1;

void A()

{

int q = 0;

++n;

++q;

printf(“n=%d,q=%d\n”,n,q );

}

void B()

{

int q = 0;

++n;

++q;

printf(“n=%d,q=%d\n”,n,q );

}

int main()

{

A();//N被累加。q程序内部变量。

A();

A();

return 0;

}

变量在外部定义后，在内部也可以定义同名变量。函数使用的是内部变量。

内部变量优先级高(前提是使用前要定义在这之前)。优先级，优先定义的级别，最近定义的优先使用。

如：

int a = 10;

void add() {

printf("a=%d\n",a);//a = 10

int a = 5;

printf("a=%d\n",a);// a = 5

}

三、块级变量：块级变量时在一个块中定义的变量。

1、存储区域：栈区

2、作用域：语句块内

3、生命周期：语句块内

int x = 1;

void A()

{

int x = 2;

if(1) { int x = 3; }／／块级变量

}

。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

预处理命令：

1.宏定义：

1.1. 不带参数宏定义

#define 标识符 字符串

#define PI 3.141526

#define R 3.0

#define L 2*PI*R

1.2.带参数宏定义

#define S(a,b) a*b

#define S(r) PI*(r)*(r)//r = a+b

2.“文件包含”处理：

#include “文件名”//自定义

#include <文件名>//系统

3.条件编译：

1.若标识符已经被#define定义过，则走程序段1

否则走程序段2

#ifdef 标识符

程序段1

#else

程序段2

#endif

2.

#ifdef 标识符

程序段1

#endif

3.若标识符没有被#define定义过，则走程序段1

#ifndef 标识符

程序段1

#else

程序段2

#endif

4.当表达式为真（非零）时，走程序段1，否则走程序段2

＃if 表达式

程序段1

#else

程序段2

#endif

——————————

新建aa的c file生成aa.h

#ifndef _________AA__

#define _________AA__

#include <stdio.h>

int add(int a,int b);

int sub(int a,int b);

#endif /* defined(_________AA__) */

//意思是；判断是否重复导入头文件，如果不存在则导入。

#ifndef判断是否存在_________AA__标志符，不存在则，新建一个_________AA__标志符，并且导入头文件。通过一个_________AA__来区分是否已经导入。