C Language structure

• Fang XS.
• [email protected]
• If there is an error , Hope to be pointed out , The road of learning technology will inevitably be bumpy , Irregular update

Structure

• stay C in , A structure is a user-defined data type , Allow users to store different data types .
• stay C in , Basic data types can be stored in the structure , Composite data type , The pointer .
• stay C in , A struct is a data set consisting of a series of data of the same or different types .
• stay C in , All the same / Different types of data can be encapsulated with structures .
• stay C++ in , Structures can contain functions ,C You can't , But you can use function pointers .

1. grammar
   • The first way ： struct struct_name{ int struct_member; };.
   • typedef The way ： typedef struct _struct_name{ int struct_member; }struct_name;
2. Defining variables
   • The first way ：
     • struct struct_name{ int struct_member; }struct_var; Define structure variables directly before semicolons .
     • struct struct_name struct_var;
   • typedef The way ：struct_name struct_var;
3. Use

/* Use typedef Defining structure */
typedef struct _struct_name{
     
    int struct_member; 
}struct_name;

int main(void)
{
    
	/*  Use structure pointers  */
    struct_name * pStructure = (struct_name *)malloc(sizeof(struct_name));
    pStructure->struct_member = 3;
    printf("struct_member: %d\n", pStructure->struct_member);
    free( pStructure );	// Free memory 
    pStructure = NULL;  // Null pointer 
    
    struct_name  Structure = {
     5 };	//  Direct initialization 
    printf("struct_member: %d\n", Structure.struct_member);
}

• Anonymous structure ：

/*  Usage mode ：*/
struct{
    
    int member;
}anonymous_struct;/* Directly defines anonymous_struct Global variables */

typedef struct _struct_name{
     
    int struct_member; 
    struct {
    
        int struct_nesting_member; /* Nested anonymous structure */
    };
}struct_name;

int main(void)
{
    
    anonymous_struct.member = 8 ; // Use it directly 
    printf("struct_member: %d\n", anonymous_struct.member);

	struct_name  Structure = {
     5 ,3 };
    printf("struct_member: %d\n", Structure.struct_member);
    printf("struct_nesting_member: %d\n", Structure.struct_nesting_member);

    return 0;
}  

• Structure is used as function parameter

typedef struct _struct_name{
     
    int struct_member1; 
    int struct_member2;
}struct_name;

void print_struct_1(struct_name s){
     // Value passed 
    printf("struct_member1: %d\n", s.struct_member1);
    printf("struct_member2: %d\n", s.struct_member2);
}

void print_struct_2(struct_name *s){
     // Pointer passing 
    printf("struct_member1: %d\n", s->struct_member1);
    printf("struct_member2: %d\n", s->struct_member2);
}
/** *  The difference between value passing and pointer passing is ： *  When the structure is large , Value transfer is copying data , Inefficient and takes up memory . *  At this time, using structure pointer is much faster , The data of access structure is accessed indirectly through pointers . *  No matter how big the structure is , It's just a 4 Byte pointer . */
int main(void)
{
    
    struct_name  Structure = {
     5 ,3 };
    print_struct_1( Structure );
    print_struct_2( &Structure );
    return 0;
}

• The size of structure in memory

struct sTest1{
     
    char member1;   // 1
    int member2;    // 4
    short member3;  // 2
};
struct sTest2{
     
    char member1;   // 1
    short member2;  // 2
    int member3;    // 4
};
struct sTest3{
     
    char member1;       // 1
    char member2[2];    // 2
    char member3[4];    // 4
};
/** *  The size of the structure in bytes , Its memory layout needs to be considered , Structures are stored in memory by unit  *  The size of each unit depends on the size of the largest basic type in the structure . */
int main(void)
{
    
    //  Basic data type size 
    printf("sizeof char = %d\n", sizeof(char));    // 1  byte 
    printf("sizeof short = %d\n", sizeof(short));   // 2  byte 
    printf("sizeof int = %d\n", sizeof(int));     // 4  byte 

    printf("sizeof struct1 = %d\n", sizeof(struct sTest1)); // 12
    printf("sizeof struct2 = %d\n", sizeof(struct sTest2)); // 8
    printf("sizeof struct3 = %d\n", sizeof(struct sTest3)); // 7
    return 0;
}

• Bit field

 
struct sTest1{
     
    char member1 : 2; //member1  yes char The type accounts for 2 position .
    char member2 : 1; //member2  yes char The type accounts for 1 position .
    char member3 : 3;
    char         : 1; // The nameless bit field is used to occupy bits , Indicates that data is not stored , Considering memory alignment requires .
    char member5 : 1;
};
/** *  Structure member plus ： Take the numbers , Represents the number of bits occupied by this member variable . *  such as  member2  Only in memory 1 position , yes char Type data range [0,1]. Can only be 0 perhaps 1. * C Language standards , The width of a bit field cannot exceed the length of the data type it is attached to . *  That is, the type of member variable limits the maximum range , Using bit fields can limit the specific range of member variables , Reasonable use saves memory . */
int main(void)
{
    
    printf("sizeof struct1 = %d\n", sizeof(struct sTest1)); // 1 byte 
    return 0;
}

• The structure is in C Widely used in , A wide range of uses .
• The member variables inside the structure are function pointers , By modifying the function pointed to by the function pointer , Can achieve C Language runtime ‘ polymorphic ’.
• Simple classes can be implemented using structs and function pointers , It can be used C To object-oriented programming , such as Linux.