Linux（七）

结构体—位域/位段 (为了节省空间)

#include <stdio.h>
//1.定义一个日期的数据类型
typedef struct date
{
	//用一个变量的某几位来保存某个值 位域 /位段
	unsigned int year:11;//0---2048 //unsigned int (0----2^32-1)
	unsigned int month:4; //0--15
	unsigned int day:5; //0---31
}Date;
//2.定义一个学生的结构体数据类型
typedef struct student
{
	char name[20]; //姓名
	int height; //身高
	Date birDay; //出生日期
}Stu;

int main(void)
{
	//位域 优点:节省空间
	// 缺点:输入的时候不能使用scanf(),因为找不到首地址，只能用赋值
	printf("sizeof(Date)=%ld\n",sizeof(Date));
	printf("sizeof(Stu):%ld\n",sizeof(Stu));
	Stu s1={"zhangsan",178,{1998,8,8}};
	printf("%s %d
	%04d:%02d:%02d\n",s1.name,s1.height,s1.birDay.year,s1.birDay.month,s1.birDay.day
	);
return 0;
}

字节对齐:一次性分配多少个字节 (64/32)

基本数据类型对齐方式

结构体对齐方式:按照成员中最大的对齐方式

#pragma pack(2) 和默认的对齐方式取最小

共用体

如何定义共用体

union 共用体名
{
	成员列表;
}
union job
{
	char dept[20];
	int class;
};
//定义了一个共用体数据类型，该共用体数据类型的名字叫 union job

如何定义一个共用体的变量

//类型名 变量名;
union job j1;

大小端

什么是大端序和小端序

如何测试计算机是小端序还是大端序

枚举:定义常量的一种方式,为了让程序更加语义话

定义常量的方式
<1>.宏定义 #define N 20
<2>.const const int a=20;
a=30; error (只读变量，不能被修改)
<3>.枚举

定义一个枚举数据类型

enum 名字
{
	值1,值2
};

enum color
{
	RED,BLUE,GREEN,WHIRE,BLACK
};
//定义了一个枚举数据类型,该枚举数据类型的名字叫enum color
//enum color中的值默认从0开始,后面的值依次加1 #define RED 0

定义一个枚举变量

//类型名 变量名
enum color e1;
e1=RED;

#include <stdio.h>
//1.定义一个枚举数据类型
enum color
{
	RED,BLUE,GREEN,WHITE=100,BLACK
};
//枚举中的值默认从0开始,后面依次加1
//定义一个枚举数据类型，该数据类型的名字叫enum color
int main(void)
{
	//2.定义一个枚举变量
	//类型名 变量名
	enum color e1;
	e1=BLUE;
	printf("e1=%d\n",e1);
	return 0;
}

函数指针

//定义一个指向int的指针 int * pi
//定义一个指向char的指针 char * pc
//定义一个指向char的指针的指针 char ** ppc
//定义一个指向数组的指针,该数组是一个长度为5的int数组 int [5] int (*pArr)[5]

定义一个指向函数的指针

#include <stdio.h>
int add(int num1,int num2)
{
	return num1+num2;
}
int sub(int num1,int num2)
{
	return num1-num2;
}
int mul(int num1,int num2)
{
	return num1*num2;
}
int div(int num1,int num2)
{
	return num1/num2;
}
int main(void)
{
	//定义一个指向数组的指针，该数组是一个长度为5的int数组
	// int [5]
	int ( *pArr) [5];
	//函数的数据类型 返回值类型 (形参列表)
	// int (int,int)
	//1.定义一个指向函数的指针
	int (*pFun) (int,int)=NULL;
	//pFun=//函数的首地址 &+函数的名字
	//pFun=&add; //add<====>*pFun
	//为了简化操作，函数名代替了函数的首地址
	pFun=add;
	printf("add=%d\n",add(12,3));
	//函数指针去调用
	printf("add=%d\n",(*pFun)(12,3));
	printf("add=%d\n",pFun(12,3));
	return 0;
}

定义一个函数指针数组

#include <stdio.h>
int add(int num1,int num2)
{
	return num1+num2;
}
int sub(int num1,int num2)
{
	return num1-num2;
}
int mul(int num1,int num2)
{
	return num1*num2;
}
int div(int num1,int num2)
{
	return num1/num2;
}
int main(void)
{
	//函数的数据类型 返回值类型 (形参列表)
	// int (int,int)
	//1.定义一个指向函数的指针变量
	int (*pFun) (int,int)=NULL;
	//int a;
	//为了简化操作，函数名代替了函数的首地址
	pFun=add;
	printf("add=%d\n",pFun(12,3));
	//2.定义一个函数指针数组,该数组中有4个元素,每个元素是一个指向函数的指针 int
	arr[4]={12,34,56,78}
	int (*pFunArr[4]) (int,int)={add,sub,mul,div};
	//add <---> pFunArr[0]
	int i=0;
	for(i=0;i<4;i++)
	{
		printf("%d ",pFunArr[i](12,3));
	}
	printf("\n");
	return 0;
}

函数指针作为函数的参数

#include <stdio.h>
int add(int num1,int num2)
{
	return num1+num2;
}
int sub(int num1,int num2)
{
	return num1-num2;
}
int mul(int num1,int num2)
{
	return num1*num2;
}
int div(int num1,int num2)
{
	return num1/num2;
}
//编写一子函数,实现两个整数的相关运算
//参数1: 函数的指针 int (*)(int,int ) 函数的类型int (int ,int)
//参数2: int num1
//参数3: int num2
//返回值:运算的结果
int cal(int (*pfun)(int,int),int num1,int num2)
{
	return pfun(num1,num2);
}
int main(void)
{
	printf("%d ",cal(add,12,3)); //+
	printf("%d ",cal(sub,12,3)); //-
	printf("%d ",cal(mul,12,3)); //*
	printf("%d \n",cal(div,12,3)); //(/)
	return 0;
}

给函数指针取了别名

typedef struct student Stu; //struct student ------>Stu

#include <stdio.h>
int add(int num1,int num2)
{
	return num1+num2;
}
int sub(int num1,int num2)
{
	return num1-num2;
}
int mul(int num1,int num2)
{
	return num1*num2;
}
int div(int num1,int num2)
{
	return num1/num2;
}
//1.给函数指针取了别名
typedef int (*pFun)(int,int); //int (*) (int,int) --->pFun 类型名
//4.函数指针作为参数传参
//参数1:函数的指针
//参数2: int num1
//参数3: int num2
//返回值:int
int cal(pFun pf,int num1,int num2)
{
	return pf(num1,num2);
}
int main(void)
{
	//2.定义一个函数指针变量
	pFun pf=add;
	printf("%d\n",pf(12,3));
	//3.定义一个函数指针数组
	pFun pfunArr[4]={add,sub,mul,div};
	int i=0;
	for(i=0;i<4;i++)
	{
		printf("%d ",pfunArr[i](12,3));
	}
	printf("\n");
	printf("%d ",cal(add,12,3));
	printf("%d ",cal(sub,12,3));
	printf("%d ",cal(mul,12,3));
	printf("%d \n",cal(div,12,3));
	return 0;
}

指针函数

定义：返回值是指针的函数

<存储类型>  数据类型  函数名（参数列表）
    		int*    add（）

int* add(int a, int b)
{
    int *p = NULL;
    return p;
}

调用：

int* res = add(a, b);

使用NULL时，必须引用stdio.h头文件

堆区的使用

定义在自定义函数中的变量会随着程序的结束而释放，如果我们想得到变量的值，必须使用静态的变量。

但是这样会导致内存无法及时释放，资源占用大。所以引出堆区空间的使用。

堆区：程序员自己申请自己释放的一片的空间。

申请空间

<1> 函数原型

#include <stdlib.h>
void* malloc(size_t size);

<2> 函数参数

size_t size
size_t————>unsigned int
ssize_t————>signed int
size————>申请空间大小（字节）

<3>函数返回值

void* 类型的指针————>万能指针
成功返回：申请到（开辟）空间的首地址
失败返回：NULL

<4>函数调用

int* malloc_func()
{
    int* ptr = (int*)malloc(sizeof(int));
	if(ptr == NULL)
	{
 		printf("申请失败\n");   
	}
	return ptr;
}
int main()
{
    int* pr = malloc_func();
}

递归

存储类型

static extern auto register

auto 自动的

//类型名 变量名
// 存储类型 类型名 变量名
auto

register 寄存器 (CPU中的存储器)

register int i=10;

static 静态的

修饰全局变量 (隐藏)

修饰函数 （隐藏)

修饰局部变量

extern 外部的

修饰全局变量,表示引入外部变量

extern修饰函数