結構體：
由一系列具有相同或者不同的數據類型的數據組成的集合，數據彼此之間有聯繫
數組：
由一系列具有相同數據類型的數據組成的集合，數據之間彼此獨立，
數據意義相同---->數據類型相同
數組的特點：
- 數據多
- 數據的意義一樣，---->數據類型一樣
- 數據彼此獨立，互不影響
- 可以拆分爲基本數據類型
結構體的特點： - 數據多
- 數據意義不一樣—>數據類型不一樣，也有可能一樣
- 數據彼此有聯繫
- 可以拆分爲基本數據類型
結構體類型定義的格式：
struct 結構體名
{
//成員列表
};
struct ：關鍵字，表示一種結構體 數據類型 *----->指針類型 —> int *
結構體類型：struct 結構體名
成員列表：數據類型 成員名; -------->結構體中的成員不能賦值
成員用分號隔開
結構體支持嵌套，但是要在嵌套之前，完成定義
結構體類型只需要定義一次，後面直接使用，不需要再重新定義該類型
結構體類型定義完成之後，不佔用內存空間，只有在使用該類型的變量的時候，系統纔會分配內存空間
注意：結構體大括號外面的分號不能省略
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
};
結構體類型變量的定義
結構體類型變量的定義有三種方式
1）在定義結構體類型的同時，定義結構體類型的變量
struct NOM
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
}a;
2）先定義結構體類型，然後在定義結構體類型的變量
struct NOM
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
};
struct NOM 變量名;
3）在定義結構體類型的同時，不加結構體名，定義結構體類型的變量
struct
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
}b,q; //定義結構體類型變量b
第三種形式不常用，這種方法只適合一次性的變量的定義，如果程序運行到後面的時候，還需要該類型的變量，則此時無法定義。
結構體類型的定義一般在頭文件與主函數之間，在函數聲明之前
構體類型變量的賦值 引用 初始化
結構體類型變量的初始化
- 結構體類型變量的初始化，採用大括號的形式對其進行整體賦值，系統默認從第一個成員開始賦值
- 結構體類型變量只有在初始化的時候，才能使用大括號對其整體賦值，除此以外不能對結構體變量進行整體賦值
- 結構體類型變量的再初始化的時候，不能跳躍式初始化，但是支持部分初始化，未被初始化的成員的值默認爲0
- 結構體類型變量進行初始化的時候，成員的值，需要使用逗號隔開
- 結構體變量與變量之間可以進行整體賦值，數組與數組之間不能整體賦值
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
};
struct NOM a = {“張三”,89,90,1103,{1990,12}};
//結構體出現嵌套的時候，進行初始化可以加大括號分開，也可以不用加大括號分開
// struct NOM a = {“張三”,89,90,1103,1990,12}; //第二種初始化方式
//struct NOM a = {“張三”,89,90,1103}; //部分初始化
struct NOM b = a;
printf("%s %d %d %d %d %d\n",b.name,b.score[0],b.score[1],b.num, b.t.year,b.t.month);
結構體類型變量的賦值
-
給結構體變量賦值的時候，需要通過結構體變量名引用成員的方式對成員進行一一賦值，在賦值時候需要注意成員本身的特性，有的成員不支持整體賦值，此時就需要換一種方式
struct NOM a;
a.acore[2] = {11,34}; //不符合數組的定義
a.score[0] = 11 , a.score[1] = 32; -
結構體變量先定義，後賦值，不能整體賦值
#include <stdio.h>
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
};
int main()
{
// struct NOM a = {"張三",89,90,1103,1990,12}; //第二種初始化方式
struct NOM a = {"張三",89,90,1103}; //部分初始化
struct NOM b = a; //結構體變量之間的賦值
printf("%s %d %d %d %d %d\n",b.name,b.score[0],b.score[1],b.num,
b.t.year,b.t.month);
struct NOM c;
c.score[0] = 86;
c.score[1] = 78;
c.num = 1107;
//c.t = {1789,10}; //結構體類型的成員不能整體賦值
c.t.year = 1789;
c.t.month = 10;
//c.name = "李思"; //數組不能整體賦值
//終端輸入
//gets(c.name);
//字符串拷貝函數
strcpy(c.name,"zhang san");
printf("%s %d %d %d %d %d\n",c.name,c.score[0],c.score[1],c.num,
c.t.year,c.t.month);
//結構體變量的值，終端輸入，數據輸入到結構體變量的成員
struct NOM d;
scanf("%s %d %d %d %d %d",d.name,&d.score[0],&d.score[1],&d.num,
&d.t.year,&d.t.month);
printf("----------------------------------------------\n");
printf("%s %d %d %d %d %d\n",d.name,d.score[0],d.score[1],d.num,
d.t.year,d.t.month);
}
結構體變量引用成員的方式
給結構體變量的賦值，實際上是給結構體變量的成員進行賦值，如果要使用結構體變量的值，需要通過結構體變量名引用成員們的方式，得到成員值
結構體變量引用成員的方式：
結構體變量名.成員名
如果結構體中出現嵌套的結構體，需要一層一層的進入，一層一個.
a.name
b.num
a.score[0]
a.score[1]
a.t.year a.t.month
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
};
舉個栗子
定義三個結構體變量，一個變量初始化，一個變量先定義後賦值。一個變量終端輸入，打印學號最大的 這個人的所有信息
#include <stdio.h>
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[15]; //姓名
int score[2]; //成績
int num; //學號
struct BIR t;
};
int main()
{
struct NOM a = {"張三",88,90,1102,2016,2};
struct NOM b;
struct NOM c;
struct NOM max;
//賦值：結構體變量名.成員 賦值
strcpy(b.name, "李思");
b.score[0] = 77;
b.score[1] = 89;
b.num = 1107;
b.t.year = 2017;
b.t.month = 10;
//終端輸入
printf("請輸入姓名\t 語文\t 數學\t 學號\t 年月：\n");
scanf("%s %d %d %d %d %d",c.name,&c.score[0],&c.score[1],&c.num,
&c.t.year,&c.t.month);
max = (a.num > b.num)?a:b;
max = (max.num > c.num)?max:c;
printf("學號最大的人的對應的信息爲：\n");
printf("姓名\t 語文\t 數學\t 學號\t 年\t 月\n");
printf("%s\t %d\t %d\t %d\t %d\t %d\n",max.name,max.score[0],max.score[1],max.num,
max.t.year,max.t.month);
}
結構體數組的定義 初始化 賦值 引用
- 結構體數組的定義跟結構體變量的定義方式一樣
- 結構體數組的初始化，本質—>數組，只有在初始化的時候，才能使用大括號對結構體進行初始化，支持部分初始化，如果初始化，長度可以省略不寫
//表示該數組有三個元素，每個元素的類型爲結構體類型，包括成員
struct NOM a[3] = {
{“張三”},
{},
{},
}; //初始化數組中裏面的括號可以省略不寫，其目的只是爲了區分元素
//結構體數組引用成員的方式：
數組名[下標].成員名
在進行賦值的時候，要注意成員本身的特性，有的成員不支持整體賦值
#include <stdio.h>
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[10]; //姓名 //15--->+1
int score[2]; //成績 //8--? 4+4
int num; //學號 //4
struct BIR t; //8
};
int main()
{
struct NOM a[3] = {
{"zhangsan",88,90,1101,2017,8},
{"zhoasi",89,90,1102,2018,7},
{"zhaosan",66,56,1103,2015,8}
};
int i;
//結構體數組的賦值,實際上給數組的元素的成員進行賦值
//a[0] a[1] a[2]
strcpy(a[0].name,"張三");
a[0].t.year = 2018; //*a
a[1].score[0] = 100; //*(a+1)
a[2].num = 1106;
a[2].score[1] = 100; //*(a+2)
//終端輸入
for(i = 0; i < 3; i++)
{
scanf("%s %d %d %d %d %d",a[i].name,&a[i].score[0],&a[i].score[1],&a[i].num,
&a[i].t.year,&a[i].t.month);
}
//打印
for(i = 0; i < 3; i++)
{
printf("%s %d %d %d %d %d\n",a[i].name,a[i].score[0],a[i].score[1],a[i].num,
a[i].t.year,a[i].t.month);
}
}
結構體指針的定義 初始化 賦值 引用
-
結構體指針的定義跟結構體變量的定義方式一樣
-
結構體指針的初始化，------>指針
指針指向結構體變量 ，指針指向結構體數組 -
結構體指針的引用成員，得到成員的值
指針名->成員
(指針名).成員名
結構體指針指向數組
(指針名+下標)->成員
((指針名+下標)).成員名
初始化
結構體類型 指針 = &結構體變量名
結構體類型 指針 = 結構體數組名
#include <stdio.h>
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[10]; //姓名 //15--->+1
int score[2]; //成績 //8--? 4+4
int num; //學號 //4
struct BIR t; //8
};
int main()
{
struct NOM a = {"張三",88,90,1102,2016,2};
struct NOM b;
struct NOM c;
struct NOM max;
struct NOM *pb = &b; //結構體指針指向結構體變量b
//賦值：結構體變量名.成員 賦值
//strcpy(b.name, "李思");
strcpy(pb->name,"lisi"); //strcpy((*pb).name,"lisi");
//b.score[0] = 77;
(*pb).score[0] = 77;
//b.score[1] = 89;
pb->score[1] = 89;
//b.num = 1107;
pb->num = 1107;
//b.t.year = 2017;
(*pb).t.year = 2017;
//b.t.month = 10;
pb->t.month = 10;
//終端輸入
pb = &c; //結構體指針指向結構體變量C
printf("請輸入姓名\t 語文\t 數學\t 學號\t 年月：\n");
scanf("%s %d %d %d %d %d",pb->name,&pb->score[0],&pb->score[1],&pb->num,
&pb->t.year,&pb->t.month);
max = (a.num > b.num)?a:b;
max = (max.num > c.num)?max:c;
pb = &max; //結構體指針指向結構體變量max
printf("學號最大的人的對應的信息爲：\n");
printf("姓名\t 語文\t 數學\t 學號\t 年\t 月\n");
printf("%s\t %d\t %d\t %d\t %d\t %d\n",(*pb).name,(*pb).score[0],(*pb).score[1],(*pb).num,
(*pb).t.year,(*pb).t.month);
}
結構體指針指向結構體數組
#include <stdio.h>
struct BIR
{
int year;
int month;
};
struct NOM
{
char name[10]; //姓名 //15--->+1
int score[2]; //成績 //8--? 4+4
int num; //學號 //4
struct BIR t; //8
};
int main()
{
struct NOM a[3] = {
{"zhangsan",88,90,1101,2017,8},
{"zhoasi",89,90,1102,2018,7},
{"zhaosan",66,56,1103,2015,8}
};
int i;
struct NOM *p = a; //數組名是數組首元素地址，
//結構體指針指向結構體數組首元素的地址，其指針可以當成數組名
//p+i 表示元素 a+i == &a[i]
//結構體數組的賦值,實際上給數組的元素的成員進行賦值
//a[0] a[1] a[2]
//strcpy(a[0].name,"張三");
strcpy(p[0].name,"張三");
//a[0].t.year = 2018; //*a
(p+0)->t.year = 2018;
// a[1].score[0] = 100; //*(a+1)
(*(p+1)).score[0] = 100;
// a[2].num = 1106;
(p+2)->num = 1106;
(*(p+2)).score[1] = 100; //*(a+2)
//終端輸入
for(i = 0; i < 3; i++)
{
scanf("%s %d %d %d %d %d",(p+i)->name,&(p+i)->score[0],&(p+i)->score[1],&(p+i)->num,
&(p+i)->t.year,&(p+i)->t.month);
}
//打印
for(i = 0; i < 3; i++)
{
printf("%s %d %d %d %d %d\n",(*(p+i)).name,(*(p+i)).score[0],(*(p+i)).score[1],(*(p+i)).num,
(*(p+i)).t.year,(*(p+i)).t.month);
}
}