//将unsigned int 重命名为un_t, 所以un_t也是一个类型名
typedef unsigned int un_t;
int main()
{
   //观察num1和num2,这两个变量的类型是一样的
   unsigned int num1 = 0;
   un_t num2 = 0;
   return 0;
}

寄存器关键字-register

如果有一个变量频繁的去访问，就可以建议放到寄存器中

int main()
{
	int a = 10;
	register int b = 5;//建议将5放在寄存器中，放不放取决于编译器
	return 0;
}

static关键字

static修饰局部变量

局部变量变成了静态的局部变量，进作用域的时候在，出作用域的时候不会销毁，保留了上一次的值。

因为：static修饰的局部变量是存储在静态区的。

本质是改变了变量的存储位置。

void test()
{
    static int a=1;//a是一个静态的局部变量 
	a++;
	printf("a=%d\n",a);
}
int main()
{
	int i=0;
	while(i<5)
	{
		test();
		i++;
	}
	return 0;
}

void test()
{
    int a=1;//a是一个静态的局部变量 
	a++;
	printf("a=%d\n",a);
int main()
{
	int i=0;
	while(i<5)
	{
		test();	
		i++;
	}
	return 0;
}

static修饰全局变量

一个全局变量本来是具有外部链接属性的，但是被static修饰后外部链接属性就变成了内部链接属性，只能在自己所在的源文件内部使用，不能在其他文件内部使用了。

缩小了作用域

static修饰函数

和修饰全局变量一样

#define 定义常量和宏

#define 定义常量

#define MAX 1000
#define STR "hello bit"

int main()
{
	int m = MAX;
	printf("%d\n", m);
	printf("%s\n", STR);
	return 0;
}

#define 定义宏

#define MAX(x,y) (x) > (y) ? (x) : (y) 
int main() 
{
	int a = 10;
	int b = 20;
	int m = MAX(a, b);
	printf("较大值:%d\n", m);
	return 0;
}

只是简单替换,和函数是不一样的

#define FUN(x,y) (x)>(y)?(x):(y)
void main()
{
	int i = 10, j = 15,k;
	k = 10 * FUN(i, j);
	printf("%d\n", k);
	k = 10 * 10 > 15 ? 10 : 15;
	printf("%d\n", k);
}

这两种写法是一样的。最后的结果都是10。

指针

想要玩明白指针,先要搞明白什么是内存,内存在电脑是怎么分配的

内存

计算机中程序的运行都是在内存中进行的。所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

变量的地址

我们定义变量，调用函数，都是在向内存中申请一块空间进行操作，内存中的地址就是我们宿舍的门牌号，只要找到门牌号就可以找到你。同样的，只要找到这个变量的地址，就能对这个变量进行操作。

我们怎么找到变量的地址呢？这就不得不提到3个操作符 & [ ] *

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int num = 2;
	printf("num1=%d\n", num);
	int* pa = &num;
	*pa = 5;
	printf("num2=%d\n", num);
	return 0;
}

这里的&地址代表拿到变量的地址；*代表根据地址找到变量进行一次解引用, 找变量的内容进行操作。

指针变量的大小

指针变量的大小取决于编译器环境的大小，32位环境下指针的大小是四个字节，地址的编号是八位的十六进制序列，64位环境的大小是八个字节，地址的编号是十六位的十六进制序列。

结构体

如果遇到一个变量有多个信息，就要用到结构体。它可以用来描述一个复杂对象。比如：一个人（姓名+性别+年龄）

结构体不同成员之间的类型可以相同，也可以不同，和数组的区别在于，数组是同类元素的集合，而结构体是异类元素的集合。

结构体类型的声明和初始化

struct student
{
	char name[20];//名字
	int age; //年龄
	char sex[5]; //性别
};

只是单纯的结构体声明

int main()
{
	struct student s;
	struct student s1 = { "张三",20,"男" };
	return 0;
}

/*这里的student叫做结构名，struct student叫做类型名,{ }中声明的name，age，sex称为结构体成员,下面的s和s1称为结构体变量。*/

这里的s和s1都是局部变量 ,而你想使用全局变量的时候,也可以像下面这样

struct student
{
	char name[20];//名字
	int age; //年龄
	char sex[5]; //性别
}s;

struct student
{
	char name[20];//名字
	int age; //年龄
	char sex[5]; //性别
}s1,s2,s3;

由于类型名太长，就以重可命名，就要用到typedef。

typedef struct student
{
	char name[20];//名字
	int age; //年龄
	char sex[5]; //性别
}stu;

int main()
{
	stu s2 = { "张三",20,"男" };;
	struct student s3 = { "张三",20,"男" };
	return 0;
}

stu就是struct student的别名

结构体成员的访问

typedef struct student
{
	char name[20];//名字
	int age; //年龄
	char sex[5]; //性别
}stu;
int main()
{
	stu s2;
	struct student s3;
	s2 = { "张三",20,"男" };
	s3 = { "张三",20,"男" };
	return 0;
}

像上面s2,s3这样,修改结构体成员信息的方法是不对的

结构体成员访问需要借助两个操作符 . ->

#include<stdio.h>

typedef struct Student
{
	int age;
	char name[10];
}Stu;

int main()
{
	struct Stu s = { 20,"张三" };
	printf("%d %s\n", s.age, s.name);
	struct Stu* ps = &s;
    ps->age = 22;
    ps->name = "李四";
	printf("%d %s\n", ps->age, ps->name);
    return 0;
}

. 是对结构体变量进行操作，而->是对结构体指针进行操作

下期再见。

初识C语言(3) - 关键字，#define，指针，结构体

常见关键字

unsigned 关键字

typedef关键字