c/c++结构体的定义及使用：struct 和typedef struct详细总结（含代码实例）
结构体struct详解
数组（Array），它是一组具有相同类型的数据的集合。但在实际的编程过程中，我们往往还需要一组类型不同的数据，显然不能用一个数组来存放：
在C语言中，可以使用结构体（Struct） 来存放*一组不同类型的数据*。结构体的定义形式为：
struct 结构体名{
结构体所包含的变量或数组
};
结构体是一种集合，它里面包含了多个变量或数组，它们的类型可以相同，也可以不同，每个这样的变量或数组都称为结构体的成员（Member），如下：
struct student{
char *name;//姓名
int num;//学号
int age;//年龄
char group;//所在学习小组
float score;//成绩
};
student为结构体名，它包含了 5 个成员，分别是 name、num、age、group、score。结构体成员的定义方式与变量和数组的定义方式相同，只是不能初始化。
结构体也是一种数据类型，它由程序员自己定义，可以包含多个其他类型的数据。
struct结构体变量
既然结构体是一种数据类型，那么就可以用它来定义变量。例如：
struct student student1,student2;
定义了两个变量 student1 和 student2，它们都是 student 类型，都由 5 个成员组成。注意关键字struct不能少。
也可以在定义结构体的同时定义结构体变量（如下例所示）：
struct student{
char *name;//姓名
int num;//学号
int age;//年龄
char group;//所在学习小组
float score;//成绩
};stduent1,student2;
将变量放在结构体定义的最后即可。
如果只需要 student1、student2 两个变量，后面不需要再使用结构体名定义其他变量，那么在定义时也可以不给出结构体名，如下所示：
struct{//无需写出student
char *name;//姓名
int num;//学号
int age;//年龄
char group;//所在学习小组
float score;//成绩
};stduent1,student2;
这样写的优点就是简单，缺点就是由于没有结构体名，后面无法用该结构定义新的变量。
理论上讲结构体的各个成员在内存中是连续存储的，和数组非常类似，例如上面的结构体变量 student1、student2 的内存分布如下图所示，共占用 4+4+4+1+4 = 17 个字节。
但是在编译器的具体实现中，各个成员之间可能会存在缝隙，对于 student1、student2，成员变量 group 和 score 之间就存在 3 个字节的空白填充（见下图）。这样算来，student1、student2 其实占用了 17 + 3 = 20 个字节。
一般形式
第一种： 只有结构体定义
struct stuff{
char job[20];
int age;
float height;
};
struct stuff Huqinwei = {"manager",30,185}; //声明
Huqinwei.job[0] = 'M';
Huqinwei.job[1] = 'a';
Huqinwei.age = 27;
Huqinwei.height = 185;
第二种： 附加变量初始化的结构体定义
//直接带变量名Huqinwei
struct stuff{
char job[20];
int age;
float height;
}Huqinwei= {"manager",30,185};
其实这就相当于：
//直接带变量名Huqinwei
struct stuff{
char job[20];
int age;
float height;
};
struct stuff Huqinwei;
第三种： 如果该结构体你只用一个变量Huqinwei，而不再需要用
struct stuff yourname;
成员的获取和赋值
获取结构体成员的一般格式为：
结构体变量名.成员名;
通过这种方式可以获取成员的值也可以给成员赋值：
#include<stdio.h>
int main(){
struct student{
char *name;//姓名
int num;//学号
int age;//年龄
char group;//所在学习小组
float score;//成绩
};stduent1;
//给结构体成员赋值
student1.name = "Tom";
student1.num = 12;
student1.age = 18;
student1.group = 'A';
student1.score = 136.5;
//读取结构体成员的值
printf("%s的学号是%d，年龄是%d，在%c组，今年的成绩是%.1f！\n", student1.name, student1.num, student1.age, student1.group, student1.score);
return 0;
}
运行结果为：
Tom的学号是12，年龄是18，在A组，今年的成绩是136.5！
除了可以对成员进行逐一赋值，也可以在定义时整体赋值，例如：
struct student{
char *name; //姓名
int num; //学号
int age; //年龄
char group; //所在小组
float score; //成绩
} student1, student2 = { "Tom", 12, 18, 'A', 136.5 };
不过整体赋值仅限于定义结构体变量的时候，在使用过程中只能对成员逐一赋值。
需要注意的是，结构体是一种自定义的数据类型，是创建变量的模板，不占用内存空间；结构体变量才包含了实实在在的数据，需要内存空间来存储
指针和数组
结构体成员变量的访问除了可以借助符号"."，还可以用"->"访问。
struct stuff *ref = &Huqinwei;
ref->age = 100;
printf("age is:%d\n",Huqinwei.age);
指针也是一样的
struct stuff *ptr;
ptr->age = 200;
printf("age is:%d\n",Huqinwei.age);
结构体也不能免俗，必须有数组
struct test{
int a[3];
int b;
};
//对于数组和变量同时存在的情况，有如下定义方法：
struct test student[3] = {{{66,77,55},0},
{{44,65,33},0},
{{46,99,77},0}};
//特别的，可以简化成：
struct test student[3] = {{66,77,55,0},
{44,65,33,0},
{46,99,77,0}};
数组成员赋值
typedef struct
{
char key[15]; //结点的关键字
char name[20];
int age;
}student ; //定义结点类型，可定义为简单类型，也可定义为结构
strcpy(student.name,"sss");
结构体嵌套
//对于“一锤子买卖”，其中A、B可删，不过最好带着
struct A{
struct B{
int c;
} b;
} a;
//使用如下方式访问：
a.b.c = 10;
特别的,可以一边定义结构体B，一边就使用上：
struct A{
struct B{
int c;
}b;
struct B sb;
}a;
使用方法与测试：
a.b.c = 11;
printf("%d\n",a.b.c);
a.b.c = 22;
printf("%d\n",a.sb.c);
//结果无误。
结构体与函数
关于传参，首先：
void func(int);
func(a.b.c);
把结构体中的int成员变量当做和普通int变量一样的东西来使用，是不用脑子就想到的一种方法。
另外两种就是传递副本和指针了 ：
//struct A定义同上
//设立了两个函数，分别传递struct A结构体和其指针。
void func1(struct A a){
printf("%d\n",a.b.c);
}
void func2(struct A* a){
printf("%d\n",a->b.c);
}
main(){
a.b.c = 112;
struct A * pa;
pa = &a;
func1(a);
func2(&a);
func2(pa);
}
结构体typedef struct详解
typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和 自定义的数据类型（struct等）。
在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。
1、typedef的最简单使用
typedef long byte_4;
作用：给已知数据类型long起个新名字，叫byte_4。
2、typedef与结构结合使用
typedef struct tagMyStruct
{
int iNum;
long lLength;
} MyStruct;
这语句实际上完成两个操作：
1) 定义一个新的结构类型
struct tagMyStruct
{
int iNum;
long lLength;
};
分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。
2) typedef为这个新的结构起了一个名字，叫MyStruct。
typedef struct tagMyStruct MyStruct;
一般形式
形式一
我们使用：
typedef struct student{
int age;
char s;
} Stu
在定义结构体变量的时候，可以使用
Stu student1;
也可以省略掉student:
typedef struct{
int age;
char s;
} Stu
在定义结构体变量的时候，依然可以使用
Stu student1;
形式二
typedef struct
{
int num;
int age;
}stu1,stu2,stu3;
相当于
typedef struct
{
int num;
int age;
}stu1；
typedef stu1 stu2;
typedef stu1 stu3;
typedef struct的用法实践
第一种情况中，Victor 将来可以作为一个变量类型来使用 ，就像 int一样去定义变量，vicptr则是指向Victor类的指针类型，在第二种情况中，我们并不能直接使用 Vic 来定义变量，但是在用stu定义的变量，最终的类型却是Vic。第三种情况中，victor3 是个指针类型的变量，指针必须要给定指向的变量，如victor1，否则程序就会报错，通过修改指针victor3，我们成功修改了victor1的值。
/* 1 */
typedef struct {
int age;
int weight;
}Victor, *vicptr;
/* 2 */
typedef struct Vic {
int age;
int weight;
}stu;
void main(){
Victor victor1;
victor1.age = 22;
victor1.weight = 69;
stu victor2;
victor2.age = 24;
victor2.weight = 70;
vicptr victor3;
victor3 = &victor1;
victor3->age = 25;
victor3->weight = 71;
}
运行结果如下：
用途1
定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。
比如：
char* pa, pb; // 这多数不符合我们的意图，它只声明了一个指向字符变量的指针和一个字符变量；
以下则可行：
typedef char* PCHAR; // 一般用大写
PCHAR pa, pb; // 可行，同时声明了两个指向字符变量的指针
虽然：
char *pa, *pb;
也可行，但相对来说没有用typedef的形式直观，尤其在需要大量指针的地方，typedef的方式更省事。
用途2
以前的代码中，声明struct新对象时，必须要带上struct，即形式为：*struct 结构名 对象名 ，如：
struct tagPOINT1
{
int x;
int y;
};
struct tagPOINT1 p1;
而在C++中，则可以直接写：结构名 对象名，即：
tagPOINT1 p1;
经常多写一个struct太麻烦了，于是就发明了：
typedef struct tagPOINT
{
int x;
int y;
}POINT;
POINT p1; // 这样就比原来的方式少写了一个struct，比较省事，尤其在大量使用的时候
定义结构体数组类型
规范
typedef int arrs[5];
typedef arrs * p_arr5;
typedef p_arr5 arrp10[10];
arr5 togs; // togs是具有5个元素的int数组
p_arr5 p2; // p2是一个指针，指向具有元素的数组
arrp10 ap; // ap是具有十个元素的指针数组，每个指针指向具有5个元素的int数组
例子
typedef struct VertexNode
{
char data;
int weitht;
struct EdgeNode * firstEdge;
}VertexNode,AdjList[MAX_VERTEX];
这里AdjList就是结构体数组类型
AdjList adjlist;
等价于
struct VertexNode adjlist[MAX_VERTEX];
同样情况
typedef int arr[5];
arr a;//就定义了一个有5个int型变量的数组a。
定义结构体指针
规范
typedef struct ANSWER_HEADER
{
u8 u8Type;
u8 u8Code;
u32 u32TimeStamp;
struct ANSWER_HEADER *pNext;
}ANSWER_HEADER_T, *PANSWER_HEADER_T;
ANSWER_HEADER为结构名，这个名字主要是为了在结构体中包含自己为成员变量的时候有用
ANSWER_HEADER_T为struct ANSWER_HEADER的别名
PANSWER_HEADER_T为struct ANSWER_HEADER*的别名
上面的定义方式等价于：
struct ANSWER_HEADER
{
u8 u8Type;
u8 u8Code;
u32 u32TimeStamp;
struct ANSWER_HEADER *pNext;
};
typedef struct ANSWER_HEADER ANSWER_HEADER_T;
typedef struct ANSWER_HEADER *PANSWER_HEADER_T;
定义实现
定义一个名为TreeNode的结构体，和指向该结构体类型的指针PtrToTreeNode （不使用typedef） ：
struct TreeNode
{
int Element;
struct TreeNode* LeftChild;
struct TreeNode* RightChild;
};
struct TreeNode *PtrToTreeNode； //定义指针
使用typedef关键字用一个单词Node代替struct TreeNode，并定于指向该结构体类型的指针PtrToTreeNode：
struct TreeNode
{
int Element;
struct TreeNode* LeftChild;
struct TreeNode* RightChild;
};
typedef struct TreeNode Node; //用Node代替struct TreeNode
Node *PtrToTreeNode; //定义指针
将结构体的定义和typedef连在一起写，再次缩短代码：
typedef struct TreeNode
{
int Element;
struct TreeNode* LeftChild;
struct TreeNode* RightChild;
}Node; //定义结构体并用Node代替struct TreeNode
Node *PtrToTreeNode; //定义指针
还可以继续缩短代码，直接定义了指向结构体类型的指针，但是这种写法没有为结构体起一个别名。
typedef struct TreeNode
{
int Element;
struct TreeNode* LeftChild;
struct TreeNode* RightChild;
} *PtrToTreeNode; //直接定义指针
在c和c++中struct和typedef struct的区别
区别一
struct _x1 { ...}x1;
//定义了类_x1和_x1的对象实例x1
typedef struct _x2{ ...} x2;
//定义了类_x2和_x2的类别名x2
区别二
typedef struct {
int data;
int text;
} S1; //这种方法可以在c或者c++中定义一个S1结构
struct S2 {
int data;
int text;
}; // 这种定义方式只能在C++中使用，而如果用在C中，那么编译器会报错
struct {
int data;
int text;
} S3; //这种方法并没有定义一个结构，而是定义了一个s3的结构变量，编译器会为S3内存。
void main()
{
S1 mine1;// OK ,S1 是一个类型
S2 mine2;// OK,S2 是一个类型
S3 mine3;// ERROR,S3 不是一个类型
S1.data = 5;// ERROR,S1 是一个类型
S2.data = 5;// ERROR,S2 是一个类型
S3.data = 5;// OK,S3是一个变量
}
//另外，对与在结构中定义结构本身的变量也有几种写法
struct S6 {
S6* ptr;
};
// 这种写法只能在C++中使用
typedef struct {
S7* ptr;
} S7;
// 这是一种在C和C++中都是错误的定义
简单理解：
struct Student
{
int a;
}stu1;//stu1是一个变量
typedef struct Student2
{
int a;
}stu2;//stu2是一个结构体类型
//使用时可以直接访问stu1.a
//但是stu2则必须先 stu2 s2;
//然后 s2.a=10;
区别三
typedef struct tagMyStruct
{
int iNum;
long lLength;
} MyStruct;
在C中，这个申明后申请结构变量的方法有两种：
（1）struct tagMyStruct 变量名
（2）MyStruct 变量名
在c++中可以有
（1）struct tagMyStruct 变量名
（2）MyStruct 变量名
（3）tagMyStruct 变量名
综合实例
Test1
#include <iostream>
using namespace std;
typedef struct _point{
int x;
int y;
}point; //定义类，给类一个别名
struct _hello{
int x,y;
} hello; //同时定义类和对象
int main()
{
point pt1;
pt1.x = 2;
pt1.y = 5;
cout<< "ptpt1.x=" << pt1.x << "pt.y=" <<pt1.y <<endl;
//hello pt2;
//pt2.x = 8;
//pt2.y =10;
//cout<<"pt2pt2.x="<< pt2.x <<"pt2.y="<<pt2.y <<endl;
//上面的hello pt2;这一行编译将不能通过. 为什么?
//因为hello是被定义了的对象实例了.
//正确做法如下: 用hello.x和hello.y
hello.x = 8;
hello.y = 10;
cout<< "hellohello.x=" << hello.x << "hello.y=" <<hello.y <<endl;
return 0;
}
Test2
//以下student是标识符（标识符是用户编程时使用的名字，对于变量、常量、函数、语句块也有名
//字；），stu则为变量类型（类比int和char等）,pstu相当于（int*）。
typedef struct student{
string name;
int age;
}stu,*pstu;
//C++中,ss为结构体类型
struct ss{
string name;
int age;
};
int main(){
//变量类型==struct+标识符
//使用变量类型+结构变量名
stu xiaoming;
//或者使用stuct+标识符+结构变量名
struct student zhangsan;
//c++ struct+结构变量名
ss lisi;
xiaoming.name="xiaoming";
xiaoming.age=18;
zhangsan.name="zhangsan";
zhangsan.age=17;
lisi.name="lisi";
}
Test3 typedef与数组类型、数组指针
typedef int num[5]; //定义数组类型
typedef char *num1[5]; //定义指针数组类型
typedef int(*num2)[5]; //定义指向多维数组的指针类型
int (*num3)[5]; //定义指向多维数组的指针变量
测试程序：
#include <stdio.h>
#include <stdlib.h>
typedef int num[5]; //定义数组类型
typedef char *num1[5]; //定义指针数组类型
typedef int(*num2)[5]; //定义指向多维数组的指针类型
int (*num3)[5]; //定义指向多维数组的指针变量
int main() {
int i, j;
num a; //等价于 int a[5];
num *b = NULL;
b = &a;
for (i = 0;i < 5;i++)
(*b)[i] = i;
for (i = 0;i < 5;i++)
printf("%d\n", (*b)[i]); //这一段完成了对num 以及num *的测试
int c[][5] = { {1,2,3,4,5},{6,7,8,9,10} };
num2 d;
d = c;
for (i = 0;i < 2;i++)
for (j = 0;j < 5;j++)
printf("%d\n", c[i][j]);
num3 = c;
for (i = 0;i < 2;i++)
for (j = 0;j < 5;j++)
printf("%d\n", num3[i][j]); //这一段完成了num2 num3的测试
num1 e;
for (i = 0;i < 5;i++) {
e[i] = (int *)malloc(sizeof(char)*10);
strcpy(e[i], "hello");
}
for (i = 0;i < 5;i++)
printf("%s\n", e[i]); //这一段完成了 num1的测试
system("pause");
}
说明：
a是一个整型数组名，数组含有5个元素，b是num * 类型，只能指向num类型（也就是函数5个整型元素的数组）
c是一个指针数组，每个元素是一个指针
d是一个指向二维数组的指针变量，二维数组的列数是5
Test4 结构体指针（二层指针）
#include <iostream>
using namespace std;
typedef struct {
int x;
int y;
}point,*_point; //定义类，给类一个别名
//验证 typedef point * _point;
int main()
{
_point *hp;
point pt1;
pt1.x = 2;
pt1.y = 5;
_point p;
p = &pt1;
hp = &p;
cout<< pt1.x<<" "<<pt1.y <<endl;
cout<< (**hp).x <<" "<< (**hp).y <<endl;
return 0;
}
//运行结果：2 5
// 2 5
参考链接
https://blog.csdn.net/m0_37973607/article/details/78900184.
https://blog.csdn.net/zhanghow/article/details/53463825.
https://blog.csdn.net/u013273161/article/details/83793122.
https://blog.csdn.net/weixin_41127779/article/details/82023671.
https://blog.csdn.net/mpp_king/article/details/70229150.
https://blog.csdn.net/haiou0/article/details/6877718.
https://blog.csdn.net/qq_37962204/article/details/78240757.
https://blog.csdn.net/wzz110011/article/details/78883838.
https://blog.csdn.net/zyh821351004/article/details/47961967.
https://blog.csdn.net/u013632190/article/details/47720703.
694
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
