struct和typedef区别 (完整标题:c/c++结构体的定义及使用：struct和typedef struct详细总结（含代码实例）)

c/c++结构体的定义及使用：struct 和typedef struct详细总结（含代码实例）

• 结构体struct详解
• • struct结构体变量
• 一般形式
• 成员的获取和赋值
• 指针和数组
• • 数组成员赋值
  • 结构体嵌套
  • 结构体与函数
• 结构体typedef struct详解
• • 一般形式
• • 形式一
  • 形式二
• typedef struct的用法实践
• • 用途1
  • 用途2
• 定义结构体数组类型
• • 规范
  • 例子
• 定义结构体指针
• • 规范
  • 定义实现
• 在c和c++中struct和typedef struct的区别
• • 区别一
  • 区别二
  • 区别三
• 综合实例
• • Test1
• Test2
• Test3 typedef与数组类型、数组指针
• Test4 结构体指针（二层指针）
• 参考链接

结构体struct详解

数组（Array），它是一组具有相同类型的数据的集合。但在实际的编程过程中，我们往往还需要一组类型不同的数据，显然不能用一个数组来存放：

在C语言中，可以使用结构体（Struct） 来存放一组不同类型的数据。结构体的定义形式为：

struct 结构体名{ 结构体所包含的变量或数组 };

• 1
• 2
• 3

结构体是一种集合，它里面包含了多个变量或数组，它们的类型可以相同，也可以不同，每个这样的变量或数组都称为结构体的成员（Member），如下：

