Introduction to C language custom types (structure, enumeration, union, bit segment)

1. Structure

 1.1 Structure overview

1.1.1 Structure concept

C  Arrays allow you to define variables that can store items of the same type , Structure is  C  Another user-defined data type available in programming , It allows you to store different types of data items .

1.1.2  Declaration and use of structures

Declaration and definition of structure

// Structure
struct Stu
{
 char name[20];// full name
 char sex[5];// Gender
 char id[20];// Student number
 int age;// Age
 double grade;// achievement
}student;


among

struct Stu

Is a custom structure type , A series of data types in curly braces are called

Structural members

,

student

Variable for the structure type defined . Incomplete declaration of structure

// Anonymous struct type
struct
{
 int a;
 char b;
 float c; 
}x;

struct
{
 int a;
 char b;
 float c;
}a[20], *p;


The above two structures are declared without the structure label , However, structure variables can only be created after the structure declaration , In other cases, the structure variable cannot be created , This means that the structure pointer cannot be created , Even if you declare as like as two peas

p

, take

x

The address of is assigned to

p

The compiler will report an error , The compiler will deal with two completely different structures .

Self reference of structure

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


It is not advisable to nest structures directly in the same structure , You can imagine , If you can do this , What is the size of this structure , He will nest indefinitely , Cause stack overflow , If you just need to nest yourself , Pointers of the same structure type should be nested .

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


In the use of

typedef

When defining a structure self reference , Cannot be used directly in a structure

typedef

The replaced structure type name directly defines the structure pointer , Instead, you should define the structure pointer in the structure using the original type name definition .

// The wrong sample ：
typedef struct NODE
{
 int data;
 Node* next; 
}Node;

// The correct sample ：
typedef struct NODE
{
 int data;
 struct NODE* next; 
}Node;


Use and transfer of structures

#include <stdio.h>
int main()
{
 struct Stu s = { &quot; Zhang San &quot;,&quot; male &quot;,&quot;20210618&quot;,20,99 };// Structure declaration and initialization
 printf(&quot; full name ：%s\n&quot;, s.name);// Structure member access method 1： Structure variable name . Structure member name
 printf(&quot; Gender ：%s\n&quot;, s.sex);
 struct Stu* ps = &s;
 printf(&quot; Student number ：%s\n&quot;, ps->id);// Structure access member mode 2： Structure pointer -> Structure member name
 printf(&quot; Age ：%d\n&quot;, ps->age);
 printf(&quot;C Language test results ：%.2lf\n&quot;, ps->grade);
 return 0;
}


Running results ：

full name ： Zhang San
Gender ： male
Student number ：20210618
Age ：20
C Language test results ：99.00

D:\gtee\C-learning-code-and-project\test_922\Debug\test_922.exe ( process  26272) Exited , The code is  0.
Press any key to close this window . . .


For structure parameters , Try to use structure pointers to pass parameters , Because the direct transmission structure , When the structure is large , It will take up a lot of stack space , Even lead to stack overflow .

 1.2 Structure alignment and its size calculation

1.2.1 Offset

The offset in computer assembly language is defined as : The distance between the actual address of the storage unit and the segment address of the segment in which it is located is called the intra segment offset , Also known as " Valid address or offset ".

1.2.2 Calculation of structure size

The size of the structure is not as simple as adding up the sizes of all member variables , In fact, members need to be aligned in memory , stay vs The default alignment value in the compiler is

8

, In other compilation environments, there may be no default values , You can also default to other values . Of course , This default alignment value can be modified , have access to "pragma pack()" modify . If the alignment number is

1

, It is equivalent to that the structure has no memory alignment .

#pragma pack(4)// Set the default alignment number to 4
#pragma pack()// No parameter means the default value is 8（vs compiler ）


Then why do you need to align memory ？

• Platform reasons ( Reasons for transplantation )
  ： Not all hardware platforms can access any data on any address ; Some hardware platforms can only access certain types of data at certain addresses , Otherwise, a hardware exception will be thrown .

