一、课前准备

1.Linux和unbutu安装

微信关注 软件管家 公众号->回复Linux->点击虚拟安装Linux系统教程

2.虚拟机联网

VMware虚拟机不能联网的解决办法

3.gcc和vim的安装及使用说明

首先按 :ctrl+shift+T 打开终端
输入sudo apt install gcc
接着输入Ubuntu密码（之前设置的密码）
就可以安装gcc啦

4.做一个简单的例程感受一下吧

（1）首先创建一个vim吧（vim可以理解为一个word文档编辑器）
vim这个编译器有许多快捷键，不掌握这些快捷键是很难完成编译的 vim入门教程
1.输入vim hello.c

2.进入vim后，按 a 进入编辑模式,输入下面的代码

#include<stdio.h>
#include<stdlib.h>

int main()
{
           
printf("Hello Wold!\n");
exit(0);
}

3.按 esc 键，退出编辑模式。再输入 ：qw保存并退出
4.终端输入 gcc hello.c -o hello 编译器会自动编译hello.c 并生成一个 hello文件

5.输入 ./hello 运行hello这个文件

看到Hello word！ 就算成功运行这个程序啦！
下面可以进入C语言的学习啦

二、数据类型

1.常量

(1) 整形常量：1，79
实型常量：3.14，1.999
字符常量:由单引号引起来的单个字符或转意字符’a’，’\n’，’\015’(八进制)
，’\x7f’（十六进制）

(2).字符串常量：由双引号引起来的一个或多个字符串组成的序列
如"",”a”,”asdXS\n\021”

(3)1标识常量（特点：处理在程序预处理阶段，一改全改，但不检查语法，只是单纯宏体与宏名替换）
a) #define PI 3.14（用宏体替换为宏名）
b) #define ADD 2+3(直接转换到上面)
c) #define MAX(a,b) (a>b?a:b)

(4). 什么时候用宏，什么时候用函数
答：节约时间用宏，保证稳定用函数

2.变量

定义：用来保存一些特定的内容，并且在程序执行过程中随时发生变化的量

1. 存储类型：auto static register extern(说明型)

a) auto:默认，自动分配空间，自动回收空间
b) register：（建议型）寄存器类型 只能定义局部变量，不能定义全局变量，只能定义32位大小的数据类型，寄存器没有地址，所以寄存器类型的变量无法打印出地址查看或使用 sush register int i=1
c) static：静态型，自动华初始值为0或NULL，并值其变量的值有继承性，仅能在局部使用。
d) extern：说明型，意味着不能改变被说明变量的值或类型

2.变量的生命周期和作用范围

a) 全局变量和局部变量
全局：从定义开始到程序结束
局部：从当前程序块开始，到程序块结束
b) 局部变量和局部变量
内部优先

3.运算符和表达式

运算符	符号
1.单目运算符	+、- 、 *、 \、 % 、 ++、 – 、 % 、/
关系运算符	< <= >= !=
逻辑运算符！	&&（有零取零） 异或（有1取1）
注意：短路特性 &&左边为0，
赋值运算符	= （a = 3 -> a = a3）
条件运算符	? :
逗号运算符
求字节数sizeof	例：printf(“%d\n”,sizeof(int));
强制类型转换	例：a=(int)f;
位运算的重要意义	硬件、电路很多都用位运算

移位操作 <<(右移)
  ~（取反）  
|（按位或，有1取1） 
 ^（按位异或，同值取零不同取一）
&（按位与，有零取零）

例:  将操作位中第n位置1 num=num | 1<<n
	将操作数中第n位清0，其他位不变：num=num&~(1<<n)
	测试第n定位：if(num & 1 <<n)
	从一个指定宽度中取出其中某几位？？？：段中取出几位	

三、输入、输出专题

1、格式化输入输出函数:scanf、printf
int printf(const char *format,)
format ："% [修饰符] 格式字符"，

输出格式	字符
十进制整数	%d
十六进制无符号整数	%x
八进制	%o
不带符号十进制整数	%u
单一字符	%c
字符串	%s
指数形式浮点数	%e
百分号本身	%%

修饰符	功能
m	输出数据宽度，数据长度<m,左补空格，否则按实际输出
.n	对实数，指定指定小数点后位（四舍五入）
.n	对字符串，指定实际输出位
-	输出数据左对齐（缺省右对齐）
+	指定在该符号数的整数正数前显示正号（+）
0	输出数值时指定左面不适用的空位自动添零
#	在八进制和16进制前显示前导0，0x
l	在d,o,x,u前指定输出精度为long型
l	在e，g，f前，指定输出精度为double型

