Structure primaire (explication super détaillée)

1. Déclaration de structure

1.1 Connaissance de base de la structure

Une structure est un ensemble de valeurs appelées variables membres . Chaque membre de la structure peut être une variable de différents types
Structure -> (structure)
comparaison :

1.2 Déclaration de structure

struct Stu
{
    
    
	//学生相关属性
	char name[20];
	int age;
	char sex[5];
	char id[20];
}s3,s4;//不可省略；
//s3,s4是结构体变量类型
//s3,s4是全局的
int main()
{
    
    
	struct Stu s1;
	struct Stu s2;
	//s1,s2是结构体类型的变量，是局部的
	struct Stu s3;
	return 0;
}

La définition de type est indispensable pour struct
Regardons la définition suivante : (struct peut être omis)

typedef struct Stu
{
    
    
	//学生相关属性
	char name[20];
	int age;
	char sex[5];
	char id[20];
}Stu;//Stu是重新定义的新类型
int main()
{
    
    
	struct Stu s1;
	struct Stu s2;
	//s1,s2是结构体类型的变量，是局部的
	Stu s5;//typedef定义下可省略struct
	return 0;
}

1.3 Types de membres de la structure

Les membres des variables de structure peuvent être des scalaires, des tableaux, des pointeurs ou même d'autres structures

struct B
{
    
    
	char c;
	int i;
};

struct S
{
    
    
	char c;
	int num;
	int arr[10];
	double* pd;
	struct B sb;
	struct B* pb;
};
int main()
{
    
    
	return 0;
}

1.4 Initialisation et définition des variables de structure

Avec le type de structure, la définition des variables est en fait très simple.

struct B
{
    
    
	char c;
	int i;
};
struct S
{
    
    
	char c;
	int num;
	int arr[10];
	double* pd;
	struct B sb;
	struct B* pb;
}s1;//s1是全局变量
struct S s2;//s2是全局变量
int main()
{
    
    
	double d = 3.14;
	//按照顺序初始化
	struct S s3 = {
    
     'q', 100, {
    
    1,2,3}, &d, {
    
    'a', 99}, NULL };//局部变量
	//指定成员来初始化
	struct S s4 = {
    
     .num = 1000, .arr = {
    
    1,2,3,4,5} };//局部变量
	return 0;
}

2. Accès aux structures

• Membres d'accès aux variables de structure
  Les membres de la variable de structure sont accessibles via l'opérateur point (.). L'opérateur point accepte deux opérandes.
• Les pointeurs de structure accèdent aux membres pointant vers des variables
  Parfois, ce que nous obtenons n'est pas une variable de structure, mais un pointeur vers une structure. Accès 1 avec (->)

Cas 1:

#include <string.h>

struct S
{
    
    
	char name[20];
	int age;
};
void set_s(struct S t)
{
    
    
	t.age = 18;
	//t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
	strcpy(t.name, "zhangsan");//字符串拷贝
}
int main()
{
    
    
	struct S s = {
    
     0 };
	//写一个函数给s中存放数据
	set_s(s);
	return 0;
}

mauvais code ci-dessus

Modifier comme suit :

//void set_s(struct S* ps)
//{
    
    
//	(*ps).age = 18;
//	//t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
//	strcpy((*ps).name, "zhangsan");//字符串拷贝
//}

//
void set_s(struct S* ps)
{
    
    
	ps->age = 18;
	//t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
	strcpy(ps->name, "zhangsan");//字符串拷贝
}

void print_s(struct S* ps)
{
    
    
	printf("%s %d\n", ps->name, ps->age);
}

int main()
{
    
    
	struct S s = {
    
    0};
	//写一个函数给s中存放数据
	set_s(&s);

	//写一个函数打印s中的数据
	print_s(&s);

	return 0;
}

3. Passage des paramètres de structure

Accédez directement au code :

struct S
{
    
    
	char name[20];
	int age;
};
void set_s(struct S* ps)
{
    
    
	ps->age = 18;
	//t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
	strcpy(ps->name, "zhangsan");//字符串拷贝
}

void print1(struct S ps)
{
    
    
	printf("%s %d\n", ps.name, ps.age);
}
int main()
{
    
    
	struct S s = {
    
     0 };
	//写一个函数给s中存放数据
	set_s(&s);

	//写一个函数打印s中的数据
	print1(s);

	return 0;
}
//
//
struct S
{
    
    
	char name[20];
	int age;
};
void set_s(struct S* ps)
{
    
    
	ps->age = 18;
	//t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
	strcpy(ps->name, "zhangsan");//字符串拷贝
}

void print2(struct S* ps)
{
    
    
	printf("%s %d\n", ps->name, ps->age);
}
int main()
{
    
    
	struct S s = {
    
    0};
	//写一个函数给s中存放数据
	set_s(&s);

	//写一个函数打印s中的数据
	print2(&s);

	return 0;
}

La réponse est : la fonction print2 est préférée.
raison:

Lors de l'utilisation d'un objet de structure, la structure est trop volumineuse et la surcharge du système pour pousser les paramètres vers la pile est relativement importante, ce qui entraînera une diminution des performances.

en conclusion:

Lorsqu'une structure est passée en paramètre, l'adresse de la structure doit être passée.

Sans le savoir, la structure a commencé à prendre fin. Vous avez dû beaucoup gagner à lire le texte intégral, continuons ensemble à avancer pour l'apprentissage du langage C