• Performance reasons ：
  data structure ( Especially stacks ) It should be aligned as far as possible on the natural boundary . The reason is to access misaligned memory , The processor needs to make two memory accesses ; The aligned memory access only needs one access .

Structure memory alignment rules ：

• [ ]  The offset between the first member of the structure and the structure is
  0
  .

• [ ]  Structure members need to be aligned to an integer multiple of the alignment number （ Offset ） It's about .

• [ ]  Each structure member has an alignment number , The alignment number is the smaller of the compiler default value and the structure member size .

• [ ]  The total size of the structure is the maximum number of alignments （ The largest alignment number of each member of the structure ） Integer multiple .

• [ ]  If there is a nested structure in the structure , The nested structure is aligned to an integral multiple of its maximum alignment , The overall size of the structure is the maximum number of alignments （ The number of alignments with nested structures ） Integer multiple .

// practice 1
struct S1
{
 char c1;
 int i;
 char c2;
};
// practice 2
struct S2
{
 char c1;
 char c2;
 int i;
};
// practice 3
struct S3
{
 double d;
 char c;
 int i;
};
// practice 4- Structure nesting problem
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};


practice 1：

char c1

First structure member , The size is

1

, The offset for the

0

, The alignment number is

1

, The memory locations are as follows ：

The second structure member

int i

, The size is

4

, The alignment number is

4

, Therefore, the offset to be stored is

4

The address at .

The third structure member

char c2

, The size is

1

, The alignment number is

1

, Offset

8

by

1

Integer multiple , therefore

c2

The deposit offset is

8

The location of .

Deposit in

c2

The rear structure uses a total of

9

Bytes , However, the structure size needs to be an integer multiple of the maximum alignment number , The maximum number of alignments in this structure is

4

, So the size of the structure should be

4

Integer multiple , The size is

12

.

practice 2： This is more practical 1 Structural body in , Put two

char

The type variable is advanced , That is to put smaller member variables together . Let's look at this structure compared to practice 1 Will the size of the structure change ！ The first structure member

c1

And practice 1 Same as the old position , Into the second structure member

c2

when , The size is

1

, The offset for the

1

, The alignment number is

1

Satisfy integer multiple relationship , therefore

c2

Deposit in

c1

After . The size of the third member is

4

, The offset for the

2

, The alignment number is

4

, The alignment number is not an integer multiple of the offset , So you want to offset from

4

Start saving at , After saving, the structure uses

8

Bytes , Satisfy the integer relationship of the maximum alignment number , So the size of this structure is

8

. We found that when we put the members of the structure with small space together as much as possible , The size of the structure becomes smaller , Therefore, when defining a structure, we try to gather the members of the structure with small space together .

practice 3:

double

by

8

byte , After saving, the offset becomes

8

, Then deposit

char

  The size is

1

, The offset after storage is

9

, Final deposit

int

The size is

4

, The alignment number is

4

, The offset from is

12

Start depositing , The structure uses a total of

16

byte , Satisfy the integer multiple of the maximum alignment , So the size of the structure is

16

.

practice 4: A structure is nested inside this structure

S3

, The maximum number of alignments for this structure is

8

, The size is

16

. First save a

char

, The size is

1

, After saving, the offset is

1

, Then save

S3

, The size is

16

, The maximum number of alignments is

8

, therefore

S3

The number of alignments for is

8

, So the offset from is

8

Start saving your address , After saving , The offset for the

24

, Last deposit

double

, The size is

8

, The alignment number is

8

, The offset from is

24

Start saving your address , After saving , The structure uses a total of

32

byte , Satisfy the integer multiple of the maximum structure member , So the size of the structure is

32

.

int main()
{
 printf("%d\n", sizeof(struct S1));
 printf("%d\n", sizeof(struct S2));
 printf("%d\n", sizeof(struct S3));
 printf("%d\n", sizeof(struct S4));
 return 0;
}


