Estructura primaria (explicación súper detallada)

1. Declaración de estructura

1.1 Conocimientos básicos de estructura

Una estructura es una colección de valores llamados variables miembro . Cada miembro de la estructura puede ser una variable de diferentes tipos
Estructura - -> (estructura)
comparación:

1.2 Declaración de estructura

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 definición de tipo es indispensable para struct
Veamos la siguiente definición: (struct se puede omitir)

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 Tipos de elementos de estructura

Los miembros de las variables de estructura pueden ser escalares, matrices, punteros o incluso otras estructuras.

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 Inicialización y definición de variables de estructura

Con el tipo de estructura, cómo definir variables es realmente muy 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. Acceso a la estructura

• Miembros de acceso de variable de estructura
  Se accede a los miembros de variable de estructura a través del operador de punto (.). El operador punto acepta dos operandos.
• Acceso de puntero de estructura a miembros de variables
  A veces lo que obtenemos no es una variable de estructura, sino un puntero a una estructura. Acceso 1 con (->)

Caso 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;
}

código incorrecto arriba

Modificar de la siguiente manera:

//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. Paso de parámetros de estructura

Ir directamente al código:

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 respuesta es: se prefiere la función print2.
razón:

Cuando se usa un objeto de estructura, la estructura es demasiado grande y la sobrecarga del sistema de empujar parámetros a la pila es relativamente grande, lo que conducirá a una disminución en el rendimiento.

en conclusión:

Cuando se pasa una estructura como parámetro, se debe pasar la dirección de la estructura.

Sin saberlo, la estructura comenzó a llegar a su fin. Debe haber ganado mucho al leer el texto completo, sigamos avanzando juntos para el aprendizaje del lenguaje C