memset
在前面不止一次说过，定义变量时一定要进行初始化，尤其是数组和结构体这种占用内存大的数据结构。在使用数组的时候经常因为没有初始化而产生“烫烫烫烫烫烫”这样的野值，俗称“乱码”。
每种类型的变量都有各自的初始化方法，memset() 函数可以说是初始化内存的“万能函数”，通常为新申请的内存进行初始化工作。它是直接操作内存空间，mem即“内存”（memory）的意思。该函数的原型为：
# include <string.h>
void *memset(void *s, int c, unsigned long n);
函数的功能是：将指针变量 s 所指向的前 n 字节的内存单元用一个“整数” c 替换，注意 c 是 int 型。s 是 void* 型的指针变量，所以它可以为任何类型的数据进行初始化。
memset() 的作用是在一段内存块中填充某个给定的值。因为它只能填充一个值，所以该函数的初始化为原始初始化，无法将变量初始化为程序中需要的数据。用memset初始化完后，后面程序中再向该内存空间中存放需要的数据。
memset 一般使用“0”初始化内存单元，而且通常是给数组或结构体进行初始化。一般的变量如 char、int、float、double 等类型的变量直接初始化即可，没有必要用 memset。如果用 memset 的话反而显得麻烦。
当然，数组也可以直接进行初始化，但 memset 是对较大的数组或结构体进行清零初始化的最快方法，因为它是直接对内存进行操作的。
这时有人会问：“字符串数组不是最好用’\0’进行初始化吗？那么可以用 memset 给字符串数组进行初始化吗？也就是说参数 c 可以赋值为’\0’吗？”
可以的。虽然参数 c 要求是一个整数，但是整型和字符型是互通的。但是赋值为 ‘\0’ 和 0 是等价的，因为字符 ‘\0’ 在内存中就是 0。所以在 memset 中初始化为 0 也具有结束标志符 ‘\0’ 的作用，所以通常我们就写“0”。
memset 函数的第三个参数 n 的值一般用 sizeof() 获取，这样比较专业。注意，如果是对指针变量所指向的内存单元进行清零初始化，那么一定要先对这个指针变量进行初始化，即一定要先让它指向某个有效的地址。而且用memset给指针变量如p所指向的内存单元进行初始化时，n 千万别写成 sizeof( p)，这是新手经常会犯的错误。因为 p 是指针变量，不管 p 指向什么类型的变量，sizeof( p) 的值都是 4。
下面写一个程序：
# include <stdio.h>
# include <string.h>
int main(void)
{
int i; //循环变量
char str[10];
char *p = str;
memset(str, 0, sizeof(str)); //只能写sizeof(str), 不能写sizeof(p)
for (i=0; i<10; ++i)
{
printf("%d\x20", str[i]);
}
printf("\n");
return 0;
}
根据memset函数的不同，输出结果也不同，分为以下几种情况：
m
emset(p, 0, sizeof( p)); //地址的大小都是4字节
0 0 0 0 -52 -52 -52 -52 -52 -52
memset(p, 0, sizeof(*p)); //*p表示的是一个字符变量, 只有一字节
0 -52 -52 -52 -52 -52 -52 -52 -52 -52
memset(p, 0, sizeof(str));
0 0 0 0 0 0 0 0 0 0
memset(str, 0, sizeof(str));
0 0 0 0 0 0 0 0 0 0
memset(p, 0, 10); //直接写10也行, 但不专业
0 0 0 0 0 0 0 0 0 0
总结:memset 是一个初始化函数对于 数组和结构体来说 相当快速
因为是直接对内存进行操作 三个参数分别是（初始化量的引用或者指针 ，所替换的数（一般都用0或’\0’），需要替换的数的数量（一般都是用初始化量的引用的sizeof））
=======================================================================================================
01背包问题 dp 动态规划
（暂时还没有理解清楚）
分析： 深度搜索算法： 先简单来看一下深搜的算法吧。这题的深搜就像一棵二叉树，从每个节点向下都会有两个分支，一个是加a，一个是减b。需要考虑的是根节点的大小，也就是第一个数的大小。第一个数没有明确告诉那么必然是在一个区间内浮动无法确定，需要一个个测试是否符合要求然后确定。注意到输入的数据有4个，第一个数的大小的区间可以用这四个数表示出来，可以确定最大值和最小值。最大值为s+nb，最小值为s-na。对这个区间内的每个整数做一遍深搜，统计满足条件的值可得答案。
代码：
public class Main{
static int num;//统计方案数 static int n;//数列长度 static int s;//和 static int a;//加a static int b;//减b public static void main(String[] args) { Scanner scanner=new Scanner(System.in); n=scanner.nextInt(); s=scanner.nextInt(); a=scanner.nextInt(); b=scanner.nextInt(); int total=s+nb;//第一个数可能取得的最大值 for (int i = s-na; i <=total ; i++) { dfn(i,i,1);//对每个符合要求的数列的首项做一次深搜 } System.out.PRintln(num); } //cur是数列当前项的值，all是数列累计值的总和，len是数列的长度 private static void dfn(int cur,int all,int len) { if(lenn) { if(alls) { num++; num=num%100000007; return ; } else return;//缺少此项堆栈溢出 } dfn(cur+a,all+cur+a,len+1); //下一项加a的情况 dfn(cur-b,all+cur-b,len+1); //下一项减b的情况 } }
可惜出现运行超时的情况
动态规划算法： 简单介绍深搜后重点来了，这题用动态规划（dp）解才是正解。在讲这题之前首先要回顾一下01背包问题中统计方案数的问题。
有容量为c的背包要装入体积为1~n的物品，每种物品各一个，求恰好将背包装满的方案数。
我们用二维数组Bo[i][j]来存储背包容量递增，物品按体积1n的顺序递增时方案数的情况。i表示有体积为0i的物品各一个，j表示背包的容量为j。首先要初始化当已有的物品体积数量为0，也就是相当于只有一个体积为0的物品时，背包容量j为0的方案数为1个，而容量大于0的方案数全为0。
之后来看关键的状态转移方程：
Bo[i][j]=Bo[i-1][j] ； i>j
Bo[i][j]=Bo[i-1][j]+Bo[i-1][j-i] ； i<=j
二维数组是从上到下，从左到右进行计算的，每个元素都与之前已经计算过元素相关。
第i行j列的元素，如果i>j，也就是新添加的可选物品的体积大于背包的容积，无法放入背包，所以新添加的可选物品不能够增加方案数。
如果i<=j，新添加的可选物品的体积小于背包的容积，有可能与其他物品组合装入背包，这时方案数为当没有添加入i体积物品时背包容量为j的方案数Bo[i-1][j]（装入后背包内体积还是小于背包体积），加上当没有添加入i体积物品时但背包容量恰好可以装入i体积物品的方案数Bo[i][j]=Bo[i-1][j]+Bo[i-1][j-i]（装入后背包内体积等于背包体积）。这样逐行计算即可知道所有情况下的方案数。 但是背包问题和本题有何关系呢，似乎毫不相干？
这题的难点就在于如何将本题转化为01背包问题。 设数列首项为t，F(i)={a,-b},第i项加上F(i)为第i+1项。所以第2项可表示为t+F(1)，第2项可表示为t+F(1)+F(2)，第3项可表示为t+F(1)+F(2)+F(3)…………把第一项到第n项累加起来可得表达式nt + (n-1)F(1) + (n-2)F(2) + ……. +F(n-1) =s。nt = s - {(n-1)F(1) + (n-2)F(2) + ……. +F(n-1)}。由于F(i)不为a就为-b，设有c个a，F(i)的系数相加共有1+2+……+n-1 = (n-1)*n/2项目，所以共有c-(n-1)n/2个b。所以令temp = s - ca + ((n-1)*n/2 - c)b，当temp%n = = 0时，说明temp == nt，满足要求。并且，c为1n-1个数中的若干个数组合相加而得的，每一种组合都是一种方案，到此，我们就可以发现这题已经转化为求01背包问题的方案数了。即从体积为1n-1的物品中有几种方案能够恰好填满背包。
i j 0 1 2 3 4 5 6 7 8 9 0 1 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 2 1 1 1 1 0 0 0 0 0 0 3 1 1 1 2 1 1 1 0 0 0 上图为测试输入样例的动态规划的结果，每一项都是(i,j)条件下的方案数，c的可能取值为4的倍数，该输入中有0和4符合要求，所以将(3,0)和(3.4)的值相加即为答案2。
还要注意到时间和空间的节省。时间上因为1~i-1体积的物品加起来最多也只能刚好填满i*(i+1)/2容量的背包，所以大于背包容量大于i*(i+1)/2体积的不用计算，固定初始化为0。空间上也不需要开辟上图那么大的空间，用滚动数组只需开辟两行即可，因为(i,j)的值只与i-1行有关,最终结果也只和最后求得的一行有关，所以只需存储当前行与上一行。
==========================================================================================================================================
1.按照题目要求，最终得到的序列的长度为n，和为s，并且后一项是前一项加a或减b，我们不妨将这个操作封装在一起，记作P操作，即P=(a,-b)。
2.设首项为x，可以得到一个等式x+(x+P)+(x+2P)+…+(x+(n-1)P)=s，将这个式子整理一下，就是nx+P+2P+…+(n-1)P=s，即(s-(P+2P+…+(n-1)P))/n=x。
3.由题意，x肯定是一个整数，并且由于每一个P代表一个a或者一个-b，所以a和b的总数为n*(n-1)/2，也就是说只要确定了a的个数，那么b的个数也就确定了。
4.关键问题是对于一个确定的a的个数，方案不只有一种，而且a的个数肯定是由（1,2,3,…,n-1）这其中的若干项组成的，，我们把这些项看作元素，第i个元素的权值为i于是，下面就开始构造递推方程5.首先，定义一个数组dp[i][j]，表示前i个元素组成和为j的序列的方案数，这里的和j表示的是所有的a的和，很明显当i!=0时dp[i][0]=1,当j!=0时dp[0][j]=0，然后我们要分两种情况讨论(1)、i>j时，因为每一个元素i权值都是i，所以当元素的个数大于和的时候，第i个元素的权值已经超过了和，所以第i个元素绝对不能使用，即dp[i][j]=dp[i-1][j]。(2)、i<=j时，第i个元素的权值是小于等于和的，所以可以用，也可以不用，如果不用，那么就是dp[i-1][j]，如果用，就是dp[i-1][j-i]，这个有点类似于01背包，所以dp[i][j]=dp[i-1][j]+dp[i-1][j-i]。OK，通过上面的分析，我们得到了递推方程，但还有一个问题，就是空间的问题，题目给出的i的最大值达到1000，相应的j也就是1000^2，我们是不可能开出这么大的数组的，观察递推方程，我们可以看出下一个状态只和前一个状态有关，而且我们实际上只需要最后一个状态即，dp[j]，于是可以使用滚动数组。
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0X3f3f3f3f
#define IN __int64
#define ull unsigned long long
#define ll long long
#define N 1010
#define M 100000007
using namespace std;
ll n,s,a,b;
int c[2][N*N];
int g;
int cnt;
void DP()
{
int i,j;
g=0;
memset(c,0,sizeof(c));
c[g][0]=1;
for(i=1;i<n;i++)
{
g=1-g;
for(j=0;j<=i*(i+1)/2;j++)
{
if(i>j)
c[g][j]=c[1-g][j];
else
c[g][j]=(c[1-g][j]+c[1-g][j-i])%M;
}
}
}
int main()
{
while(scanf("%lld%lld%lld%lld",&n,&s,&a,&b)!=EOF)
{
cnt=0;
DP();
ll i,t;
for(i=0;i<=n*(n-1)/2;i++)
{
t=s-i*a+(n*(n-1)/2-i)*b;
if(t%n==0)
cnt=(cnt+c[g][i])%M;
}
printf("%d\n",cnt);
}
return 0;
}
==============================================================================================
typedef的用法
https://blog.csdn.net/wangqiulin123456/article/details/8284939
结构体指针，C语言结构体指针详解
结构体指针，可细分为指向结构体变量的指针和指向结构体数组的指针。
指向结构体变量的指针
前面我们通过“结构体变量名.成员名”的方式引用结构体变量中的成员，除了这种方法之外还可以使用指针。
前面讲过，&student1 表示结构体变量 student1 的首地址，即 student1 第一个项的地址。如果定义一个指针变量 p 指向这个地址的话，p 就可以指向结构体变量 student1 中的任意一个成员。
那么，这个指针变量定义成什么类型呢？只能定义成结构体类型，且指向什么结构体类型的结构体变量，就要定义成什么样的结构体类型。比如指向 struct STUDENT 类型的结构体变量，那么指针变量就一定要定义成 struct STUDENT* 类型。
下面将前面的程序用指针的方式修改一下：
# include <stdio.h>
# include <string.h>
struct AGE
{
int year;
int month;
int day;
};
struct STUDENT
{
char name[20]; //姓名
int num; //学号
struct AGE birthday; //生日
float score; //分数
};
int main(void)
{
struct STUDENT student1; /*用struct STUDENT结构体类型定义结构体变量student1*/
struct STUDENT *p = NULL; /*定义一个指向struct STUDENT结构体类型的指针变量p*/
p = &student1; /*p指向结构体变量student1的首地址, 即第一个成员的地址*/
strcpy((*p).name, "小明"); //(*p).name等价于student1.name
(*p).birthday.year = 1989;
(*p).birthday.month = 3;
(*p).birthday.day = 29;
(*p).num = 1207041;
(*p).score = 100;
printf("name : %s\n", (*p).name); //(*p).name不能写成p
printf("birthday : %d-%d-%d\n", (*p).birthday.year, (*p).birthday.month, (*p).birthday.day);
printf("num : %d\n", (*p).num);
printf("score : %.1f\n", (*p).score);
return 0;
}
输出结果是：
name : 小明
birthday : 1989-3-29
num : 1207041
score : 100.0
我们看到，用指针引用结构体变量成员的方式是：
(*指针变量名).成员名
注意，p 两边的括号不可省略，因为成员运算符“.”的优先级高于指针运算符“”，所以如果 *p 两边的括号省略的话，那么 *p.num 就等价于 *(p.num) 了。
从该程序也可以看出：因为指针变量 p 指向的是结构体变量 student1 第一个成员的地址，即字符数组 name 的首地址，所以 p 和 (*p).name 是等价的。
但是，“等价”仅仅是说它们表示的是同一个内存单元的地址，但它们的类型是不同的。指针变量 p 是 struct STUDENT* 型的，而 (p).name 是 char 型的。所以在 strcpy 中不能将 (*p).name 改成 p。用 %s 进行输入或输出时，输入参数或输出参数也只能写成 (*p).name 而不能写成 p。
同样，虽然 &student1 和 student1.name 表示的是同一个内存单元的地址，但它们的类型是不同的。&student1 是 struct STUDENT* 型的，而 student1.name 是 char* 型的，所以在对 p 进行初始化时，“p=&student1；”不能写成“p=student1.name”。因为 p 是 struct STUDENT* 型的，所以不能将 char* 型的 student1.name 赋给 p。
此外为了使用的方便和直观，用指针引用结构体变量成员的方式：
(*指针变量名).成员名
可以直接用：
指针变量名->成员名
来代替，它们是等价的。“->”是“指向结构体成员运算符”，它的优先级同结构体成员运算符“.”一样高。p->num 的含义是：指针变量 p 所指向的结构体变量中的 num 成员。p->num 最终代表的就是 num 这个成员中的内容。
下面再将程序用“->”修改一下：
# include <stdio.h>
# include <string.h>
struct AGE
{
int year;
int month;
int day;
};
struct STUDENT
{
char name[20]; //姓名
int num; //学号
struct AGE birthday; /*用struct AGE结构体类型定义结构体变量birthday, 生日*/
float score; //分数
};
int main(void)
{
struct STUDENT student1; /*用struct STUDENT结构体类型定义结构体变量student1*/
struct STUDENT *p = NULL; /*定义struct STUDENT结构体类型的指针变量p*/
p = &student1; /*p指向结构体变量student1的首地址, 即第一项的地址*/
strcpy(p->name, "小明");
p->birthday.year = 1989;
p->birthday.month = 3;
p->birthday.day = 29;
p->num = 1207041;
p->score = 100;
printf("name : %s\n", p->name); //p->name不能写成p
printf("birthday : %d-%d-%d\n", p->birthday.year, p->birthday.month, p->birthday.day);
printf("num : %d\n", p->num);
printf("score : %.1f\n", p->score);
return 0;
}
输出结果是：
name : 小明
birthday : 1989-3-29
num : 1207041
score : 100.0
但是要注意的是，只有“指针变量名”后面才能加“->”，千万不要在成员名如 birthday 后面加“->”。
综上所述，以下 3 种形式是等价的：
结构体变量.成员名。
(*指针变量).成员名。
指针变量->成员名。
其中第 3 种方式很重要，通常都是使用这种方式，另外两种方式用得不多。后面讲链表的时候用的也都是第 3 种方式。
指向结构体数组的指针
在前面讲数值型数组的时候可以将数组名赋给一个指针变量，从而使该指针变量指向数组的首地址，然后用指针访问数组的元素。结构体数组也是数组，所以同样可以这么做。
我们知道，结构体数组的每一个元素都是一个结构体变量。如果定义一个结构体指针变量并把结构体数组的数组名赋给这个指针变量的话，就意味着将结构体数组的第一个元素，即第一个结构体变量的地址，也即第一个结构变量中的第一个成员的地址赋给了这个指针变量。比如：
# include <stdio.h>
struct STU
{
char name[20];
int age;
char sex;
char num[20];
};
int main(void)
{
struct STU stu[5] = {{"小红", 22, 'F', "Z1207031"}, {"小明", 21, 'M', "Z1207035"}, {"小七", 23, 'F', "Z1207022"}};
struct STU *p = stu;
return 0;
}
此时指针变量 p 就指向了结构体数组的第一个元素，即指向 stu[0]。我们知道，当一个指针指向一个数组后，指针就可以通过移动的方式指向数组的其他元素。
这个原则对结构体数组和结构体指针同样适用，所以 p+1 就指向 stu[1] 的首地址；p+2 就指向 stu[2] 的首地址……所以只要利用 for 循环，指针就能一个个地指向结构体数组元素。
同样需要注意的是，要将一个结构体数组名赋给一个结构体指针变量，那么它们的结构体类型必须相同。
下面编写一个程序：
# include <stdio.h>
struct STU
{
char name[20];
int age;
char sex;
char num[20];
};
int main(void)
{
struct STU stu[3] = {{"小红", 22, 'F', "Z1207031"}, {"小明", 21, 'M', "Z1207035"}, {"小七", 23, 'F', "Z1207022"}};
struct STU *p = stu;
for (; p<stu+3; ++p)
{
printf("name:%s; age:%d; sex:%c; num:%s\n", p->name, p->age, p->sex, p->num);
}
return 0;
}
输出结果是：
name:小红; age:22; sex:F; num:Z1207031
name:小明; age:21; sex:M; num:Z1207035
name:小七; age:23; sex:F; num:Z1207022
此外同前面“普通数组和指针的关系”一样，当指针变量 p 指向 stu[0] 时，p[0] 就等价于 stu[0]；p[1] 就等价于 stu[1]；p[2] 就等价于 stu[2]……所以 stu[0].num 就可以写成 p[0].num，其他同理。下面将上面的程序用 p[i] 的方式修改一下：
# include <stdio.h>
struct STU
{
char name[20];
int age;
char sex;
char num[20];
};
int main(void)
{
struct STU stu[3] = {{"小红", 22, 'F', "Z1207031"}, {"小明", 21, 'M', "Z1207035"}, {"小七", 23, 'F', "Z1207022"}};
struct STU *p = stu;
int i = 0;
for (; i<3; ++i)
{
printf("name:%s; age:%d; sex:%c; num:%s\n", p[i].name, p[i].age, p[i].sex, p[i].num);
}
return 0;
}
输出结果是：
name:小红; age:22; sex:F; num:Z1207031
name:小明; age:21; sex:M; num:Z1207035
name:小七; age:23; sex:F; num:Z1207022
============================================================
在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。创建结构体指针是极常见的。下面是一个例子：
1 typedef struct
2 {
3 char name[21];
4 char city[21];
5 char state[3];
6 } Rec;
7 typedef Rec *RecPointer;
8
9 RecPointer r;
10 r=(RecPointer)malloc(sizeof(Rec));
r是一个指向结构体的指针。请注意，因为r是一个指针，所以像其他指针一样占用4个字节的内存。而malloc语句会从堆上分配45字节的内存。*r是一个结构体，像任何其他Rec类型的结构体一样。下面的代码显示了这个指针变量的典型用法：
1 strcpy((*r).name, "Leigh");
2 strcpy((*r).city, "Raleigh");
3 strcpy((*r).state, "NC");
4 printf("%sn", (*r).city);
5 free(r);
您可以像对待一个普通结构体变量那样对待r，但在遇到C的操作符优先级问题时要小心。如果去掉r两边的括号则代码将无法编译，因为“.”操作符的优先级高于“*”操作符。使用结构体指针时不断地输入括号是令人厌烦的，为此C语言引入了一种简记法达到相同的目的：
1 strcpy(r->name, "Leigh");
r->这种写法和(*r).是完全等效的，但是省去了两个字符。
指向数组的指针
还可以创建指向数组的指针，如下所示：
1 int *p;
2 int i;
3
4 p=(int *)malloc(sizeof(int[10]));
5 for (i=0; i<10; i++)
6 p[i]=0;
7 free(p);
或：
1 int *p;
2 int i;
3
4 p=(int *)malloc(sizeof(int[10]));
5 for (i=0; i<10; i++)
6 *(p+i)=0;
7 free(p);
可见要创建指向整数数组的指针，只需创建一个普通的整数指针即可。调用malloc分配合适的数组空间，然后将指针指向数组的第一个元素。访问数组元素既可以用普通的数组下标也可以用指针运算。C将两种方法视为是等效的。
指向数组的指针这一技巧尤其适用于字符串。您可以为某个特定大小的字符串分配刚好合适的内存。
指针数组
有时声明一 个指针数组可以节省大量内存，或者使得某些内存消耗较大的问题得以解决。下面例子中的代码，声明了一个由10个结构体指针组成的数组，而不是一个结构体数组。否则这个结构体数组将占用243 * 10=2,430字节的内存。使用指针数组可以最大限度减小内存消耗，直到用malloc语句为记录实际分配内存空间。作为此过程的演示，下面的代码只为一个记录分配空间，保存某个值后又将空间释放：
定义一个结构体类型数组，其数组名是数组的首地址，这一点前面的课程介绍得很清楚。
定义结构体类型的指针，既可以指向数组的元素，也可以指向数组，在使用时要加以区分。
1 typedef struct
2 {
3 char s1[81];
4 char s2[81];
5 char s3[81];
6 } Rec;
7 Rec *a[10];
8
9 a[0]=(Rec *)malloc(sizeof(Rec));
10 strcpy(a[0]->s1, "hello");
11 free(a[0]);
包含指针的结构体
结构体可以包含指针，如下所示：
1 typedef struct
2 {
3 char name[21];
4 char city[21];
5 char phone[21];
6 char *comment;
7 } Addr;
8 Addr s;
9 char comm[100];
10
11 gets(s.name, 20);
12 gets(s.city, 20);
13 gets(s.phone, 20);
14 gets(comm, 100);
15 s.comment=
16 (char *)malloc(sizeof(char[strlen(comm)+1]));
17 strcpy(s.comment, comm);
只有当评论框里包含有评论的记录时，这一技巧才是有用的。如果没有评论记录，评论框里只包含一个指针（4个字节）。包含评论的记录会分配恰到好处的空间，保存评论的的字符串，这取决于用户输入的字符串的长度。
指向结构体类型变量的使用
首先让我们定义结构体：
1 struct stu
2 {
3 char name[20];
4 long number;
5 float score[4];
6 } ;
再定义指向结构体类型变量的指针变量：
struct stu *p1, *p2 ;
定义指针变量p 1、p 2，分别指向结构体类型变量。引用形式为：指针变量→成员；
[例7-2] 对指向结构体类型变量的正确使用。输入一个结构体类型变量的成员，并输出。
1 #include <stdlib.h> /*使用m a l l o c ( ) 需要* /
2 struct data / *定义结构体* /
3 {
4 int day,month,year;
5 } ;
6 struct stu /*定义结构体* /
7 {
8 char name[20];
9 long num;
10 struct data birthday; /嵌*套的结构体类型成员*/
11 } ;
12 main() /*定义m a i n ( ) 函数* /
13 {
14 struct stu *student; 定/*义结构体类型指针*/
15 student=malloc(sizeof(struct stu)); 为/指* 针变量分配安全的地址*/
16 printf("Input name,number,year,month,day:/n");
17 scanf("%s",student->name); 输/*入学生姓名、学号、出生年月日*/
18 scanf("%ld",&student->num);
19 scanf("%d%d%d",&student->birthday.year,&student->birthday.month,
20 &student->birthday.day);
21 printf("/nOutputname,number,year,month,day/n");
22 /*打印输出各成员项的值*/
23 printf("%20s%10ld%10d//%d//%d/n",student->name,student->num,
24 student->birthday.year,student->birthday.month,
25 student->birthday.day);
26 }
程序中使用结构体类型指针引用结构体变量的成员，需要通过C提供的函数malloc()来为
指针分配安全的地址。函数sizeof()返回值是计算给定数据类型所占内存的字节数。指针所指
各成员形式为：
1 student->name
2 student->num
3 student->birthday.year
4 student->birthday.month
5 student->birthday.day
指向结构体类型数组的指针的使用
定义一个结构体类型数组，其数组名是数组的首地址，这一点前面的课程介绍得很清楚。
定义结构体类型的指针，既可以指向数组的元素，也可以指向数组，在使用时要加以区分。
[例7-3] 在例7 - 2中定义了结构体类型，根据此类型再定义结构体数组及指向结构体类型的指针。
1 struct data
2 {
3 intday,month,year;
4 };
5 struct stu/*定义结构体*/
6 {
7 char name[20];
8 long num;
9 struct data birthday;/嵌*套的结构体类型成员*/
10 };
11 struct stustudent[4],*p;定/*义结构体数组及指向结构体类型的指针*/
作p=student，此时指针p就指向了结构体数组student。
p是指向一维结构体数组的指针，对数组元素的引用可采用三种方法。
1)地址法
student+i和p+i均表示数组第i个元素的地址，数组元素各成员的引用形式为：
（student+i）->name、(student+i)->num和(p+i)->name、（p+i）->num等。student+i和p+i
与&student[i]意义相同。
2)指针法
若p指向数组的某一个元素，则p++就指向其后续元素。
3)指针的数组表示法
若p=student，我们说指针p指向数组student，p[i]表示数组的第i个元素，其效果与
student[i]等同。对数组成员的引用描述为:p[i].name、p[i].num等。
[例7-4]指向结构体数组的指针变量的使用。
1 structdata/*定义结构体类型*/
2 {
3 intday,month,year;
4 };
5 structstu/*定义结构体类型*/
6 {
7 char name[20];
8 long num;
9 struct data birthday;
10 };
11 main()
12 {inti;
13 structstu*p,student[4]={{"liying",1,1978,5,23},{"wangping",2,1979,3,14},
14 {"libo",3,1980,5,6},{"xuyan",4,1980,4,21}};
15 /*定义结构体数组并初始化*/
16 p=student;/*将数组的首地址赋值给指针p,p指向了一维数组student*/
17 printf("/n1----Outputname,number,year,month,day/n");
18 for(i=0;i<4;i++)/*采用指针法输出数组元素的各成员*/
19 printf("%20s%10ld%10d//%d//%d/n",(p+i)->name,(p+i)->num,
20 (p+i)->birthday.year,(p+i)->birthday.month,
21 (p+i)->birthday.day);
22 }
====================
再次加深对结构体的理解
#include<stdio.h>
#include<stdlib.h>
typedef struct student *stu;
struct student
{
int id;
int score;
};
int main()
{
// stu=(student *)malloc(sizeof(student)); 错误表示法
// (*stu).id=324;
// (*stu).score=100;
stu student1=(student *)malloc(sizeof(stu));
(*student1).id=324;
(*student1).score=100;
printf("id=%d score=%d\n",(*student1).id,(*student1).score);
printf("id=%d score=%d\n",student1->id,student1->score);
}