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

简介: C语言 自定义类型 之 【结构体】

前言


C语言中结构体是一种用户自定义的数据类型,它相当于一个小型的数据结构,当我们在学数据结构阶段的时候,结构体的运用很常见,所以,基本的结构体的定义和使用,以及结构体大小的计算务必掌握。


结构体类型的声明


  • 结构体的基础知识:

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


  • 声明的语法结构:
struct tag // 结构体类型名
{
 member-list; // 结构体成员
}variable-list; // 这里是可以直接在这里输入变量名,相当于创建了一个全局的结构体变量


例如定义一个学生变量(名字,年龄,学号):

struct stu 
{
  char Name[20];  // 名字以字符串的形式存储
  int Age;
  char StuNum[20];  // 学号也以字符串的形式存储,因为可能学号很长,整型存储不下
};  // 分号必不可少


  • 特殊的声明(结构体不完全声明):
    匿名结构体声明:
struct    // 省略了tag
{
    int a;
    char b;
}x; // 匿名结构体全局变量x
struct    // 省略了tag
{
    int a;
    char b;
}y;  // 匿名结构体全局变量y


如果有这样一种操作:

y = &x;


  • 这样合法么?
    当然是不行的,编译器会将这两个结构体变量当作是两个完全不同的两个类型,所以是非法的。


结构的自引用


如果在一个结构体成员当中包含本身,这样是否可行呢?

  • 假如这样写:
struct node
{
  int a;
  struct node next;   // 这样是否可行能?????
};


上面这种写法,很容易看出问题,会形成一个死循环。

  • 另外一种写法:
struct node
{
  int a;
  struct node* next;  // 一个结构体指针
};


如果是这样写,next是一个指针,因此不会死循环,并且,next还是一个结构体指针,也就是说,next可以指向下一个自身类型的结构体(指向本身类型的结构体变量)。

例如:

struct node s1, s2;
s1.next = &s2;


所以这种写法是可以的。

  • 我们再来看这一种写法:
typedef struct node
{
    int a;
    node* next;   
}node;


这样的写法是不行的,因为遵循从上到下的原则,typedef结构体为node,其名在定义next之后,所以不行。

修正后:

typedef struct node
{
    int a;
    struct node* next;   
}node;
node s1; 


结构体变量的定义和初始化

定义

#include <stdio.h>
struct rand
{
  int x;
  int y;
}p1;  //声明类型的同时定义全局结构体变量p1
struct rand p2;  //定义全局结构体变量p2
int main()
{
  struct rand p3;  // 定义局部结构体变量p3
  return 0;
}


  • 结构体嵌套:
struct tmp
{
  char a;
  int b;
};
struct rand
{
  int x;
  int y;
  struct tmp z;  // z为struct tmp类型,该类型有两个成员
}p1;  //声明类型的同时定义全局结构体变量p1
struct rand p2;  //定义全局结构体变量p2
int main()
{
  struct rand p3;  // 定义局部结构体变量p3
  return 0;
}


初始化

1.在main函数里初始化:

#include <stdio.h>
struct rand
{
  int x;
  int y;
}p1;
struct rand p2;
int main()
{
  p1.x = 5, p1.y = 2;
  p2.x = 5, p2.y = 2;
  struct rand p3 = { 5,2 };
  return 0;
}


2.创建变量时初始化:

#include <stdio.h>
struct rand
{
  int x;
  int y;
}p1 = { 5,2 }; // 在定义结构体的同时定义结构体变量p1,同时初始化p1
struct rand p2 = { 5,2 }; // main函数外
int main()
{
  struct rand p3 = { 5,2 };
  return 0;
}


3.结构体嵌套的初始化:


#include <stdio.h>
struct tmp
{
  char a;
  int b;
};
struct rand
{
  int x;
  int y;
  struct tmp z;
}p1;
struct rand p2;
int main()
{
  p1.x = 5;
  p1.y = 2;
  p1.z.a = 'i';
  p1.z.b = 0;
  p2.x = 5;
  p2.y = 2;
  p2.z.a = 'i';
  p2.z.b = 0;
  struct rand p3 = { 5,2,{'i', 0} };
  return 0;
}
#include <stdio.h>
struct tmp
{
  char a;
  int b;
};
struct rand
{
  int x;
  int y;
  struct tmp z;
}p1 = { 5,2,{'i', 0} };
struct rand p2 = {5, 2,{'i', 0} };
int main()
{
  struct rand p3 = { 5,2,{'i', 0} };
  return 0;
}


结构体内存对齐

  • 我们已经掌握了结构体的基本使用了。
  • 现在我们深入讨论一个问题:计算结构体的大小。
  • 这也是一个特别热门的考点: 结构体内存对齐

我们先看下面一个例子:

#include <stdio.h>
struct n1
{
  char a1;
  int x1;
  char b1;
};
struct n2
{
  char a2;
  char b2;
  int x2;
};
int main()
{
  printf("%d %d\n", (int)sizeof(struct n1), (int)sizeof(struct n2));
  return 0;
}


运行结果为:12 8

为什么运行结果会不一样呢??????

这就与结构体在内存中的存储形式有关,而结构体在内存中的存储结构方式又与结构体的内存对齐有关。


那么什么是内存对齐呢?

  1. 第一个成员在与结构体变量偏移量为0的地址处。
  2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
  3. 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
  4. VS中默认的对齐数值为8
  5. 结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。
  6. 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。



6a3e984df864460b8429509a4cdd2900.png

据此因为单个不同类型的成员的摆放位置不同,造成相同成员的两个结构体的大小不同,这是不是很奇妙呢?

  • 那么为什么要有内存对齐呢???

大部分的参考资料都是如是说的:


平台原因(移植原因):

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

性能原因:

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。


总体来说:

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

  • 那在设计结构体的时候,我们既要满足对齐,又要节省空间,如何做到:


就拿上面的那个例子来说,n1n2,两个相同成员的结构体,一个大小为12,一个大小为8,那当然要选小的那个了,也就是n2

  • 实际上我们可以在自己的编译器上修改默认对齐数

我们可以通过 #pragma 来修改默认对齐数


例如

#include <stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct n1
{
    char c1;
    int x;
    char c2;
};
#pragma pack()//取消设置的默认对齐数,还原为默认
#pragma pack(1)//设置默认对齐数为1
struct n2
{
    char c1;
    int x;
    char c2;
};
#pragma pack()//取消设置的默认对齐数,还原为默认
int main()
{
    //输出的结果是什么?
    printf("%d\n", sizeof(struct n1));
    printf("%d\n", sizeof(struct n2));
}


  • n1的默认对齐数修改为8,那也就跟之前一样,也就是12
  • n2的默认对齐数修改为1,也就相当于没有内存对齐一样,直接在下一个位置就存放,因此大小为6

如果结构体在对齐方式不合适的时候,那么我们可以自己更改默认对齐数。


结构体传参


对于下面的代码:

#include <stdio.h>
struct S
{
  double data[10000];
  int num
};
struct S s = { {1.0,2.0,3.0,4.0}, 1000 };
void print1(struct S s) // 结构体传参
{
  printf("%d\n", s.num);
}
void print2(struct S* ps) // 地址传递
{
  printf("%d\n", ps->num);
}
int main()
{
  print1(s); // 传结构体
  print2(&s); // 传结构体指针
  return 0;
}


是 print1 好还是 print2 好?

答案是:首选print2函数。

因为:

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

2.如果传递一个结构体对象的时候,结构体过大,参数压栈的的系统开销比较大, 所以会导致性能的下降。

所以:

当结构体传参的时候,要传递结构体的地址;


结构体实现位段


什么是位段?


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

1.位段的成员必须是 int、unsigned int 或signed int 。

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


例如:

struct rand
{
    char _a:2; 
    char _b:5;
    char _c:4;
    char _d:6;
 // 这里的  _  和  :  是位段定义的基本语法
 // 这里的  2,5,4,6  是所占比特位的个数
};


rand就是一个位段类型,那位段rand的大小是多少?


printf("%d\n", sizeof(struct rand)); vs运行结果为4

