全国计算机等级考试二级教程-C语言程序设计_第14章_结构体、共用体和用户定义类型

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> struct info
{
char name[];
int num;
}; struct info getstruct(char *p, int num)
{
struct info info1;//创建结构体
printf("%x\n", &info1);
info1.num = num;//进行赋值
strcpy(info1.name, p);//复制字符串
printf("%d,%s\n", info1.num, info1.name);
return info1;//返回结构体，return有副本机制，保存了info1到另外一段内存
} main()
{
struct info MM = getstruct("hello", ); printf("%d,%s\n", MM.num, MM.name); system("pause");
};

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> struct info
{
char name[];
long long phone;
}; //函数的副本机制，函数的参数新建了一个变量接收值
//形参改变，不影响实参
void showinfo(struct info info1)
{
printf("%x\n", &info1); strcpy(info1.name, "gao yuan yuan");
info1.phone = ; printf("%s,%lld\n", info1.name, info1.phone);
} //因为函数的副本机制，所以改变一个外部变量，需要变量的地址
void change(struct info *p)
{
printf("%x\n", &p); strcpy((*p).name, "gao yuan yuan");
(*p).phone = ; printf("%s,%lld\n", (*p).name, (*p).phone);
} main()
{
struct info lady = { "tang wei", }; printf("%x\n", &lady); printf("%s,%lld\n", lady.name, lady.phone); change(&lady); printf("%s,%lld\n", lady.name, lady.phone); system("pause");
}

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> struct csdn
{
char user[];
char password[];
char email[];
}; //函数的参数，会对数组传地址，不会有副本机制
//为了节约内存，数组传递的是指针
//数组作为函数参数，退化成指针
//void find(struct csdn cdata[5], char *str)
void find(struct csdn *cdata, char *str)
{
printf("find结构体数组有%d个元素\n", sizeof(cdata));//结构体数组作为参数，有4个字节
printf("find结构体元素有%d个元素\n", sizeof(struct csdn)); int i; for (i = ;i < ;i++)
{
if (strcmp(cdata[i].user, str) == )
{
printf("找到%s,%s,%s\n", cdata[i].user, cdata[i].password, cdata[i].email);
}
}
} main()
{
struct csdn cdata[]=
{
{"microsoft","","microsoft@google.com"},
{ "google","","google@google.com"},
{ "baidu","","baidu@google.com"},
{ "ali","","ali@google.com"},
{ "tencent","","tencent@google.com"}
}; printf("main结构体数组有%d个元素\n", sizeof(cdata));
printf("main结构体元素有%d个元素\n", sizeof(struct csdn)); int i; for (i = ;i < ;i++)
{
printf("%s %s %s\n", cdata[i].user, cdata[i].password, cdata[i].email);
} find(cdata, "google"); system("pause");
}

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> #define DB double *
typedef double * db; main()
{
DB dp1, dp2;//double *dp1, dp2; db dp3, dp4;//double *dp3, *dp4 printf("%d,%d\n", sizeof(dp1), sizeof(dp2)); printf("%d,%d\n", sizeof(dp3), sizeof(dp4)); system("pause");
}

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> struct mystruct
{
short sh;
char str[];
};//2+11=14 struct info
{
char ch;
char str[];
};//1+10=11 struct tel
{
int tel;
char name[];
};//4+32=36 struct data
{
char c;
double db;
char str[];
};//8+8+16=32 struct data1
{
short sh;
double db;
char str[];
};//8+8+16=32 struct data2
{
short sh;
int ch;
char str[];
};//4+4+20=28 main()
{
printf("%d\n", sizeof(struct mystruct)); printf("%d\n", sizeof(struct info)); printf("%d\n", sizeof(struct tel)); printf("%d\n", sizeof(struct data)); printf("%d\n", sizeof(struct data1)); printf("%d\n", sizeof(struct data2)); system("pause");
};

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> union data
{
double db;//
char str[];//
};// union data1
{
int i;//
char str[];//
};// main()
{
printf("%d\n", sizeof(union data)); printf("%d\n", sizeof(union data1)); system("pause");
};

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> struct//第3种方法，无名结构体，限量版发行
{
char email[];
char name[];
char add[];
int num;
int bignum;
char tel[];
char phone[];
double RMB;
}d1, d2, d3;//第3种方法，无名结构体，限量版发行 //#define DD struct dangdang//第2种方法
//
//DD
//{
// char email[50];
// char name[50];
// char add[100];
// int num;
// int bignum;
// char tel[20];
// char phone[20];
// double RMB;
//};
//DD d1, d2, d3;//第2种方法 //struct dangdang//第1种方法
//{
// char email[50];
//char name[50];
//char add[100];
//int num;
//int bignum;
//char tel[20];
//char phone[20];
//double RMB;
//};
//struct dangdang d1, d2, d3;//第1种方法 main()
{ system("pause");
};

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> struct info
{
int num;
float score;
}; main()
{
struct info info1;
printf("%d,%f\n", info1.num = , info1.score = );
struct info *p1 = &info1; printf("%d,%f\n", (*p1).num, (*p1).score);
printf("%d,%f\n", p1->num, p1->score);//指针访问结构体2种形式 struct info *p2 = (struct info*)malloc(sizeof(struct info));
p2->num = ;
p2->score = 19.8; printf("%d,%f\n", (*p2).num, (*p2).score);
printf("%d,%f\n", p2->num, p2->score); system("pause");
}