printf和scanf的注意事项

printf("%s,%d\n",__FUNCTION__,__LINE__)

/* \n有强制刷新缓冲区的作用==查错时printf习惯性加\n 

scanf("%d",&i)
//%s慎用，超出会发生越界,因为不知道存储空间大小
scanf放在循环很危险,注意能否接收到正常有效的内容，输出加\n
一般情况输入什么你就里面写什么
scanf("")

2、字符串输入输出函数：getchar、putchar
getchar,回收字符,尤其时功能字符回车、空格等
3、字符串输入输出函数：gets（!）的、对缓冲区不做检查，puts
最好不用gets，用getline

四、流程控制

顺序、选择、循环
NS图，流程图 工具Dia
简单结构与复杂结构：自然流程

1. 顺序：语句逐句执行
2. 选择：出现一种以上情况
3. 循环：在某个条件成立的情况下，重复执行某个动作

关键字：
选择：if-else switch-case
循环：while do-while for if-goto
辅助控制：continue break

1.详解：if-else:

格式 if (exp)
cmd;
else if(exp)
cmd;
注意：else只找与它最近的if相匹配

2.详解 switch-case

语法格式：
switch(exp)
{
case 常量表达式：
break；
case 常量表达式
break；
…
default:
}
3.详解循环：while
while 最少循环0次
do-while 至少循环1次

4.for:(最少循环0次)

佛如（exp1;exp2;exp3）
loop;
if-goto:(慎用：go-to实现的是无条件的跳转，且不能跨函数跳转)

5.死循环：

while(1);
for( ; ; );
杀死死循环ctrl+c

6.辅助控制关键字： break continue

break跳出本层循环
continue跳出本次循环

选择循环练习题

（1）投资问题：以每年10%的单利息投资了100美元，B以每年5%的符合利息投资了100美元。编写一程序，计算要多少年B的投资总额会超过A的，并且显示出到那个时候两个人的各自总资产

（2）从终端读入数据，直到输入0值为止，计算出其中的偶数的个数及平均值和奇数的个数及平均值

（3）从终端输入若干字符，对其元音字母进行统计

（4）写出斐波那契数列的前40项（不能用数组实现）

1 1 2 3 5 8 13 21 。。。

（5）输出九九乘法表

（6）百钱买百鸡：鸡翁一，值钱5;鸡母一，值钱三；三鸡雏，值钱一，问鸡翁，鸡母，鸡雏各几何？

#include<stdio.h>
#include<stdlib.h>
static void text6(void)
{
    
	int x,y,z,s;
	for(x=0;x<20;x++)
	{
    
		for (y=0;y<100/3;y++)
		{
    
			z=100-x-y;
			s=5*x+3*y+z/3;
				if(s==100&&z%3==0)
				{
    
					printf("man=%d\twoman=%d\tchlidren=%d\n",x,y,z);
				}
		}
	}
}
int main()
{
           
	text6();
	exit(0);
}

（7）求出1000以内的水仙花数（各位数的立方和为数本身）如153=1+125+27

static void text7(void)
{
    
	int i;
	int a,b,c;
	for(i=100;i<1000;i++)
		{
    
			a=i/100;
			b=i%100/10;
			c=i%10;
			if(a*a*a+b*b*b+c*c*c==i)
       			 printf("The narcissistic number is:%d\n",i);
		}
}

（8）求出1000以内的所有质数：2，3，5，7，11，13，17，19…

static void text8(void)
{
    
	int i,j,mark;
	for(i=2;i<1000;i++)
	{
    
	        mark=1;
	        for(j=2;j<i/2;j++)
	        {
    
	                if(i%j==0)
	                {
    
	                        mark=0;
	                        break;
	                }
	        }
	        if (mark)
	                printf("The prime number is:%d\n",i);
	}
	return;
}

（9）在终端实现如下输出：

ABCDEF
BCDEF
CDEF
DEF
EF
F

static void text9(void)
{
    
	int line=6,chars=6;
	int i;
	char ch;
	for(i=0;i<line;i++)
	        {
    
	        for(ch='A';ch<'A'+chars;ch++)
	                {
    
	                printf("%c",ch);
	                }
	        printf("\n");
	        chars--;
	        }
}

（10）在终端输出钻石型

（11）之终端输入N个数（以字母Q/q作为终止），求和。

//注意：不只有输入q才会退出，只要输入不符合scanf的格式的都会退出
static void text11(void)
{
    
        int sum=0;
        int num;
        printf("Please enter the first integet(q to quit)");
        while(scanf("%d",&num)==1)
                {
    
                        if(num=='q')
                                break;
                        sum+=num;
                        printf("Please enter other intget:");
                }
                printf("sum=%d",sum);
}

（12）从半径为1开始，输出圆的面积，直到圆的面积为100截至

static void text12(void)
{
    
        int r=1;
        float area;
        for(area=1;area<=100;r++)
        {
    
                area=r*r*PI;
                if(area>100)
                        break;

                printf("area is %f\n",area);

        }

---

五、数组

1.一维数组

（1）定义

【存储类型】数据类型 标识符 【下标】
 特点：在内存中连续存放
 理解：就是一个变量，连续存放

（2）初始化

部分元素初始化，初始化的函数该是多少就是多少，其他数为零
数组不能无条件出现在等号左边

（3）元素引用

数组名 【下标】

（4）数组名

	数组名是表示地址的常量

（5）数组越界

数组越界不检查。靠程序员自身敏感程度

数组学习代码

#include<stdio.h>
#include<stdlib.h>
#define M 3
int main()
{
    
        int i;
        int arr[M];
        printf("%ld\n",sizeof(arr));
        for(i=0;i<M;i++)
                printf("%p-->%d\n",&arr[i],arr[i]);
        exit(0);
}

1.斐波那契数列

#include<stdio.h>
#include<stdlib.h>
#define a 10
int main()
{
    
        int i;
        int arr[a]={
    1,1};
        for(i=2;i<10;i++)
                arr[i]=arr[i-1]+arr[i-2];
        for(i=0;i<10;i++)
                printf("%d ",arr[i]);
        exit(0);
}

2.数据排序:
冒泡，每次只判断一个数，比大小，朝前或朝后移动(小数慢慢浮起来，大数沉下去慢慢)

#include<stdio.h>
#include<stdlib.h>
#define N 10
static void sort1(void)
{
    
        int i,j,tmp;
        int a[N]={
    45,48,24,46,68,48,24,33,1,2};
        for(i=0;i<N;i++)
                printf("%d ",a[i]);
        printf("\n");
        for(i=0;i<(N);i++)
        {
    
                for(j=0;j<(N-i);j++)
                {
    
                        if(a[j]>a[j+1])
                        {
    
                                tmp=a[j];
                                a[j]=a[j+1];
                                a[j+1]=tmp;
                        }
                          }
        }
        for (i=0;i<N;i++)
                printf("%d ",a[i]);
        printf("\n");
}
int main()
{
    
        sort1();

}

选择法，快速排序（一个数据串中，找到最小的放在第一位）

3.进制转换、

//最后一个for循环有问题，一直没改对
static void base_convert(void)
{
    
        int i=0;
        int num,base,a[N];
        printf("Please enter the converted num:");
        scanf("%d",&num);
        printf("Please enter the base:");
        scanf("%d",&base);
        do
        {
    
                a[i]=(num%base);
                num=num/base;
                printf("%d ",a[i]);
                i++;
                printf("i=%d",i);
        }while(num != 0);
        printf("\nB");
        printf("end i=%d",i);
for(;i>=0;i--)
        {
    
                printf("%d",a[i]);
        }
}

4.删数法求质数

2.二维数组

（1）定义

【存储类型】 数据类型 标识符 【行下标】 【列下标】
数组名即为数组起始位置
例：int M[2][3]   两行三列的数组 
在存储空间按行存放如:M[0][1] M[0][2] M[1][0] M[][1] M[0][1]
部分数组初始化：int a[3][3]={
   {1,2}{5,6}}
全部数组初始化：int a[3][3]={
   {1,2,3},{4,5,6},{7,8,9}}
定义可以行省略：例如：int a[][N]={4,8,45,65,8}

（2）元素引用

例：
1.行列互换

include<stdio.h>
#include<stdlib.h>
#define N 3
#define M 2
static void change(void)
{
    
        int i,j;
        int a[M][N]={
    1,2,3,4,5,6},b[N][M];
        for(i=0;i<M;i++)
        {
    
                for(j=0;j<N;j++)
                {
    
                        printf("%d",a[i][j]);
                        b[j][i]=a[i][j];
                }
                printf("\n");
        }
        for(i=0;i<N;i++)
        {
    
                for(j=0;j<M;j++)
                        printf("%d",b[i][j]);

                printf("\n");
        }
}
int main()
{
    
        change();
        exit(0);
}

2.求最大值及其所在位置

3.求各行与各列的和

static void sum(void)
{
    
        int i,j;
        int a[3][4]={
    {
    1,2,3},{
    4,5,6}};
        for(i=0;i<2;i++)
        {
    
                for(j=0;j<3;j++)
                {
    
                        a[2][3]+=a[i][j];
                        a[2][j]+=a[i][j];
                        a[i][3]+=a[i][j];
                        printf("%4d",a[i][j]);
                }
                printf("\n");
        }
        for(i=0;i<3;i++)
        {
    
                {
    
                        for(j=0;j<4;j++)
                                printf("%4d",a[i][j]);
                }
                printf("\n");
        }
}

4.矩阵乘积

（3）存储形式

在一块空间连续存储

（4）深入理解二维数组

二维数组，本质上是多个一维数组组成的
主要是理解行指针和列指针

3. 字符数组

1.定义，初始化，存储特点

【存储类型】 数据类型 标识符 【行下标】 【列下标】

2.单个字符初始化

	
输入语句：char str[N]={
    'a','b','c'};
输出语句：for(i=0;i<N;i++)
printf("%c,str[i]");

3.字符串常量初始化

	
int main()
{
    
	int N=3;
	char str[N];
	gets(str);
	puts(str);
}
上面这段代码很危险，虽然程序可以运行，但是如果输入超过2个字符
（系统会自动加一个尾零），之后的存储空间如果被保护过，则会发生段错误；

4.输入输出

scanf("%s",str);
printf("%s",str);
注意%s无法获得带分隔符的字符串

例如：
输入 hello word
输出为 hello

输入可以改为scanf("%s%s",str)来解决这个问题;

5.常用函数

为什么字符串有常用函数，而整形，浮点型等其他类型不需要函数呢

因为int等类型可以用if来比大小，也可以相互赋值，但是字符串的名字就是一个地址常量，没办法比较大小，赋值等操作，所以需要常用函数来解决这些问题

不能直接复制 例如： str=“abcde”,这个是不成立的
(1)strlen
作用：以尾零作为结束，显示当前字符串个数 （输入Hello word,返回值为5）

printf("%d\n",strlen(str))

(2)sizeof
作用：该字符串在内存所占字节个数 （输入Hello word,返回值为11）

printf("%d\n",sizeof(str));

(3)strcpy

用法strcpy(str,"abcde"); 作用：将abcde字符串copy到str中
puts(str);

（4）strncpy

用法：strncpy（str，“abcde”，STRSIZE）; 作用：将abcde字符串copy到
str中,但是STRSIZE会限制copy个数，防止溢出

（5）stract

 char *strcat(char *dest, const char *src);
 作用：将两个字符串首尾连接

（6） strncmp

int strcmp(const char *s1, const char *s2);
作用:比较ASCLL码大小，根据比较大小情况，返回值为1,0,-1

6.字符数组的单词计数

计算有多少字符串

#include <stdio.h>
#include<stdlib.h>
int main()
{
    
        char str[128];
        int flag=0,count =0;
        int i;
        gets (str);
        for (i=0;str[i]!='\0';i++)
        {
    
                if(str[i]==' ')
                        flag = 0;
                else if(flag==0)
                {
    
                        count++;
                        flag =1;
                }
        }
        printf("count=%d\n",count);
        exit(0);
}

4.多维数组

就是一维二维数组的递推
int a[2][3][4];

六、指针

1.变量与地址

变量名int i 这里的i是给程序员看到，i是一个抽象的地址

2.指针与指针变量

定义：[数据类型] *p=&i;
int *i=1；
int *p;
char *c
doubule *c
无论是什么类型的指针，所占字节数sizeof(c),均为8
虽然指针所占字节，指针变量和他所指类型的值，一定要相符

例子

#include <stdio.h>
#include<stdlib.h>
int main()
{
    
        int i=1;
        int *p;
        p=&i;
        printf("i=%d\n",i); 	//输出i的值
        printf("&i=%p\n",&i);	//i的地址
        printf("p=%p\n",p );	//p的值，存放的是i的地址
        printf("&p=%p\n",&p);	//	p的地址，一块独立的指针空间
        printf("*p=%p\n",*p);		//p所指的i中的内容
        exit(0);
}

3.直接访问与间接访问

	上图中：q=0x3000=&p
		    p=0x2000=&i
		   	i=1
		   	&q=0x4000
		   	*q=*(&p)=p=&i
		   	**q=*(&i)=i=1
	如果能理解上述关系，指针这里基本就没问题了	
	想访问i的值，可以通过i  *p  **q三种形式访问
	想访问i的地址，可以通过 &i  p  *q三种形式访问

4.空指针与野指针

指针定义：int *p =NULL （指针定义为NULL，是防止野指针的产生，如果你不清楚指向谁，就定义指针为NULL）
野指针是非常危险的，一定要让指针有去处

5.空类型

void *q=NULL （void类型的指针是一个万金油，它与任何指针类型都可以相互赋值）

6.定义与初始化的书写规则

int i=1：
int *p=&i
int **q =&i

7.指针与运算

指针的运算较少只有  &(取地址)  *(取值)  关系运算  ++  --

8.指针与数组

(1).指针与一维数组

#include <stdio.h>
#include<stdlib.h>
int main()
{
    
        int a[3]={
    1,2,3};
        int *p=a;
        int i;
        for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
        	printf("%d",a[i])
        printf("\n");
        exit(0);         
}

（1）a[i] = *(a+i) = *(p+i)= p[i]
a是数组名，是常量不可以做赋值变换，例如a++
但是p是一个指针，可以做赋值变换，p++
注意：p++和p+1的区别
学会数组常量和数组变量的区别

(2).指针与二维数组

在行上的指针和在列上的指针

#include<stdio.h>
#include<stdlib.h>
int main()
{
    
        int a[2][3]={
    1，2，3，4，5，6};
        int i,j;
        for()
        3
        printf("%ld\n",sizeof(arr));
        for(i=0;i<M;i++)
                printf("%p-->%d\n",&arr[i],arr[i]);
        exit(0);
}

(3).指针与字符数组

9.const与指针

这部分李老师讲的非常好，一听就懂

#define PI 3.14
const float PI=3.14
宏定义和const可以代替使用，区别是宏定义不做检测，const检查

（1）常量指针

用处，在封装一些函数时常用这种方式进行封装，因为其他人不可以通过指针来修改函数

const int *p
int const *p

int i=1；
const int *p =&i;
正确：  i=10;//可以
错误：*p=10;//不可以
作用：保护*p不变，*p是只读的

（2）指针常量

int *const p;
int i=1;
int j=10;
int *const p =&i;
正确：*p=10;//可以改p指向地址里的值
错误：p=&j;
作用：指针变量指的东西不变
fopen:拷贝一块内存数据

口诀：常量指针不可以该值，指针常量，不可以改指针
例如：定义 const int *const p = &i；此时既不能改变指针里的值，又不能改变指针的指向

10.指针数组与数组指针

（1）数组指针（一个指针，指向数组）

定义：【存储类型】 数据类型 （*指针名） 如：int [3] *p 
int main{
int a[2][3]={1,2,3,4,5,6};
int i,j;
int *p=*a;
int (*q)[3]=a;
for（)
}

（2)指针数组(n个指针挨在一起)

int *arr[3]={3，5，7}

11.多级指针

不常用

七、函数

1.函数的定义

数据类型 函数名【数据类型 形参名，数据类型 形参名。。。。。】
int (返回的数据类型)  arr  (int argc,char *argv[] )
return 0; （结束当前函数）

argc 是 argument count的缩写，表示传入main函数的参数个数；

argv 是 argument vector的缩写，表示传入main函数的参数序列或指针，并且第一 个参数argv[0]一定是程序的名称，并且包含了程序所在的完整路径，所以确切的说需要我们输入的main函数的参数个数应该是argc-1个；

2.函数的传参

include<stdio.h>
#include<stdlib.h>
int value(int a,int b)
{
    
        printf("%d %d\n",a,b);
        return 0;
}
int main()
{
    
        int i=3,j=5;
        value(i,j);
        return 0;
}

（1）值传递

用一个程序来解释值传递和地址传递的区别

#include<stdio.h>
#include<stdlib.h>
void swp(int i,int j)
{
    
        int tmp;
        tmp =i;
        i=j;
        j=tmp;
}
int main()
{
    
        int i=3,j=5;
        int tmp;
        swp(i,j);
        printf("%d\t%d\n",i,j);
        return 0;
}

此条语句输出还是i=3,j=5并没有起到交换i与j的作用，如下图，只是新开辟出一块地址，进行了交换，仅i，j名字是一样的，但根本不是一回事

（2）地址传递

void swp(int *p,int *q)
{
    
        int tmp;
        tmp =*p;
        *p=*q;
        *q=tmp;
}
int main()
{
    
        int i=3,j=5;
        int tmp;
        swp(&i,&j);
        printf("%d\t%d\n",i,j);
        return 0;
}

上面这个函数达到了交换数的目的，通过另外一个函数达到修改其他函数的目的，一般用地址传递

（3）全局变量

3.函数的调用

(1)嵌套调用

嵌套调用小例子：

#include<stdio.h>
#include<stdlib.h>
int max(int a,int b,int c)
{
    
        int tmp;
        tmp= a>b ? a:b;
        return tmp>c?tmp:c;
}
int min(int a,int b,int c)
{
    
        int tmp=a>b ? b:a;
        return tmp>c ? c:tmp;
}
int dist(int a,int b,int c)
{
    
        return max(a,b,c)-min(a,b,c);

}
int main()
{
    
        int res;
        int a=3,b=5,c=10;
        res = dist(a,b,c);
        printf("res=%d\n",res);
        return 0;
}

(2)递归

递归：一个函数，直接或间接调用自身
一个递归小程序：
FUNCTION:该函数的作用此时运行函数的函数名

#include<stdio.h>
#include<stdlib.h>
int b()
{
    
        printf("[%s]begin!\n",__FUNCTION__);
        printf("[%s]b()end!\n",__FUNCTION__);
        return 0;
}
int a()
{
    
        printf("[%s]begin!\n",__FUNCTION__);
        printf("[%s]call b()!\n",__FUNCTION__);
        b();
        printf("[%s]b() returned!\n",__FUNCTION__);
        printf("[%s]end!\n",__FUNCTION__);
        return 0;
}
int main()
{
    
        printf("[%s]begin!\n",__FUNCTION__);
        printf("[%s]call a()!\n",__FUNCTION__);
        a();
        printf("[%s]a() returned!\n",__FUNCTION__);
        printf("[%s]end!\n",__FUNCTION__);
        return 0;
}

例题：求一个数的阶乘

unc(int n)
{
    
        if (n==1||n==0)
                return 1;
        return  n*func(n-1);
}
int main()
{
    
        int n;
        int res;
        scanf("%d",&n);
        res =func(n);
        printf("n!=%d",res);
        return 0;
}

4.函数与数组

（1）函数与一维数组

#include<stdio.h>
#include<stdlib.h>
void print_arr (int *p)
{
    
int i;
printf("%s:%d\n",__FUNCTION__,sizeof(p));
}
int main()
{
    
int a[]={
    1,3,5,7,9};
printf("%s:%d\n",__FUNCTION__,sizeof(a));
print_arr(a);
exit(0);
}

（2）函数与二维数组

5.函数与指针

八、构造类型

1.结构体

（1）产生及意义

数组只能存储一种类型，结构体可以存储多种类型

（2）类型描述

struct 结构体名字
{
数据类型 成员1;
数据类型 成员2；
…

};
结构体定义在函数外（少数编译器不允许编译在函数内部）

（3）嵌套定义

定义方式一，分开定义

struct birthday_st
{
    
        int year;
        int month;
        int day;
};
struct student_st
{
    
        int id;
        char name[NAMESIZE];
        int year,month,day;
        int math;
        int chinese;
};

定义方式二，内部定义

struct birthday_st
{
    
        int year;
        int month;
        int day;
};
struct student_st
{
    
        int id;
        char name[NAMESIZE];
        struct birth
        int year,month,day;
        int math;
        int chinese;
};

（4）定义变量（变量，数组，指针），初始化及成员引用

int main()
{
strunct simp_st a={123,456.789,‘a’};
a.i=112233;
printf("%d %f %c\n",a.i,a.f,a.ch);
exit(0);

}

(5)占用内存空间大小