位段的内存分配


位段的成员可以是 int unsigned int signed int 或者是 char (属于整形家族)类型

位段的空间上是按照需要以4个字节( int )或者1个字节( char )的方式来开辟的。

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

#include <stdio.h>
typedef struct rand
{
  char _a : 2;
  char _b : 5;
  char _c : 4;
  char _d : 6;
}a;
int main()
{
  a a = { 4,4,10,5 };
  printf("%d\n", (int)sizeof(a));  // 3
  return 0;
}

e22cdd51b84d4592b5d102827e1741c9.png


3f07078cc1034697a8596fc578011d9b.png


然int是以4字节开辟,存储方式与char差不多,按照上面方式去弄也是很容易自己弄出来的噢。


位段的跨平台问题


  1. int 位段被当成有符号数还是无符号数是不确定的。
  2. 位段中最大位的数目不能确定。(16位机器最大16,32位机器最大32,写成27,在16位机器会出问题。)
  3. 位段中的成员在内存中从左向右分配,还是从右向左分配标准尚未定义。
  4. 当一个结构包含两个位段,第二个位段成员比较大,无法容纳于第一个位段剩余的位时,是舍弃剩余的位还是利用,这是不确定的。


所以:

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


位段的应用


7a29a57034224fb9a1942cbedf8a1d3e.png

写在最后


结构体的知识虽然较为简单,但其在数据结构当中的作用还是很重要的,因为一个数据它里面要有什么内容还是要结构体来整合。


感谢阅读本小白的博客,错误的地方请严厉指出噢!

相关文章
|
2月前
|
存储 C语言
如何在 C 语言中实现结构体的深拷贝
在C语言中实现结构体的深拷贝,需要手动分配内存并逐个复制成员变量,确保新结构体与原结构体完全独立,避免浅拷贝导致的数据共享问题。具体方法包括使用 `malloc` 分配内存和 `memcpy` 或手动赋值。
46 10
|
2月前
|
安全 编译器 Linux
【c语言】轻松拿捏自定义类型
本文介绍了C语言中的三种自定义类型:结构体、联合体和枚举类型。结构体可以包含多个不同类型的成员,支持自引用和内存对齐。联合体的所有成员共享同一块内存,适用于判断机器的大小端。枚举类型用于列举固定值,增加代码的可读性和安全性。文中详细讲解了每种类型的声明、特点和使用方法,并提供了示例代码。
26 3
|
2月前
|
存储 大数据 编译器
C语言:结构体对齐规则
C语言中,结构体对齐规则是指编译器为了提高数据访问效率,会根据成员变量的类型对结构体中的成员进行内存对齐。通常遵循编译器默认的对齐方式或使用特定的对齐指令来优化结构体布局,以减少内存浪费并提升性能。
|
2月前
|
编译器 C语言
共用体和结构体在 C 语言中的优先级是怎样的
在C语言中,共用体(union)和结构体(struct)的优先级相同,它们都是用户自定义的数据类型,用于组合不同类型的数据。但是,共用体中的所有成员共享同一段内存,而结构体中的成员各自占用独立的内存空间。
|
2月前
|
存储 C语言
C语言:结构体与共用体的区别
C语言中,结构体(struct)和共用体(union)都用于组合不同类型的数据,但使用方式不同。结构体为每个成员分配独立的内存空间,而共用体的所有成员共享同一段内存,节省空间但需谨慎使用。
|
2月前
|
编译器 C语言 C++
C语言结构体
C语言结构体
28 5
|
2月前
|
编译器 Linux C语言
C语言 之 结构体超详细总结
C语言 之 结构体超详细总结
21 0
|
2月前
|
存储 编译器 Linux
深入C语言:探索结构体的奥秘
深入C语言:探索结构体的奥秘
|
2月前
|
存储 编译器 C语言
c语言回顾-结构体(2)(下)
c语言回顾-结构体(2)(下)
31 0
|
2月前
|
存储 编译器 程序员
c语言回顾-结构体(2)(上)
c语言回顾-结构体(2)(上)
31 0