#include<stdio.h> struct date
{
int year, month, day;
}; /* （1）紧跟在结构体类型说明之后进行定义。不推荐，因为只能够定义一次此类型结构体变量 */
struct student
{
char name[];
char sex;
struct date birthday;
float sc[];
}std, pers[], *pstd; /* （2）在说明一个无名结构体类型的同时，直接进行定义。不推荐，因为只能够定义一次此类型结构体变量 */
struct
{
char name[];
char sex;
struct date birthday;
float sc[];
}std, pers[], *pstd; /* （3）先说明结构体类型，再单独进行变量定义。推荐 */
struct student
{
char name[];
char sex;
struct date birthday;
float sc[];
};
struct student std, pers[], *pstd; /* （4）使用typedef说明一个结构体类型名，再用新类型名来定义变量 */
typedef struct
{
char name[];
char sex;
struct date birthday;
float sc[];
}STREC;
STREC std, pers[], *pstd; main()
{ }

#include<stdio.h> struct student
{
int age;
float score;
char sex;
}; main()
{
struct student st = { , 66.6, 'F' }; struct student st2;
st2.age = ;
st2.score = ;
st2.sex = 'F'; printf("%d %f %c\n", st.age, st.score, st.sex);
printf("%d %f %c\n", st2.age, st2.score, st2.sex);
}

#include<stdio.h> struct student
{
int age;
float score;
char sex;
}; main()
{
struct student st = { , 66.6, 'F' };
struct student * pst = &st; st.age = ; /* （1）通过结构体变量引用 */
pst->age = ; /* （2）通过指针变量引用，更常用 */
(*pst).age = ; /* （3）通过指针变量引用 */
}

#include<stdio.h> struct student
{
char name[];
int num;
}per1, per2 = { "YANGGM", }; main()
{
per1 = per2;
}

#include<stdio.h> struct student
{
int age;
char name[];
float score;
}; void getdata(struct student * parr, int len)
{
int i; for (i = ;i < len;++i)
{
printf("请输入第%d个学生的信息：", i + ); printf("age=");
scanf("%d", &parr[i].age); printf("name=");
scanf("%s", parr[i].name); printf("score=");
scanf("%f", &parr[i].score);
}
} void outdata(struct student * parr, int len)
{
int i; for (i = ;i < len;++i)
{
printf("age=%d,name=%s,score=%f\n", parr[i].age, parr[i].name, parr[i].score);
}
} void sort(struct student * parr, int len)
{
int i, j;
struct student t; for (i = ;i < len - ;++i)
{
for (j = ;j < len - - i;++j)
{
if (parr[j].score < parr[j + ].score)
{
t = parr[j];
parr[j] = parr[j + ];
parr[j + ] = t;
}
}
}
} main()
{
int len;
struct student * parr;
struct student t; printf("请输入学生的个数：");
scanf("%d", &len);
parr = (struct student *)malloc(len * sizeof(struct student)); getdata(parr, len); printf("\n输入的信息如下：\n");
outdata(parr, len); sort(parr, len); printf("\n根据学生的成绩排序，使用降序\n");
outdata(parr, len);
}