struct student{ char *name;//姓名 int num;//学号 int age;//年龄 char group;//所在学习小组 float score;//成绩 };

• 1
• 2
• 3
• 4
• 5
• 6
• 7

student为结构体名，它包含了 5 个成员，分别是 name、num、age、group、score。结构体成员的定义方式与变量和数组的定义方式相同，只是不能初始化。 结构体也是一种数据类型，它由程序员自己定义，可以包含多个其他类型的数据。

struct结构体变量

既然结构体是一种数据类型，那么就可以用它来定义变量。例如：

struct student student1,student2;

• 1

定义了两个变量 student1 和 student2，它们都是 student 类型，都由 5 个成员组成。注意关键字struct不能少。

也可以在定义结构体的同时定义结构体变量（如下例所示）：

struct student{ char *name;//姓名 int num;//学号 int age;//年龄 char group;//所在学习小组 float score;//成绩 };stduent1,student2;

• 1
• 2
• 3
• 4
• 5
• 6
• 7

将变量放在结构体定义的最后即可。 如果只需要 student1、student2 两个变量，后面不需要再使用结构体名定义其他变量，那么在定义时也可以不给出结构体名，如下所示：

struct{//无需写出student char *name;//姓名 int num;//学号 int age;//年龄 char group;//所在学习小组 float score;//成绩 };stduent1,student2;

• 1
• 2
• 3
• 4
• 5
• 6
• 7

这样写的优点就是简单，缺点就是由于没有结构体名，后面无法用该结构定义新的变量。

理论上讲结构体的各个成员在内存中是连续存储的，和数组非常类似，例如上面的结构体变量 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}; //声明

• 1
• 2
• 3
• 4
• 5
• 6

Huqinwei.job[0] = 'M';
Huqinwei.job[1] = 'a';
Huqinwei.age = 27;
Huqinwei.height = 185;

• 1
• 2
• 3
• 4

第二种： 附加变量初始化的结构体定义

//直接带变量名Huqinwei
struct stuff{
char job[20];
int age;
float height;
}Huqinwei= {"manager",30,185};

• 1
• 2
• 3
• 4
• 5
• 6

其实这就相当于：

//直接带变量名Huqinwei
struct stuff{
char job[20];
int age;
float height;
};
struct stuff Huqinwei;

• 1
• 2
• 3
• 4
• 5
• 6
• 7

第三种： 如果该结构体你只用一个变量Huqinwei，而不再需要用

struct stuff yourname;

• 1

成员的获取和赋值

获取结构体成员的一般格式为：

结构体变量名.成员名;

• 1

通过这种方式可以获取成员的值也可以给成员赋值：

#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！

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

除了可以对成员进行逐一赋值，也可以在定义时整体赋值，例如：

struct student{ char *name; //姓名 int num; //学号 int age; //年龄 char group; //所在小组 float score; //成绩 } student1, student2 = { "Tom", 12, 18, 'A', 136.5 };

• 1
• 2
• 3
• 4
• 5
• 6
• 7

不过整体赋值仅限于定义结构体变量的时候，在使用过程中只能对成员逐一赋值。 需要注意的是，结构体是一种自定义的数据类型，是创建变量的模板，不占用内存空间；结构体变量才包含了实实在在的数据，需要内存空间来存储

指针和数组

结构体成员变量的访问除了可以借助符号"."，还可以用"->"访问。

struct stuff *ref = &Huqinwei;
ref->age = 100;
printf("age is:%d\n",Huqinwei.age);

• 1
• 2
• 3

指针也是一样的

struct stuff *ptr;
ptr->age = 200;
printf("age is:%d\n",Huqinwei.age);

• 1
• 2
• 3

结构体也不能免俗，必须有数组

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}};

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

数组成员赋值

typedef struct { char key[15]; //结点的关键字 char name[20]; int age; }student ; //定义结点类型，可定义为简单类型，也可定义为结构

strcpy(student.name,"sss");

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

结构体嵌套

//对于“一锤子买卖”，其中A、B可删，不过最好带着
struct A{
struct B{
int c;
} b;
} a;
//使用如下方式访问：
a.b.c = 10;

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

特别的,可以一边定义结构体B，一边就使用上：

struct A{
struct B{
int c;
}b;
struct B sb;
}a;

• 1
• 2
• 3
• 4
• 5
• 6

使用方法与测试：

  a.b.c = 11;  
  printf("%d\n",a.b.c);  
  a.b.c = 22;  
  printf("%d\n",a.sb.c);  
	//结果无误。   

• 1
• 2
• 3
• 4
• 5

结构体与函数

关于传参，首先：

void func(int);
func(a.b.c);

• 1
• 2

把结构体中的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);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

结构体typedef struct详解

typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和 自定义的数据类型（struct等）。

在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。

1、typedef的最简单使用

typedef long byte_4;

• 1

作用：给已知数据类型long起个新名字，叫byte_4。 2、typedef与结构结合使用

typedef struct tagMyStruct { 　int iNum; 　long lLength; } MyStruct;

• 1
• 2
• 3
• 4
• 5

这语句实际上完成两个操作：

1. 定义一个新的结构类型

struct tagMyStruct { 　int iNum; 　long lLength; };

• 1
• 2
• 3
• 4
• 5

分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。 2) typedef为这个新的结构起了一个名字，叫MyStruct。

typedef struct tagMyStruct MyStruct;

• 1

一般形式

形式一

我们使用：

typedef struct student{ int age; char s; } Stu

• 1
• 2
• 3
• 4

在定义结构体变量的时候，可以使用

Stu student1;

• 1

也可以省略掉student:

typedef struct{ int age; char s; } Stu

• 1
• 2
• 3
• 4

在定义结构体变量的时候，依然可以使用

Stu student1;

• 1

形式二

　typedef struct
　　　{ 　　　　int num; 　　　　int age; 　　　}stu1,stu2,stu3;

• 1
• 2
• 3
• 4
• 5

相当于

　typedef struct
　　　{ 　　　　int num; 　　　　int age; 　　　}stu1； 　typedef stu1 stu2; 　typedef stu1 stu3;

• 1
• 2
• 3
• 4
• 5
• 6
• 7

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
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

运行结果如下：

用途1

定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。 比如：

char* pa, pb; // 这多数不符合我们的意图，它只声明了一个指向字符变量的指针和一个字符变量；

• 1

以下则可行：

typedef char* PCHAR; // 一般用大写 PCHAR pa, pb; // 可行，同时声明了两个指向字符变量的指针

