一、结构体介绍
结构体是自定义的一种类型，可以让程序结构更清晰

二、结构体定义

struct tag { 
    member-list
    member-list 
    member-list  
    ...
} variable-list ;

1、方式1，定义结构体并声明

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;

2、方式2，分开定义和声明

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} ；
struct Books book;

3、方式3，使用typedef

typedef struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book_def;
book_def book;

其中Books可以省略，如下

typedef struct
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book_def;
book_def book;

三、结构体的访问

book.id = 100;
printf("%d",book.id);
strcpy(book.title,"C Programming");
printf("%s",book.title);

四、结构体数组
1、定义

typedef struct
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book_def;
book_def book[10];

2、访问

book[0].id = 100;
printf("%d",book[0].id);
strcpy(book[1].title,"C Programming");
printf("%s",book[1].title);

3、直接传递

book[2] = book[1];

五、结构体指针
1、定义

typedef struct
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book_def;
book_def *pbook;
book_def book;

2、操作

pbook = &book;
(*pbook).id = 10;
pbook->id = 20;
strcpy((*book).title,"C Programming");
strcpy(book->title,"C Programming");

六、实例
需求：我们串口发送是一个字节一个字节的，我们制定的协议如下：
一阵协议10个字节，放于buff[10]
byte0 byte1 0x5555起始
byte2 value1
byte3 byte4 value2
byte5 byte6 byte7 byte8 value3
byte9 0xff 停止

常规方法解析：

char value1；
short value2；
int value3;
value1 = buff[2];
value2 = (buff[3] << 8) + buff[4] ;
value3 = (buff[5] << 24) + (buff[6] << 16) + (buff[7] << 8)+buff[8];
printf("%d",value1);
printf("%d",value2);
printf("%d",value3);

结构体方法解析：

typedef struct
{
	short start;
   char  value1;
   short  value2;
   int  value3;
   char stop;
} value_def;

value_def *pvalue;
pvalue = (pvalue *)buff;//强制转换地址类型再给地址到指针
printf("%d",pvalue->value1);
printf("%d",pvalue->value2);
printf("%d",pvalue->value3);

函数
实参：
真实传给函数的参数，可以是常量，变量，表达式，函数等。在进行函数调用时，它们必须有确定的值，以便把这些值传送给形参。
形参：
指函数名后括号中的变量，因形参只有在函数被调用的过程中才会实例化（分配内存单元），即形式参数。形参当函数调用完成之后就会自动销毁，也就是说形参只在函数中有效。
形参实例化之后其实相当于实参的一份临时拷贝。

函数调用：
传值调用:函数形参与实参分别占用不同内存块，对形参的修改不会影响实参。
传址调用：把函数外部创建变量的内存地址传递给函数参数的一种调用函数方式。

函数组成：
ret_type fun_name(para1,para2)//返回类型，函数名，函数参数
{
statement//函数体，语句项
}

函数独立性：
#include <stdio.h>
int Add(int x,int y)//定义一个加法函数
{
int z=0;
z=x+y;
return z;
}
int main()
{
int a=10;
int b=20;
int sum=Add(a,b);//调用函数
printf("%d\n",sum);
return 0;
}

库函数：
#include <stdio.h>
#include <string.h>
int main()
{
char arry1[]=“amy”;
char arry2[]=“111111111”;
strcpy(arry2,arry1);//字符串拷贝（库函数）,需要头文件<string.h>
printf("%s\n",arry2);//输出函数，需要头文件<stdio.h>
return 0;
}

两者取较大函数：
#include <stdio.h>
int get_max(int x,int y)//定义比较函数
{
if(x>y)
return x;
else
return y;

}
int main()
{
int a=10;
int b=20;
int max=get_max(a,b);//函数使用
printf(“max=%d\n”,max);
}

交换整形变量函数：
#include <stdio.h>
int main()
{
int a=10;
int b=20;
int tmp=0;
printf(“a=%d,b=%d\n”,a,b);
tmp=a;
a=b;
b=tmp;
printf(“a=%d,b=%d\n”,a,b);
return 0;
}
错误：

正确：

注意：Void 表示为空，无返回值

练习：
1.判断101-200之间有多少个素数，并输出所有素数。
分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，
　　　　　则表明此数不是素数，反之是素数。
#include <stdio.h>

int is_prime(int n)//是素数返回1，否则返回0
{
int j;
for(j=2;j<n;j++)
{
if(n%j==0)
return 0;
}
return 1;
}
int main()
{
int i,sum=0;
for(i=100;i<200;i++)//打印100-200之间的素数
{
if(is_prime(i)==1)//判断i是否为素数
{
printf("%5d\n",i);
sum+=1;
}
}
printf(“总计%d个素数”,sum);
}　　

2.判断1000-2000之间有多少个闰年，并输出所有闰年。
分析：判断闰年的方法,用该数除以4的余数为0且除以100不为0或除以400等于0即为闰年。
#include <stdio.h>
int is_leap_year(int y)//是闰年返回1，否则返回0
{
if(y%40 && y%100!=0||y%4000)
return 1;
}
int main()
{
int i,sum=0;
for(i=1000;i<=2000;i++)//打印1000-2000之间的闰年
{
if(is_leap_year(i)==1)//判断i是否为闰年
{
printf("%5d\n",i);
sum+=1;
}
}
printf(“总计%d个闰年”,sum);
return 0;
}

3.写一个函数，实现一个整形有序数组的二分查找。
#include <stdio.h>
int binary_search(int arr[],int k,int sz)
{
//算法实现
int left=0;
int right=sz-1;
while(left<=right)
{
int mid=(left+right)/2;//中间元素下标
if(arr[mid]<k)
{
left=mid+1;
}
else if(arr[mid]<k)
{
right=mid-1;
}
else
{
return mid;
}
}
return 0;
}
int main()
{
/二分查找，在一个有序数组里查找一个具体的数
若找到则返回这个数的下标，找不到返回-1/
int arr[]={1,2,3,4,5,6,7,8,9,10};
int k=7;
int sz=sizeof(arr)/sizeof(arr[0]);
int ret=binary_search(arr,k,sz);
if(ret==-1)
{
printf(“找不到指定的数字\n”);
}
else
{
printf(“找到喽，其下标是%d\n”,ret);
}
return 0;
}

4.写一个函数，每调用一次这个函数，就将num的值加1。
#include <stdio.h>
void Add(int* p)
{
(*p)++;
}
int main()
{
int num=0;
Add(&num);
printf(“num=%d\n”,num);
Add(&num);
printf(“num=%d\n”,num);
Add(&num);
printf(“num=%d\n”,num);
return 0;
}

函数嵌套调用：
#include <stdio.h>
void new_one()
{
printf(“世界真好！！！\n”);
}
void new_two()
{
int i=0;
for(i=0;i<5;i++)
{
new_one();
}
}
int main()
{
new_two();
return 0;
}

链式访问:
把一个函数的返回值作为另外一个函数的参数。
#include <stdio.h>
#include <string.h>
int main()
{
int len=0;
//1
len=strlen(“abc”);
printf("%d\n",len);
//2
printf("%d\n",strlen(“abc”));
return 0;
}

指针：
指针变量：存放变量地址，如 pa=&a;
变量类型：type*，如int* pa=&a;//指针变量pa的类型为整形
*pa=a;//解引用操作，即变量