#include<stdio.h> enum weekday
{
mon, tue, wed, thu, fri, sat, sun
}; void fun(enum weekday i) /* 本函数目的只是期望接受0-6之间的数字，将形参i定义为枚举 */
{
switch (i)
{
case :printf("mon\n");
break;
case :printf("tue\n");
break;
case :printf("wed\n");
break;
case :printf("thu\n");
break;
case :printf("fri\n");
break;
case :printf("sat\n");
break;
case :printf("sun\n");
break;
}
} main()
{
fun(fri);
}

#include<stdio.h> typedef struct
{
int num;
double mark;
}REC; void sub1(REC x)
{
x.num = ;
x.mark = 81.5;
} void sub2(REC y[])
{
y[].num = ;
y[].mark = 77.5;
} main()
{
REC a = { ,90.0 }, b[] = { ,90.0 };
sub1(a);
printf("A)%d,%5.1lf\n", a.num, a.mark);
sub2(b);
printf("B)%d,%5.1lf\n", b[].num, b[].mark);
}

#include<stdio.h> typedef struct
{
int a;
char b;
}ST; ST fun(ST x) /* 函数的返回值类型是结构体类型ST */
{
x.a = ;
x.b = 'S';
return x;
} main()
{
ST y;
y.a = ;
y.b = 'A';
printf("y.a=%d,y.b=%c\n", y.a, y.b);
y = fun(y);
printf("y.a=%d,y.b=%c\n", y.a, y.b);
}

#include<stdio.h> typedef struct
{
int a;
char b;
}ST; ST * fun(ST x) /* 函数的返回值类型是ST *类型 */
{
ST * px;
x.a = ;
x.b = 'C';
px = &x;
return px;
} main()
{
ST y, *p;
y.a = ;
y.b = 'X';
printf("y.a=%d y.b=%c\n", y.a, y.b);
p = fun(y);
printf("(*p ).a=%d (* p).b=%c\n", (*p).a, (*p).b);
}

#include<stdio.h>
#include<string.h>
#define N 5 typedef struct
{
char name[];
char num[];
}USER; void getdata(USER * sp);
void getsort(USER * sp);
void outdata(USER * sp); main()
{
USER sp[N];
getdata(sp);
getsort(sp);
outdata(sp);
} void getdata(USER * sp)
{
int i;
printf("Enter name & phone number:\n");
for (i = ;i < N;i++)
{
gets(sp[i].name);
gets(sp[i].num);
}
} void getsort(USER * sp)
{
int i, j, k;
USER temp;
for (i = ;i < N - ;i++) /* 按成员 name 的大小重新排列 sp 数组的元素 */
{
k = i;
for (j = i + ;j < N;j++)
{
if (strcmp(sp[k].name, sp[j].name)>)
{
k = j;
}
temp = sp[k]; /* 结构体整体赋值 */
sp[k] = sp[i];
sp[i] = temp;
}
}
} void outdata(USER * sp)
{
int i;
printf("after sorted:\n");
for (i = ;i < N;i++)
{
printf("%s,%s\n", sp[i].name, sp[i].num);
}
}

#include<stdio.h> struct node
{
int data;
struct node * next;
}; typedef struct node NODETYPE; main()
{
NODETYPE a, b, c, *h, *p;
a.data = ; /* 给变量中的 data 域赋值 */
b.data = ;
c.data = ;
h = &a; /* 将结点相连 */
a.next = &b;
b.next = &c;
c.next = '\0';
p = h;
while (p) /* 移动 p，使之依次指向 a、b、c，输出它们 data 域中的值 */
{
printf("%d", p->data);
p = p->next; /* p 顺序后移 */
}
printf("\n");
}