Running results ：

12
8
16
32

D:\gtee\C-learning-code-and-project\test_922\Debug\test_922.exe ( process  34308) Exited , The code is  0.
Press any key to close this window . . .


 1.3 Structure and bit segment

1.3.1 Bit segment

Bit segment , Also called bit field ,C Language allows a structure to specify the length of memory occupied by its members in bits , This kind of member in bits is called " Bit segment " Or called " Bit field "( bit field) . With bit segments, data can be stored in fewer bits .

1.3.2 Bit segment implementation structure

The declaration and structure of a bit segment are similar , There are two differences ：1. The member of the segment must be  int、unsigned int  or signed int .2. The member name of the segment is followed by a colon and a number .

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


What is the size of the structure implemented using bit segments ？ If the size of the structure is calculated according to the method mentioned above , The result is

16

, But is that true ？ Let's use the program to calculate the size of this structure , Running results ：

8

D:\gtee\C-learning-code-and-project\test_922\Debug\test_922.exe ( process  22660) Exited , The code is  0.
Press any key to close this window . . .


The size is

8

, Not at all

16

, In fact, the number after the colon of the structure member name , It's actually the size of the occupied space , Unit is bit, In structures implemented using bit segments , Memory is opened up by corresponding data types , For example, the structure above A, Open up first

4

Byte size space, that is

32

bit size , Then save

_a

, Occupy

2

bit, And then there were

30

bit, Save again

_b

, Occupy

5

bit, And then there were

25

bit, Save again

_c

, Occupy

10

bit, And then there were

15

bit, Last deposit

_d

Occupy

30

bit, But the first piece of memory is not enough , So we need to open up another piece with the size of

4

byte （

32

bit） Space , To deposit

_d

, In the whole structure, a total of

8

Byte space , So the size of the structure is

8

. Allocation of bit segments in memory

• The members of a segment can be  
  int unsigned int
   
  signed int
    Or is it  
  char
   （ It belongs to the plastic family ） type

• The space of the bit segment is based on 4 Bytes （ 
  int
   ） perhaps 1 Bytes （ 
  char
   ） The way to open up .

• Bit segments involve many uncertainties , Bit segments are not cross platform ,
  Pay attention to portable program should avoid using bit segment .

Actually in C The language standard does not give the details of opening up memory space for bit segments , Let's try to explore the details of bit segment memory allocation .

Bit segment cross platform problem ：

• int 
  It's uncertain whether a bit segment is treated as a signed number or an unsigned number .

• The number of the largest bits in the bit segment cannot be determined .（16 The machine is the largest 16,32 The machine is the largest 32, It's written in 27, stay 16 A bit of the machine will go wrong .

• The members in the bit segment are allocated from left to right in memory , Or right to left allocation criteria have not yet been defined .

• When a structure contains two bit segments , The second segment is relatively large , Cannot hold the remaining bits of the first bit segment , Whether to discard the remaining bits or to use , This is uncertain .

Compared to the structure , Bit segments can achieve the same effect , But it can save a lot of space , But there are cross platform problems .

Application of bit segment ：

2. enumeration

 2.1 Enumeration overview

2.1.1 Enumeration concept

enum, Enumeration in C/C++/c#, also Objective-C in , Is a named set of integer constants , Enumeration is very common in daily life . For example, for a week SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,SATURDAY,  It's just an enumeration . The description of enumeration is similar to structure and union .

2.1.2 Declaration and use of enumeration

keyword ：

enum

enum Day// week
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};
enum Sex// Gender
{
 MALE,
 FEMALE,
 SECRET
};
enum Color// Color
{
 RED,
 GREEN,
 BLUE
};


As defined above  enum Day , enum Sex , enum Color  All enumeration types .{} The contents in are possible values of enumeration types , Also called  

Enumeration constants

 . These enumeration constants have values , The default from the 0 Start , One increment 1, Of course, initial values can also be assigned when defining .

