当前位置：网站首页>Advanced part of C language IV. detailed explanation of user-defined types

A collection of various data types of a structure , These data are called structure members . When you create a structure variable , Each member has their own space .

Declaration format ：

struct tag

{

member-list;

}variable-list;

or Declare anonymous structure

struct

{

int a;

char b;

float c;

}a[20], *p;

Create structure pointer variables at the same time when declaring p etc. , Easy to use .

Self reference of structure

struct Node

{

int data;

struct Node next;

};

It is wrong for a structure to refer to itself as a member , The reason is that the size of the structure will be unknown

The correct way is to take the structure pointer as a member , Such as ：

struct Node

{

int data;

struct Node* next;

};

Be careful typedef The latter type cannot be used in the structure , for example

typedef struct

{

int data;

Node* next;// The compiler doesn't know Node

}Node;

The right thing to do is ：

typedef struct Node

{

int data;

struct Node * next;

}Node;

Structure variable definition and initialization

There are many ways to define structure variables , for example

struct Point{

int x;

int y;

}p1;// Define structure variables p1

perhaps

struct Point p2;// Define structure variables p2

Initializing structure variables

struct Point p3={3,5};

If it is a structure defined in this way , Nested initialization is also required

struct Node

{

int data;

struct Point p;

struct Node* next;

}n1 = { 10, { 4,5}, NULL}; // Structure nesting initialization n1, use {} Initialize structure member structure variable

struct Node n2 = { 20, { 5, 6}, NULL};// Structure nesting initialization n2

Structure memory alignment

When calculating the size of structure, we need to consider the memory alignment of structure , The reasons for the existence of structure memory alignment are as follows ：

1. Platform reasons ： Some hardware platforms can only access certain types of data at certain addresses , Otherwise, a hardware exception will be thrown .

2. Performance reasons ： Accessing unaligned memory , The processor needs to access twice , The aligned memory is accessed only once

So the data structure （ Stack ） It should be aligned on natural boundaries as much as possible .

Memory alignment rules ：

1. The first member is aligned to be offset from the structure variable by 0 The location of

2. Other members are aligned to an integer multiple of their respective alignment numbers （ Alignment number is the compiler default alignment number and member size （ Number of bytes ） The lesser of ）

3. The total size of the structure is an integer multiple of the maximum alignment number of each member

4. If nested structures , The nested structure is aligned to an integer multiple of the maximum alignment number of its members , The total size of the structure is the maximum alignment number of all members （ Members with nested structures ） Integer multiple

VS2022 The compiler's default alignment number is 8, use #pragma pack(4） You can modify the default alignment number of the compiler to 4

Reuse #pragma pack() You can restore the default alignment number of the compiler

Using macros offsetof You can find the offset of the structure member variable from the first address of the structure

offsetof Implementation of macro

#define offsetof(StructName,MemberName) (size_t)&(((StructName*)0)->MemberName)

Structural parameters

Structure parameters are usually passed to the address of the structure , Structure pointer , This saves memory overhead , Because the structural parameters need to be pressed , When the structure is large, the system time and space overhead are large .

Structs implement bit segments （ Filling of bit segments & Portability ）

Bit segment is a special type of structure ,（ Bit segments are not cross platform , Pay attention to portable programs and avoid using ） The bit segment declaration rules are as follows ：

1. The member of the bit segment must be an integer （int,char）.

2. The member name of the segment is followed by a colon and a number （ Numbers indicate the development bit position ）.

Bit segment memory allocation ：

The space of the bit segment is on demand with 4 Bytes （ int ） perhaps 1 Bytes （ char ） The way to open up （ If there is not enough space, directly re open bytes ）

for example ：

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

stay VS Next , The layout in memory is as follows （ The picture is a little rough ,c=3 It's on it 00011 dial the wrong number ）：

It can be seen that bit segments are opened from right to left in bytes , If the size of the bit segment member is not enough, a byte will be opened up at a higher address

View the structure under the compiler s The memory content of is found to be true ：

Be careful ： The cross platform problem of bit segment （ For the following reasons , Bit segments do not support cross platform ）

1.int Bit segment is not known as signed int still unsigned int.

2. The number of the largest bits in the bit segment is uncertain .（16 The machine is the largest 16,32 The machine is the largest 32, It's written in 27, stay 16 It's a plane

There will be problems with the device ）

3. The allocation order standard of members in the bit segment in memory is not defined .（VS2022 From right to left ）

4. When the latter bit segment member cannot accommodate the remaining bits of the first bit segment member , Not sure whether to discard the remaining bits （VS2022 The next is abandoned ）

enumeration

Enumeration refers to the types that list possible values one by one , for example

enum Color

{

RED,

GREEN,

BLUE

};

{} The contents in are possible values of enumeration types , Also called Enumeration constants .

All these possible values have values , The default from the 0 Start , One increment 1, Of course, initial values can also be assigned when defining , The value of the unassigned variable will be the previous enumeration constant +1（ The first enumeration constant is 0）.

Advantages of enumeration

comparison define Defined constant , Enumeration has more rigorous type checking .

Defining enumeration types and defining multiple constants at a time is fast and convenient , Enumerated constants have their own names and are of the same type , It increases the readability of the code and is easy to maintain .

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 
 image clr=4; This assignment is unreasonable because enum color The type and int  Different types .

although enum Color and int Different types , But the compiler works properly , Finding the size of variables of enumeration type is 4 Bytes

union

Federation is also a special custom type , Variables defined by this type contain a series of members , Unlike structures , These members share a space , So union is also called community .

Definition of joint type

Declaration of union type

union Un

{

char c;

int i;

};

Define joint variables

union Un un;

Calculation of joint size

Because the members of the Federation share the same memory space , The size of such a union type variable , At least the size of the largest member , But this is not the final size of the union type variable , Because the consortium also has memory alignment

The rule is , The size of the consortium is at least the size of the largest member ; If it is not an integral multiple of the maximum alignment number of consortium members , Then align to an integer multiple .（ Array alignment number is the alignment number of array member type ）

for example ：

First VS2022 The default alignment number of the lower compiler is 8,c The alignment number of is 1,i The alignment number of is 4, Array a The alignment number of is 1,

So united un It's at least the same size 5, Then align to 4 Integer multiple 8

Why at least 5 instead of 4 Well , Array a Is it a member or is each member in the array a member of the consortium ？

The following example illustrates ：

You can see the whole array a Is a member of the consortium , Otherwise the result is 8 instead of 12 了 .

Characteristics of Union

Because the members of the consortium share a space , The characteristic of association is naturally that the memory storage is different from the structure .

for example ：