• 1
• 2

虽然：

char *pa, *pb;

• 1

也可行，但相对来说没有用typedef的形式直观，尤其在需要大量指针的地方，typedef的方式更省事。

用途2

以前的代码中，声明struct新对象时，必须要带上struct，即形式为：*struct 结构名 对象名 ，如：

struct tagPOINT1 { int x; int y; }; struct tagPOINT1 p1;

• 1
• 2
• 3
• 4
• 5
• 6

而在C++中，则可以直接写：结构名 对象名，即：

tagPOINT1 p1;

• 1

经常多写一个struct太麻烦了，于是就发明了：

typedef struct tagPOINT { int x; int y; }POINT;

• 1
• 2
• 3
• 4
• 5

POINT p1; // 这样就比原来的方式少写了一个struct，比较省事，尤其在大量使用的时候

• 1

定义结构体数组类型

规范

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数组

• 1
• 2
• 3
• 4
• 5
• 6

例子

typedef struct VertexNode { char data; int weitht; struct EdgeNode * firstEdge; }VertexNode,AdjList[MAX_VERTEX];

• 1
• 2
• 3
• 4
• 5
• 6

这里AdjList就是结构体数组类型

AdjList adjlist;

• 1

等价于

struct VertexNode adjlist[MAX_VERTEX];

• 1

同样情况

typedef int arr[5]; arr a;//就定义了一个有5个int型变量的数组a。

• 1
• 2

定义结构体指针

规范

typedef struct ANSWER_HEADER { u8 u8Type; u8 u8Code; u32 u32TimeStamp; struct ANSWER_HEADER *pNext; }ANSWER_HEADER_T, *PANSWER_HEADER_T;

• 1
• 2
• 3
• 4
• 5
• 6
• 7

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;

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

定义实现

定义一个名为TreeNode的结构体，和指向该结构体类型的指针PtrToTreeNode （不使用typedef） ：

struct TreeNode { int Element; struct TreeNode* LeftChild; struct TreeNode* RightChild; }; struct TreeNode *PtrToTreeNode； //定义指针

• 1
• 2
• 3
• 4
• 5
• 6
• 7

使用typedef关键字用一个单词Node代替struct TreeNode，并定于指向该结构体类型的指针PtrToTreeNode：

struct TreeNode { int Element; struct TreeNode* LeftChild; struct TreeNode* RightChild; }; typedef struct TreeNode Node; //用Node代替struct TreeNode Node *PtrToTreeNode; //定义指针

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

将结构体的定义和typedef连在一起写，再次缩短代码：

typedef struct TreeNode { int Element; struct TreeNode* LeftChild; struct TreeNode* RightChild; }Node; //定义结构体并用Node代替struct TreeNode Node *PtrToTreeNode; //定义指针

• 1
• 2
• 3
• 4
• 5
• 6
• 7

还可以继续缩短代码，直接定义了指向结构体类型的指针，但是这种写法没有为结构体起一个别名。

typedef struct TreeNode { int Element; struct TreeNode* LeftChild; struct TreeNode* RightChild; } *PtrToTreeNode; //直接定义指针

• 1
• 2
• 3
• 4
• 5
• 6

在c和c++中struct和typedef struct的区别

区别一

struct _x1 { ...}x1; //定义了类_x1和_x1的对象实例x1 typedef struct _x2{ ...} x2; //定义了类_x2和_x2的类别名x2

• 1
• 2
• 3
• 4

区别二

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++中都是错误的定义

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

简单理解：

struct Student { int a; }stu1;//stu1是一个变量 typedef struct Student2 { int a; }stu2;//stu2是一个结构体类型 //使用时可以直接访问stu1.a //但是stu2则必须先 stu2 s2; //然后 s2.a=10;

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

区别三

typedef struct tagMyStruct 　　　　{ 　　　　　int iNum; 　　　　　long lLength; 　　　　} MyStruct;

• 1
• 2
• 3
• 4
• 5

在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; }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29

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"; }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

参考链接

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.