【C语言】自定义类型：结构体

Posted on by hackdl

1、结构体类型的声明

1.1、结构体的概念

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

1.2、结构的声明

struct tag
{
 member-list;
}variable-list;

在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct 
{
  int a;
  char b;
  double c;
} s1;

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE
{
  int a;
  char b;
  double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;

//也可以用typedef创建新类型
typedef struct
{
  int a;
  char b;
  double c; 
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2[20], *u3;

在上面的声明中，第一个和第二个声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的，如果令 t3=&s1，则是非法的。

1.3、结构的自引用

在结构中包含⼀个类型为该结构本⾝的成员是否可以呢？
⽐如，定义⼀个链表的节点：

struct Node
{
	int data;
  struct Node next;
};

上述代码正确吗？如果正确，那 sizeof(struct Node) 是多少？
仔细分析，其实是不行的，因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的大小就会无穷的大，是不合理的。
正确的自引用方式： 

struct Node
{
 int data;
 struct Node* next;//现在运用结构体指针后大小就是可算的
};

在结构体自引用使用的过程中，夹杂了typedef对匿名结构体类型重命名，也容易引入问题，看看下面的代码，可行吗？

typedef struct
{
 int data;
 Node* next;
}Node;

答案是不行的，因为Node是对前面的匿名结构体类服务器托管网型的重命名产生的，但是在匿名结构体内部提前使用Node类型来创建成员变量，这是不行的。

解决方案如下：定义结构体不要使用匿名结构体了

typedef struct Node
{
 int data;
 struct Node* next;
}Node;

2、结构体变量的创建和初始化

有了结构体类型，那如何定义变量，其实很简单，结构体变量的初始化使用{}

#include 
struct Books
{
 char title[50];
 char author[50];
 char subject[100];
 int  book_id;
} book = {"C 语言", "RUNOOB", "编程语言", 123456};

int main()
{
  printf("title : %snauthor: %snsubject: %snbook_id: %dn", book.title, book.author, book.subject, book.book_id);
}

执行结果：

title : C 语言
author: RUNOOB
subject: 编程语言
book_id: 123456

常见初始化

struct Point
{
 int x;
 int y;
}p1;      							//声明类型的同时定义变量p1 
struct Point p2; 				//定义结构体变量p2 

//初始化：定义变量的同时赋初值。 
struct Point p3 = {x, y};

struct Stu 					//类型声明
{
 char name[15];			//名字 
 int age; 					//年龄 
};
struct Stu s = {"zhangsan", 20};//初始化 

struct Node
{
 int data;
 struct Point p;
 struct Node* next; 服务器托管网
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化 

struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

3、结构成员访问操作符

结构成员访问操作符有两个，分别是 . 和 ->

形式如下：

结构体变量.成员变量名
结构体指针—>成员变量名

举例：

#include 
#include 

struct Stu
{
 char name[15];//名字 
 int age; //年龄 
};

void print_stu(struct Stu s)
{
 printf("%s %dn", s.name, s.age);
}

void set_stu(struct Stu* ps)
{
 strcpy(ps->name, "李四");
 ps->age = 28;
}

int main()
{
 struct Stu s = { "张三", 20 };
 print_stu(s);
 set_stu(&s);
 print_stu(s);
 return 0;
}

4、结构体内存对齐

我们已经掌握了结构体的基本使用了。

现在我们深入讨论一个问题：计算结构体的大小。这也是⼀个特别热门的考点： 结构体内存对齐

4.1、对齐规则

1.结构体的第⼀个成员对⻬到相对结构体变量起始位置偏移量为0的地址处

2.其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。

对⻬数=编译器默认的⼀个对⻬数与该成员变量⼤⼩的较⼩值。

-VS中默认的值为8

-Linux中没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

3.结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的的整数倍。

4.如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构
体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

//练习1 
struct S1
{
 char c1;
 int i;
 char c2;
};
printf("%dn", sizeof(struct S1));

//练习2 
struct S2
{
 char c1;
 char c2;
 int i;
};
printf("%dn", sizeof(struct S2));

//练习3 
struct S3
{
 double d;
 char c;
 int i;
};
printf("%dn", sizeof(struct S3));

//练习4-结构体嵌套问题 
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};
printf("%dn", sizeof(struct S4));

4.2、为什么存在内存对齐？

1、平台原因（移植原因）：

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2、性能原因：

数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。

总的来说：结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满⾜对⻬，⼜要节省空间，如何做到：

让占⽤空间⼩的成员尽量集中在⼀起

//例如： 
struct S1
{
 char c1;
 int i;
 char c2;
};

struct S2
{
 char c1;
 char c2;
 int i;
};

int main(){
	printf("%zdn",sizrof(struct s1));
  printf("%zdn",sizrof(struct s2));
}

S1 和 S2 类型的成员⼀模⼀样，但是 S1 和 S2 所占空间的大小有了⼀些区别。

4.3、修改默认对齐数

#pragma 这个预处理指令，可以改变编译器的默认对齐数。

#include 

#pragma pack(1)//设置默认对⻬数为1 
struct S
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对⻬数，还原为默认 

struct SL
{
 char c1;
 int i;
 char c2;
};

int main()
{
 //输出的结果是什么？ 
 printf("%dn", sizeof(struct S));
 printf("%dn", sizeof(struct SL));
 return 0;
}

5、结构体传参

struct S
{
 int data[1000];
 int num;
};

struct S s = {{1,2,3,4}, 1000};

//结构体传参 
void print1(struct S s)
{
 printf("%dn", s.num);
}

//结构体地址传参 
void print2(struct S* ps)
{
 printf("%dn", ps->num);
}

int main()
{
 print1(s); //传结构体 
 print2(&s); //传地址 
 return 0;
}

上面的print2 和 print1 函数哪个好些？ —>首选print2函数

原因：

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。

结论：结构体传参的时候，要传结构体的地址。

6、结构体实现位段

6.1、什么是位段

位段的声明和结构是类似的，有两个不同：

1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以
选择其他类型。

2. 位段的成员名后边有⼀个冒号和⼀个数字。

比如：

struct A
{
 int _a:2;
 int _b:5;
 int _c:10;
 int _d:30;
};

int main(){
	printf("%dn", sizeof(struct A));
  return 0;
}

A就是一个位段类型，其所占内存的大小：

6.2、位段的内存分配

1、位段的成员可以是 int unsigned int signed int 或者是 char 等类型

2、位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的⽅式来开辟的。

3、位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段。

//⼀个例⼦ 
struct S
{
 char a:3;
 char b:4;
 char c:5;
 char d:4;
};

struct S s = {0};
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;

//空间是如何开辟的？

6.3、位段的跨平台问题

  1. int位段被当成有符号数还是⽆符号数是不确定的。
  2. 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会
    出问题。
  3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
  4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃
    剩余的位还是利⽤，这是不确定的。

总结：跟结构相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
机房租用，北京机房租用，IDC机房托管， http://www.fwqtg.net

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

服务器托管

咨询：董先生

电话13051898268 QQ/微信93663045！

上一篇:
下一篇: