Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. Definir y utilizar estructuras.

1.1 Descripción general

Los tipos de datos que hemos visto antes, como int, float, char, etc., se usan simplemente en programas. Si queremos crear algunos datos complejos de acuerdo con nuestras propias necesidades, necesitamos usar estructuras.

Por ejemplo, el número de estudiante, el nombre, el sexo, la edad, etc. de un estudiante pertenecen al mismo estudiante, pero estas variables pertenecen a diferentes tipos. Si simplemente usa diferentes variables para hacer definiciones simples, es difícil reflejar la relación entre ellas. Conexión interior. Luego creamos una variable que puede combinar estos datos y ponerlos en la variable, para que sea mucho más sencillo de usar. Este es el aprendizaje de la estructura;

结构体类型：
        struct Student
        {
              int num;//学号为整形；
              char name[20];//姓名为字符串；
              char sex;//性别为字符型；
              int age;//年龄为整形
              float score;//成绩为浮点型
              char addr[30];//地址为字符型；
        }

en:

struct Student es un tipo de estructura;

struct es una palabra clave que declara un tipo de estructura.

Student es el nombre de la estructura, para distinguirla de otras estructuras;

Las llaves contienen los miembros de la estructura. El grupo en conjunto se denomina lista de miembros y su denominación es coherente con la denominación de las variables;

Nota: Los tipos de estructura pueden tener varios tipos, como: struct Student; struct Teacher; struct Worker;

Los miembros de una estructura también pueden ser el tipo de otra estructura;

Estructura Fecha

{        

int mes;

int día;

int año;

};

Estructura Estudiante

{

int num;

nombre del personaje[20];

sexo char;

int edad;

struct Fecha cumpleaños;

char dirección[30];

}

1.2 Definición de variables de estructura

Anteriormente solo definimos un tipo de estructura, que es equivalente a un modelo, y no definimos variables. A continuación, definimos variables de estructura y almacenamos datos específicos en ellas, 3 métodos;

Método 1: declarar primero el tipo de estructura y luego definir las variables de estructura

Según el tipo de estructura anterior struct Student, defina las variables de estructura;

struct Estudiante estudiante1,estudiante2;

Este método es similar a int a, b; el único requisito previo es que ya exista un tipo de estructura y la variable de estructura se defina en función del tipo.

    Método 2: definir variables al declarar el tipo

forma:

nombre de la estructura

                {

Lista de miembros;

}Lista de nombres de variables;

Ejemplo:

Estructura Estudiante
                {
int num;
nombre del personaje[20];
sexo char;
int edad;
puntuación flotante;
char dirección[30];
}estudiante1,estudiante2;

      Método 3: definir directamente variables de tipo de estructura sin especificar un nombre de tipo

forma:

estructura

                        {

Variables miembro;

}Lista de nombres de variables;

Es un tipo de estructura sin nombre y no se usa comúnmente;

Nota: 1. Los nombres de los miembros en las variables de estructura pueden ser los mismos que los nombres de las variables en el programa;

2. Los miembros de las variables estructurales se pueden utilizar solos; su estado y función son equivalentes a las variables ordinarias;

1.3 Inicialización y referencia de variables de estructura.

Inicializar las variables de estructura al definirlas;

      Ejemplo:Coloque la información de un estudiante (incluido el número de estudiante, nombre, sexo, dirección) en una variable de estructura y luego genere la información del estudiante;

#include <stdio.h>
 
int main()
{
	struct Student
	{
		int num;
		char name[20];
		char sex;
		char addr[20];
	}student1 = {101,"Li li",'M',"123XiAn"};
	printf("NO:%d,nname:%snssex:%cnaddress:%sn",student1.num,student1.name,student1.sex,student1.addr);
	return 0;

Análisis de resultados:

Por cierto, al definir una variable de estructura, inicialice sus miembros. La lista de inicialización es una cantidad de constantes encerradas entre llaves. Estas constantes son miembros asignados a la variable de estructura al mismo tiempo. la estructura. Inicialización del tipo de cuerpo.

El valor del miembro en la variable de estructura, el método de referencia es:

Nombre de variable de estructura. Nombre de miembro

estudiante1.nombre

      Para los miembros de estructura que pertenecen a otro tipo de estructura, los miembros de nivel más bajo deben encontrarse nivel por nivel. Por ejemplo, la estructura Estudiante mencionada anteriormente contiene la estructura Fecha de cumpleaños;

Mes del cumpleaños del estudiante

Se pueden asignar entre sí estructuras del mismo tipo:estudiante1= estudiante2;

        Ejemplo:Ingrese la identificación del estudiante, el nombre y las calificaciones de dos estudiantes, y genere la identificación del estudiante, el nombre y la calificación del estudiante con calificaciones más altas;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	struct Student
	{
		int num;
		char name[20];
		float score;
	}student1,student2;
	scanf("%d%s%f", &student1.num, student1.name, &student1.score);
	scanf("%d%s%f", &student2.num, student2.name, &student2.score);
	printf("The higher score is:n");
	if (student1.score > student2.score)
	{
		printf("%d %s %6.2fn", student1.num, student1.name, student1.score);
	}
	else if (student1.score < student2.score)
	{
		printf("%d %s %6.2fn", student2.num, student2.name, student2.score);
	}
	else
	{
		printf("%d %s %6.2fn", student1.num, student1.name, student1.score);
		printf("%d %s %6.2fn", student2.num, student2.name, student2.score);
	}
}

Cuando use la función scanf para ingresar variables de estructura, debe ingresarlas por separado. No puede usar el nombre de la variable de estructura en la función scanf para ingresar los valores de todos los miembros a la vez. Tenga en cuenta que la función scanf no tiene & al frente. de estudiante1.nombre, porque el nombre de la matriz originalmente representa Obtuve la dirección.

2. Utilice una matriz de estructura

2.1 Definir matriz de estructura

Cuando definimos las variables de estructura anteriormente, las definimos una por una. Sin embargo, si es un grupo de datos relacionados los que necesitan participar en la operación, obviamente es necesario utilizar datos, como la información de 10 estudiantes. es la matriz de estructura. Cada elemento de la matriz de estructura es una estructura.

Por ejemplo: hay tres candidatos y cada votante solo puede votar por una persona. Es necesario escribir un programa para contar los votos. Primero, ingrese el nombre del candidato y finalmente muestre el resultado del voto de cada persona.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
 
struct Person
{
	char name[20];
	int count;
}leader[3] = { "wang", 0, "zhang", 0, "li", 0 };
int main()
{
		int i, j;
		char lead_name[20];
		for (i = 0; i < 10; i++)
		{
			scanf("%s", lead_name);
			for (j = 0; j < 3; j++)
			{
				if (strcmp(lead_name, leader[j].name) == 0)
					leader[j].count++;
			}
		}
		printf("nResultn");
		for (i = 0; i < 3; i++)
		{
			printf("name:%s,count:%dn", leader[i].name, leader[i].count);
		}
		return 0;
	}

Defina la forma general de una matriz de estructura:

        nombre de la estructura

        {

lista de variables

} nombre de la matriz [longitud de la matriz];

o

Primero declare un tipo de estructura, como: struct Student, y luego defina la matriz de estructura;

        Nombre de la matriz del tipo de estructura [longitud de la matriz];

La forma de inicializar una matriz de estructura es agregar después de la definición:

      ={Lista de valores iniciales};     

2.2 Usando matriz de estructura

        Ejemplo:Hay información sobre n estudiantes (incluido el ID del estudiante, el nombre y las calificaciones) y se requiere generar la información de cada estudiante en orden de calificación;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
 
struct Student
{
	int num;
	char name[20];
	float score;
};
 
int main()
{
	struct Student stu[5] = { 1001, "Wangwei", 98.25, 1002, "Liuliu", 91, 1003, "Zhangli", 98, 1004, "Xiaozhao", 85, 1005, "Baibai", 94 };
	struct Student temp;
	printf("The order id:n");
	int i, j,k;
	for (i = 0; i < 4; i++)
	{
		k = i;
		for (j = i + 1; j < 5; j++)
		{
			if (stu[j].score>stu[k].score)
			{
				k = j;
			}
		}
			temp = stu[k]; 
			stu[k] = stu[i]; 
			stu[i] = temp;	
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d  %s  %5.2f", stu[i].num, stu[i].name, stu[i].score);
		printf("n");
	}
	return 0;
}

3. Puntero de estructura

3.1 Consejos para estructurar variables

El llamado puntero de estructura es un puntero a una variable de estructura. La dirección inicial de una variable de estructura es el puntero de la variable de estructura.

Una variable de puntero que apunta a un objeto de estructura puede apuntar a una variable de estructura o a un elemento de una matriz de estructura. El tipo base de la variable de puntero debe ser el mismo que el tipo de la variable de estructura.

Por ejemplo: estructura Estudiante * pt;

Ejemplo:Genere la información de los miembros en la variable de estructura a través de la variable de puntero que apunta a la variable de estructura;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
 
struct Student
{
	long num; 
	char name[20];
	char sex;
	float score;
};
 
int main()
{
	struct Student stu1;
	struct Student *pt;
	pt = &stu1;
	stu1.num = 10001;
	strcpy(stu1.name, "Lili");
	stu1.sex = 'M';
	stu1.score = 96.5;
	printf("No:%dnname:%snsex:%cnscore:%5.1fn", stu1.num, stu1.name, stu1.sex, stu1.score);
	printf("n");
	printf("No:%dnname:%snsex:%cnscore:%5.1fn", (*pt).num, (*pt).name, (*pt).sex, (*pt).score);
	printf("n");
	printf("No:%dnname:%snsex:%cnscore:%5.1fn", pt->num, pt->name, pt->sex, pt->score);
	return 0;
}

Análisis de resultados:

En la función, la primera función printf accede a los miembros a través del nombre de la variable de estructura stu1;

La segunda función printf accede a sus miembros a través de una variable de puntero que apunta a una variable de estructura (*pt) representa la variable de estructura apuntada y (*pt).num representa el miembro de estructura apuntado.

Además, en lenguaje C, se permite reemplazar (*pt).num por pt->num;

3.2 Puntero a matriz de estructura

Las variables de puntero se pueden utilizar para señalar elementos de la matriz de estructura.

Ejemplo:Hay información de tres estudiantes, colocada en la matriz de estructura, y se requiere que se genere la información del estudiante;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
 
struct Student
{
	long num; 
	char name[20];
	char sex;
	float score;
};
 
int main()
{
	struct Student stu[3] = { 1001, "wangle", 'M', 95, 1002, "chengcai", 'M', 99.9, 1003, "shangmin", 'F', 85.2 };
	struct Student *pt;
	printf("No.  name       sex  scoren");
	for (pt = stu; pt < stu + 3; pt++)
	{
		printf("%d %s %c %5.2fn", pt->num, pt->name, pt->sex, pt->score);
	}
	return 0;
}

En el programa, pt es un puntero a una variable de estructura de tipo Student. Se utiliza para apuntar a la variable de estructura, no a un determinado miembro de la estructura. pt=stu[1].name es ilegal. variable de estructura y la otra es una variable miembro de estructura. p++, el valor de p aumenta la longitud de la estructura.

3.3 Utilice variables de estructura y punteros para estructurar variables como parámetros de función

Hay tres formas de pasar el valor de una variable de estructura a una función;

1. Utilice los miembros de las variables de la estructura como parámetros. Este método es equivalente a pasar variables ordinarias. Cabe señalar que los parámetros formales y reales (miembros de la estructura) son del mismo tipo;

2. Utilice variables de estructura como parámetros reales. Cuando una variable de estructura se usa como parámetro real, también se pasa por valor. Todo el contenido de la unidad de memoria ocupada por la variable de estructura se pasa al parámetro formal.

3. Utilice el puntero a la variable de estructura (matriz) como parámetro real para pasar la dirección de la variable de estructura (matriz) al parámetro formal.

Ejemplo:

Hay n estructuras, incluidas las identificaciones de estudiantes, nombres y calificaciones de los estudiantes en 3 cursos. Se requiere generar la información de los estudiantes con las calificaciones promedio más altas (incluidas las identificaciones de estudiantes, nombres, calificaciones en 3 cursos y calificaciones promedio). .

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
void print(struct Student stud);
struct Student Max(struct Student stu[]);
void input(struct Student stu[]);
struct Student
{
	int num; 
	char name[20];
	float score[3];
	float aver;
};
 
int main()
{
	struct Student stu[3], *pt;
	pt = stu;
	input(pt);
	print(Max(pt));
	return 0;
}
void input(struct Student stu[])
{
	int i;
	printf("请输入各学生的信息：学号、姓名、3门成绩：n");
	for (i = 0; i < 3;i++)
	{
		scanf("%d%s%f%f%f", &stu[i].num, stu[i].name, &stu[i].score[0], &stu[i].score[1], &stu[i].score[2]);
		stu[i].aver = (stu[i].score[0] + stu[i].score[1] + stu[i].score[2]) / 3.0;	
	}
}
 
struct Student Max(struct Student stu[])
{
	int i, m = 0;
	for (i = 0; i < 3; i++)
	{
		if (stu[i].aver > stu[m].aver)
			m = i;
	}
	return  stu[m];
}
void print(struct Student stud)
{
	printf("成绩最好的学生是：n");
	printf("学号：%d 姓名：%s 三门课程：%5.2f %5.2f %5.2f平均成绩：%5.2fn", stud.num, stud.name, stud.score[0], stud.score[1], stud.score[2], stud.aver);
}

1. Al llamar a la función de entrada, el parámetro real es la variable de puntero pt y el parámetro formal es la matriz de estructura. Lo que se pasa es la dirección inicial del elemento de estructura y la función no tiene valor de retorno;

2. Al llamar a la función Max, el parámetro real es la variable de puntero pt, el parámetro formal es la matriz de estructura, se pasa la dirección inicial del elemento de estructura y el valor de retorno de la función son datos de tipo de estructura.

3. Al llamar a la función de impresión, los parámetros reales son variables de estructura (elementos de matriz de estructura) y los parámetros formales son variables de estructura. Lo que se pasa es el valor de cada miembro en la variable de estructura y la función no tiene valor de retorno.

4. Lista enlazada

4.1 Descripción general

La lista vinculada es una estructura de datos común, que es una estructura para la asignación de almacenamiento dinámico.

Al almacenar datos en una matriz, la longitud de la matriz (múltiples matrices) se debe definir de antemano. Si algunas clases tienen 100 estudiantes y algunas clases tienen 30 estudiantes, si se usa la misma matriz para almacenar los datos de los estudiantes en diferentes clases. Debe definirse una matriz con una longitud de 100, pero esto a menudo conduce a un desperdicio de recursos. La lista vinculada no tiene tales deficiencias. Abre unidades de memoria según sea necesario.

La lista vinculada tiene una variable de "puntero de cabecera", representada por cabecera en la figura, que almacena una dirección que apunta a un elemento. Cada elemento de la lista vinculada se denomina "nodo", y cada nodo debe incluir dos partes:

1. Datos reales requeridos por los usuarios;

2. La dirección del siguiente elemento;

Se puede ver que las direcciones de cada elemento en la lista vinculada en la memoria pueden ser discontinuas. Para encontrar un determinado elemento, primero debe encontrar el elemento anterior y puede encontrar el siguiente elemento en función de la dirección del elemento anterior. . Si no se proporciona el "puntero principal", no se podrá acceder a toda la lista vinculada.

En este caso, lo más apropiado es utilizar una estructura para crear una lista vinculada. Una estructura contiene varios miembros y los miembros de tipo puntero se utilizan para almacenar la dirección del siguiente nodo.

Estructura Estudiante

        {

int num;

int puntuación;

estructura Estudiante *siguiente;

        }

Entre ellos, num y score se usan para almacenar datos del usuario, y next se usa para almacenar la dirección del siguiente nodo.

4.2 Lista enlazada estática

Caso:

Cree una lista vinculada estática, que consta de nodos con datos de tres estudiantes, y requiera que se generen los datos de cada nodo;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
struct Student
{
	int num; 
	float score;
	struct Student * next;
};
 
int main()
{
	struct Student a, b, c, *head, *p;
	a.num = 1001; a.score = 85.5;
	b.num = 1002; b.score = 95.5;
	c.num = 1003; c.score = 84.5;
	head = &a;
	a.next = &b;
	b.next = &c;
	c.next = NULL;
	p = head;
	do
	{
		printf("%d %5.2fn", p->num, p->score);
		p = p->next;
	} while (p != NULL);
	return 0;
}

Por ejemplo, cree una lista vinculada de modo que head apunte al nodo a, a.next apunte al nodo b, b.next apunte al nodo c y c.next apunte a nulo. Esto forma una relación de lista vinculada.

Al generar una lista vinculada, primero debe usar p, hacer que p apunte a a y luego generar los datos en p = p-> next para preparar el siguiente nodo para la salida.

4.3 Lista enlazada dinámica

4.3.1 Asignación de memoria dinámica

Antes de hablar sobre listas enlazadas dinámicas, primero permítanos presentarle la asignación de memoria dinámica.

Anteriormente dijimos que las variables se dividen en variables globales y las variables locales se asignan en el área de almacenamiento estático de la memoria. Las variables locales almacenadas no estáticamente se asignan en el área de almacenamiento dinámico. Esta área de almacenamiento se llama memoria.pila。

Además, el lenguaje C también permite el establecimiento de áreas de asignación de memoria dinámica para almacenar algunos datos temporales. Estos datos se abren cuando son necesarios y se liberan cuando no son necesarios. Estos datos se almacenan temporalmente en un área de almacenamiento libre especial.montón。

La asignación dinámica de memoria se logra mediante funciones proporcionadas por el sistema: funciones malloc, calloc, free y realloc.

1. Utilice la función malloc para abrir un área de almacenamiento dinámico

función: void *malloc (unsigned int tamaño);

Función:

        Asigne un espacio continuo de tamaño de longitud (unidad: bytes) en el área de almacenamiento dinámico de la memoria.

valor de retorno:

La dirección del primer byte asignado; esta dirección no tiene tipo, sólo una dirección simple;

2. Utilice la función calloc para abrir un área de almacenamiento dinámico

función：void * calloc(n sin signo, tamaño sin signo);

Función:

Asigne n bytes de espacio continuo con una longitud de tamaño en el área de almacenamiento dinámico de la memoria. Este espacio es relativamente grande para guardar una matriz;

Utilice la función calloc para abrir espacio de almacenamiento dinámico para una matriz unidimensional, n es el número de elementos de la matriz y el tamaño es la longitud del elemento.

valor de retorno:

La dirección del primer byte asignado; esta dirección no tiene tipo, sólo una dirección simple;

3. Utilice la función realloc para reasignar el área de almacenamiento dinámico.

función:void * realloc(void *p ,unsigned int tamaño);

Función:

Reasigne la memoria dinámica asignada.

Utilice la función de recuperación para cambiar el tamaño del espacio dinámico al que apunta p. El valor de p permanece sin cambios;

valor de retorno:

La dirección del primer byte de la memoria dinámica después de la actualización es esencialmente la dirección señalada por p.

4. Utilice la función gratuita para liberar el área de almacenamiento dinámico.

función: vacío libre (vacío *p);

Función:

Libere el espacio dinámico al que apunta la variable de puntero p para que esta parte del espacio pueda ser utilizada por otras variables.

p es el valor de retorno obtenido de la última llamada a las funciones malloc y calloc;

valor de retorno:

ninguno;

Nota: Las declaraciones de las cuatro funciones anteriores están todas en el archivo de encabezado stdlib.h.

tipo de puntero vacío:

Los valores de retorno de las funciones malloc y calloc anteriores son de tipo void *, lo que significa que no apunta a ningún tipo de datos. No lo entiendo como que apunta a ningún tipo, sino que apunta a un tipo vacío. o no apunta a datos de un determinado tipo.

Al llamar a la memoria dinámica, el programa solo usa la dirección pura devuelta por la función y no usa el atributo que apunta a qué tipo de datos desea usar esta dirección, debe convertirse.

Por ejemplo:

entero *p;

p=(int*)malloc(100);

Caso:

Cree datos dinámicos, ingrese las puntuaciones de 5 estudiantes y use una función para verificar si hay estudiantes con menos de 60 puntos y genere las puntuaciones no calificadas;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
	void check(int * p);
	int *p1, i;
	p1 = (int *)malloc(5 * sizeof(int));
	for (i = 0; i < 5; i++)
	{
		scanf("%d", p1 + i);
	}
	check(p1);
	return 0;
}
void check(int * p)
{
	int i;
	printf("they are fail:n");
	for (i = 0; i < 5; i++)
	{
		if (*(p+i) < 60)
			printf("%d  ", *(p + i));
	}
}

resultado de la operación:

Análisis de resultados:

No hay ninguna matriz definida en el programa, pero se abre un área dinámica de asignación libre para usar como matriz.

En la función malloc, no se pasa directamente ningún valor específico para asignar espacio dinámico. En cambio, se usa sizeof para calcular el número de bytes del entero del sistema y luego se crean 5 elementos. Utilice p para señalar la dirección del primer byte y conviértala a tipo int, y p+1 apunta al siguiente elemento.

4.3.2 Creación de lista enlazada dinámica

Escriba una función para crear una lista enlazada dinámica con datos para 4 estudiantes.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
 
#define LEN sizeof(struct Student)
 
struct Student
{
	long num;
	float score;
	struct Student * next;
};
 
int n;
struct Student * creat(void)
{
	struct Student * head, *p1, *p2;
	n = 0; p1 = p2 = malloc(LEN);
	scanf("%ld%f", &p1->num, &p1->score);
	head = NULL;
	while (p1->num != 0)
	{
		n = n + 1;
		if (n == 1)
			head = p1;
		else  p2->next = p1;
		p2 = p1;
		p1 = (struct Student *)malloc(LEN);
		scanf("%ld%f", &p1->num, &p1->score);
	}
	p2->next = NULL;
	return (head);
	}
 
int main()
{
	struct Student * pt;
	pt = creat();
	printf("n num:%ld score:%5.2fn", pt->num, pt->score);
	return 0;
}
 
 

resultado de la operación:

Análisis de resultados: Para crear una lista enlazada dinámica, primero se especifican tres punteros de estructura y luego se usa la función malloc para crear un nodo. Los tres punteros de estructura apuntan a este nodo, y luego p1 usa la función malloc para crear el nodo y p2 Siguiente. apunta al nodo creado, después de apuntar a p2 = p1, p1 crea p2. Luego apunta al nodo creado, p2 = p1 ... hasta que el valor del elemento en p1 sea 0. El siguiente de p2 no apunta al. nodo recién creado. El nodo apunta a NULL. De esta manera, se crea una lista enlazada dinámica. El encabezado apunta al primer nodo, que es el nodo principal.

Entrada y salida de lista enlazada dinámica:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
 
#define LEN sizeof(struct Student)
 
struct Student
{
	long num;
	float score;
	struct Student * next;
};
int n;
struct Student * creat(void)
{
	struct Student * head, *p1, *p2;
	head = NULL;
	n = 0;
	p2 = p1 = malloc(LEN);
	scanf("%ld%f", &p1->num, &p1->score);
	while (p1->num != 0)
	{
		n = n + 1;
		if (n == 1)
			head = p1;
		else
			p2->next = p1;
		p2 = p1;
		p1 = malloc(LEN);
		scanf("%ld %f", &p1->num, &p1->score);
	}
	p2->next = NULL;
	return head;
}
 
void print(struct Student * p)
{
	do
	{
		printf("%ld %5.2fn", p->num ,p->score);
		p=p->next;
	} while (p->num != NULL);
}
 
int main(void)
{
	struct Student * pt;
	pt = creat();
	print(pt);
	return 0;
}

resultado de la operación:

5. Tipo de unión

5.1 Descripción general

A veces, desea almacenar diferentes tipos de variables en una unidad de memoria. Por ejemplo, coloque variables enteras, variables de caracteres y variables de punto flotante en una unidad de memoria comenzando en la misma dirección. Esto permite que varias variables compartan la misma unidad de memoria. Una sección de la estructura de la memoria se llama "unión".

Defina la forma general de una unión:

nombre del sindicato

        {

Lista de miembros;

}Lista de variables;

Por ejemplo:

Datos de la Unión

        {

yo entero;

carácter ch;

flotar f;

}a B C;

La longitud de la memoria ocupada por una variable de estructura es la suma de las longitudes de la memoria ocupada por cada miembro, mientras que la longitud de la memoria ocupada por una unión es la longitud del miembro más largo.

5.2 Cotizaciones

Solo se puede hacer referencia a las variables de unión que se han definido de antemano. Tenga en cuenta que no estamos haciendo referencia a las variables de unión sino a los miembros de las variables de unión a las que se hace referencia.

ai se refiere a la variable entera en la variable de unión;

a.ch se refiere a la variable de carácter en la variable de unión;

af se refiere a la variable real en la variable de unión;

5.3 Características

1. El segmento de memoria se puede utilizar para almacenar varios tipos diferentes de miembros, pero sólo se puede almacenar uno de ellos en cada momento, en lugar de varios al mismo tiempo.

2. Las variables de unión se pueden inicializar, pero solo puede haber una constante en la tabla de inicialización.

3. El miembro de la variable de unión es el miembro asignado la última vez y la variable original anterior se sobrescribe y reemplaza.

4. La dirección de una variable de unión es la misma que la dirección de sus miembros.

5. No puede asignar un valor a un nombre de variable de unión, ni intentar hacer referencia a un nombre de variable para obtener un valor.

6. Tipo de enumeración

Si algunas variables tienen solo unos pocos valores posibles, se pueden definir como tipos de enumeración; la llamada enumeración consiste en enumerar los valores posibles uno por uno.

La declaración de un tipo de enumeración comienza con enum, por ejemplo;

eunm Día de la semana{dom,lun,mar,mié,jue,vie,sáb};

Lo anterior declara un tipo de enumeración enumeración Weekday. Este tipo se puede utilizar para definir variables.

enumeración Día de la semana día laborable, fin de semana;

Entre ellos, el día laborable y el fin de semana se definen como variables de enumeración, y las llaves se denominan elementos de enumeración o constantes de enumeración.

La forma general de declarar un tipo de enumeración:

enum [nombre de enumeración] {lista de elementos de enumeración};

Ejemplo:

Hay 5 tipos de bolas en el bolsillo: roja, amarilla, azul, blanca y negra. Saca 3 bolas de la bolsa cada vez. Pregunta por las posibles formas de conseguir 3 bolas de diferentes colores y colócalas.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	enum Color {red,yellow,bule,white,black};
	enum Color i, j, k, pri;
	int n, loop;
	n = 0;
	for (i = red; i <= black; i++)
		for (j = red; j <= black; j++)
			if (i != j)
			{
		for (k = red; k <= black; k++)
 
			if ((k != i) && (k != j))
			{
			n++;
			printf("%d ", n);
			for (loop = 1; loop <= 3; loop++)
			{
				switch (loop)
				{
				case 1:pri = i; break;
				case 2:pri = j; break;
				case 3:pri = k; break;
				default:break;
				}
 
				switch (pri)
				{
				case red:printf("%s ", "red"); break;
				case yellow:printf("%s ", "yellow"); break;
				case bule:printf("%s ", "bule"); break;
				case white:printf("%s ", "white"); break;
				case black:printf("%s ", "black"); break;
				default:break;
				}
			}
			printf("n");
				}
			}
	printf("n total:%dn", n);
	return 0;
}

resultado de la operación:

7. Utilice typedef para declarar un nuevo nombre de tipo.

Utilice typedef para especificar un nuevo nombre de tipo para reemplazar el nombre de tipo existente;

1. Simplemente reemplace el nombre del tipo original con un nuevo nombre de tipo.

Por ejemplo:

typedef int Entero;

typedef float Real;

Por tanto, las dos líneas siguientes son equivalentes:

int i,j;——— Entero i,j;

2. Asigne un nombre de tipo simple en lugar de un método de representación de tipo complejo

  Asigne un nombre al nuevo tipo para representar el tipo de estructura:

estructura typedef

        {

int-mun;

                ......

} Datos;

Luego use el nuevo nombre de tipo Datos para definir la variable;

Datos del cumpleaños;

Datos * p;

      Asigne un nuevo nombre de tipo en lugar del tipo de matriz:

tipo definido int Num[100];

Número a;

      Nombra un nuevo tipo para representar el tipo de puntero：

typedef char * Cadena;

Cadena p,a[10];

      Asigne un nuevo nombre de tipo para representar un puntero a una función;

typedef int (* Puntero)();

Puntero p1,p2;

           Resumen: de acuerdo con la forma de definir las variables, reemplace el nombre de la variable con un nuevo nombre de tipo y agregue typedef al frente para declarar que el nuevo nombre de tipo representa el tipo original.

typetef solo especifica un nuevo nombre de tipo para un tipo existente, pero no crea un tipo nuevo.

typetef y #define tienen similitudes superficiales.

typedef int Contar

#define Contar int

Su función es usar Count en lugar de int, pero en realidad son diferentes. #define se procesa en la precompilación y solo se puede usar como un simple reemplazo de cadena, mientras que typedef se procesa en la etapa de compilación. En realidad, no es un simple reemplazo. En su lugar, se genera un nuevo nombre de tipo y se define la variable.