enum Color// Color
{
 RED=1,
 GREEN=2,
 BLUE=4
};


Use of enumeration

enum Color// Color
{
 RED=1,
 GREEN=2,
 BLUE=4
};
enum Color clr = GREEN;// Only enumeration constants can be assigned to enumeration variables , There will be no type difference .
clr = 5;// error , Enumeration constants cannot be assigned


 2.2 Enumeration size calculation

Enumeration variable size , That is, the memory occupied by enumeration types , Enumeration type variables account for

4

byte .

enum A
 {
 QSW,
 BSW,
 CWS
 }a;
int main()
{
 printf("%d\n", sizeof(a));
 return 0;
}

4

D:\gtee\C-learning-code-and-project\test_922\Debug\test_922.exe ( process  21156) Exited , The code is  0.
Press any key to close this window . . .


 2.3 The difference between enumeration and macro

Enumeration constants defined using enums are typed , For enumeration type , While using

#define

A macro is a replacement , There is no enum type of this nature . We can use  

#define 

Define constants , Why do I have to use enumeration ？ Advantages of enumeration ：

• Increase the readability and maintainability of the code

• and
  #define
  The defined identifier comparison enumeration has type checking , More rigorous .

• Prevent named pollution （ encapsulation ）.

• Easy to debug .

• Easy to use , You can define more than one constant at a time .

3. Consortium

 3.1 Overview of the consortium

3.1.1 Consortium concept

In some algorithms C In language programming , Several different types of variables need to be stored in the same memory unit . That is, using coverage technology , Several variables cover each other . This kind of several different variables occupy a memory structure , stay C In language , It's called " Shared body " Type structure , Abbreviation: common body , It's also called a consortium .

3.1.2 Declaration and use of the consortium

keyword ：

union

Federation is also a special custom type . Variables defined by this type also contain a series of members , The feature is that these members share the same space （ So union is also called community ）.

// Declaration of union type
union Un
{
 char c;
 int i;
};
// The definition of joint variables
union Un un;


Members of the union share the same memory space , The size of such a joint variable , At least the size of the largest member （ Because the Union has to be able to keep at least the largest member ）. Use the consortium to judge the size of the end ：

int is_bl()
{
 union BL
 {
 char a;
 int b;
 }un;
 un.b = 1;
 // return 1 For the small end , return 0 Big end
 if (un.a == 1)
 {
 return 1;
 }
 else
 {
 return 0;
 }
}
int main()
{
 int ret = is_bl();
 if (ret == 1)
 {
 printf(" The small end \n");
 }
 else
 {
 printf(" Big end \n");
 }
 return 0;
}


VS The compiler uses a small end ：

The small end

D:\gtee\C-learning-code-and-project\test_922\Debug\test_922.exe ( process  23328) Exited , The code is  0.
Press any key to close this window . . .


 3.2 Consortium size calculation

• [ ]  The size of the union is at least the size of the largest member .

• [ ]  When the maximum member size is not an integral multiple of the maximum number of alignments , It's about aligning to an integer multiple of the maximum number of alignments .

union Un1
{
 char c[5];
 int i;
};
union Un2
{
 short c[7];
 int i;
};
// What is the output below ？
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));


Consortium

Un1

The maximum member size is

5

,

char

The number of type alignments is

1

,

int

The number of type alignments is

4

, So the maximum number of alignments is

4

, The consortium size should be an integral multiple of the maximum number of alignments , The size is

8

. Consortium

Un2

The maximum member size is

14

,

short

The number of type alignments is

2

,

int

The number of type alignments is

4

, So the maximum number of alignments is

4

, The consortium size should be an integral multiple of the maximum number of alignments , The size is

16

.

Running results ：

8
16

D:\gtee\C-learning-code-and-project\test_922\Debug\test_922.exe ( process  12864) Exited , The code is  0.
Press any key to close this window . . .