Compartilhamento de tecnologia

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

1. Definir e usar estruturas

1.1 Visão geral

Os tipos de dados que vimos antes, como int, float, char, etc., são simplesmente usados ​​em programas. Se quisermos criar alguns dados complexos de acordo com nossas próprias necessidades, precisamos usar estruturas.

Por exemplo, o número de aluno, nome, sexo, idade, etc. de um aluno pertencem ao mesmo aluno, mas essas variáveis ​​pertencem a tipos diferentes. Se você usar variáveis ​​diferentes para fazer definições simples, será difícil refletir a relação entre elas. Conexão interna. Aí criamos uma variável que pode combinar esses dados e colocar na variável, para que fique muito mais simples de usar. Esse é o aprendizado da estrutura;

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

em:

struct Student é um tipo de estrutura;

struct é uma palavra-chave que declara um tipo de estrutura.

Aluno é o nome da estrutura, para distingui-la de outras estruturas;

As chaves contêm os membros da estrutura. O grupo conjunto é chamado de lista de membros e sua nomenclatura é consistente com a nomenclatura das variáveis;

Nota: Os tipos de estrutura podem ter vários tipos, como: struct Student;

Os membros de uma estrutura também podem ser do tipo de outra estrutura;

estrutura Data

{        

int mês;

dia int;

ano int;

};

estrutura Estudante

{

número inteiro;

nome do caractere[20];

sexo char;

idade int;

struct Data aniversário;

char addr[30];

}

1.2 Definição de variáveis ​​de estrutura

Anteriormente definimos apenas um tipo de estrutura, que é equivalente a um modelo, e não definimos variáveis. Em seguida, definimos variáveis ​​de estrutura e armazenamos dados específicos nelas, 3 métodos;

Método 1: declare primeiro o tipo de estrutura e depois defina as variáveis ​​​​de estrutura

Com base no tipo de estrutura anterior struct Student, defina variáveis ​​de estrutura;

estrutura Aluno aluno1,aluno2;

Este método é semelhante a int a,b; o único pré-requisito é que já exista um tipo de estrutura e a variável de estrutura seja definida com base no tipo.

    Método 2: Definir variáveis ​​ao declarar o tipo

forma:

nome da estrutura struct

                {

lista de membros;

}Lista de nomes de variáveis;

Exemplo:

estrutura Estudante
                {
número inteiro;
nome do caractere[20];
sexo char;
idade int;
pontuação flutuante;
char addr[30];
}aluno1,aluno2;

      Método 3: definir diretamente variáveis ​​de tipo de estrutura sem especificar um nome de tipo

forma:

estrutura

                        {

Variáveis ​​de membro;

}Lista de nomes de variáveis;

É um tipo de estrutura sem nome e não é comumente usado;

Nota: 1. Os nomes dos membros nas variáveis ​​de estrutura podem ser iguais aos nomes das variáveis ​​no programa;

2. Membros de variáveis ​​de estrutura podem ser usados ​​sozinhos, seu status e função são equivalentes a variáveis ​​comuns;

1.3 Inicialização e referência de variáveis ​​de estrutura

Inicialize as variáveis ​​de estrutura ao defini-las;

      Exemplo:Coloque as informações do aluno (incluindo número do aluno, nome, sexo, endereço) em uma variável de estrutura e, em seguida, produza as informações do aluno;

#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álise de resultados:

A propósito, ao definir uma variável de estrutura, inicialize seus membros. A lista de inicialização é um número de constantes entre chaves. Essas constantes são membros atribuídos à variável de estrutura de uma só vez. Nota: Esta é a inicialização da variável de estrutura. a estrutura.

O valor do membro na variável de estrutura, o método de referência é:

Nome da variável de estrutura.Nome do membro

aluno1.nome

      Para membros de estrutura que pertencem a outro tipo de estrutura, os membros de nível mais baixo devem ser encontrados nível por nível. Por exemplo, a estrutura Aluno mencionada acima contém a estrutura Data aniversário;

Mês de aniversário do aluno

Estruturas do mesmo tipo podem ser atribuídas entre si:aluno1= aluno2；

        Exemplo:Insira a carteira de aluno, nome e notas de dois alunos, e produza a carteira de aluno, nome e nota do aluno com notas mais 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);
	}
}

Ao usar a função scanf para inserir variáveis ​​​​de estrutura, você deve inseri-las separadamente. Você não pode usar o nome da variável de estrutura na função scanf para inserir os valores de todos os membros de uma vez. de student1.name, porque o nome da matriz representa originalmente o endereço obtido.

2. Use matriz de estrutura

2.1 Definir matriz de estrutura

Quando definimos as variáveis ​​​​de estrutura anteriormente, definimos uma por uma, porém, se for um grupo de dados relacionados que precisa participar da operação, é obviamente necessário utilizar dados, como as informações de 10 alunos. é a matriz de estrutura, cada elemento da matriz da matriz de estrutura é uma estrutura.

Por exemplo: Existem três candidatos e cada eleitor só pode votar em uma pessoa. É necessário escrever um programa para contar os votos. Primeiro, insira o nome do candidato e, por fim, exiba o resultado da votação de cada pessoa.

#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 a forma geral de uma matriz de estrutura:

        nome da estrutura struct

        {

lista de variáveis

} nome do array [comprimento do array];

ou

Primeiro declare um tipo de estrutura, como: struct student, e depois defina o array de estrutura;

        Nome da matriz do tipo de estrutura [comprimento da matriz];

A forma de inicializar um array de estrutura é adicionar após a definição:

      ={Lista de valores iniciais};     

2.2 Usando estrutura array

        Exemplo:Há informações sobre n alunos (incluindo carteira de aluno, nome e notas), e é necessário gerar as informações de cada aluno em ordem de nota;

#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. Ponteiro de estrutura

3.1 Ponteiros para estruturar variáveis

O chamado ponteiro de estrutura é um ponteiro para uma variável de estrutura. O endereço inicial de uma variável de estrutura é o ponteiro da variável de estrutura.

Uma variável de ponteiro que aponta para um objeto de estrutura pode apontar para uma variável de estrutura ou para um elemento de uma matriz de estrutura. O tipo base da variável de ponteiro deve ser igual ao tipo da variável de estrutura.

Por exemplo: struct Aluno * pt;

Exemplo:Produza as informações dos membros na variável de estrutura por meio da variável ponteiro apontando para a variável de estrutura;

#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álise de resultados:

Na função, a primeira função printf acessa os membros por meio da variável de estrutura nomeada stu1;

A segunda função printf acessa seus membros por meio de uma variável de ponteiro apontando para uma variável de estrutura (*pt) representa a variável de estrutura apontada e (*pt).num representa o membro da estrutura apontado.

Além disso, na linguagem C é permitido substituir (*pt).num por pt->num;

3.2 Ponteiro para array de estrutura

Variáveis ​​​​de ponteiro podem ser usadas para apontar para elementos da matriz de estrutura.

Exemplo:Existem três informações dos alunos, colocadas na matriz de estrutura, e as informações do aluno devem ser produzidas;

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

No programa, pt é um ponteiro para uma variável de estrutura do tipo struct Student. É usado para apontar para a variável de estrutura, não para um determinado membro da estrutura pt=stu[1].name é ilegal. variável de estrutura e a outra é uma variável de membro de estrutura. p++, o valor de p aumenta o comprimento da estrutura.

3.3 Use variáveis ​​de estrutura e ponteiros para estruturar variáveis ​​como parâmetros de função

Existem três maneiras de passar o valor de uma variável de estrutura para uma função;

1. Utilize os membros das variáveis ​​da estrutura como parâmetros. Este método equivale à passagem de variáveis ​​​​comuns. Deve-se observar que os parâmetros formais e reais (membros da estrutura) possuem o mesmo tipo;

2. Use variáveis ​​de estrutura como parâmetros reais. Quando uma variável de estrutura é usada como parâmetro real, ela também é passada por valor. Todo o conteúdo da unidade de memória ocupada pela variável de estrutura é passado para o parâmetro formal.

3. Use o ponteiro para a variável de estrutura (matriz) como um parâmetro real para passar o endereço da variável de estrutura (matriz) para o parâmetro formal.

Exemplo:

Existem n estruturas, incluindo carteiras de alunos, nomes e notas em 3 cursos. É necessário gerar as informações dos alunos com as notas médias mais altas (incluindo carteiras de alunos, nomes, notas em 3 cursos e notas médias). .

#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. Ao chamar a função de entrada, o parâmetro real é a variável ponteiro pt, e o parâmetro formal é a matriz da estrutura. O que é passado é o endereço inicial do elemento da estrutura, e a função não tem valor de retorno;

2. Ao chamar a função Max, o parâmetro real é a variável de ponteiro pt, o parâmetro formal é a matriz da estrutura, o endereço inicial do elemento da estrutura é passado e o valor de retorno da função são os dados do tipo de estrutura.

3. Ao chamar a função de impressão, os parâmetros reais são variáveis ​​de estrutura (elementos da matriz de estrutura) e os parâmetros formais são variáveis ​​de estrutura. O que é passado é o valor de cada membro na variável de estrutura, e a função não tem valor de retorno.

4. Lista vinculada

4.1 Visão Geral

A lista vinculada é uma estrutura de dados comum, que é uma estrutura para alocação dinâmica de armazenamento.

Ao armazenar dados em uma matriz, o comprimento da matriz (múltiplas matrizes) deve ser definido antecipadamente. Se algumas turmas tiverem 100 alunos e algumas turmas tiverem 30 alunos, se a mesma matriz for usada para armazenar os dados de alunos em turmas diferentes, ela será usada. deve ser definido. Uma matriz com comprimento de 100, mas isso geralmente leva ao desperdício de recursos. A lista vinculada não possui essas deficiências.

A lista vinculada possui uma variável "ponteiro principal", representada por head na figura, que armazena um endereço que aponta para um elemento. Cada elemento da lista vinculada é chamado de "nó", e cada nó deve incluir duas partes:

1. Dados reais exigidos pelos usuários;

2. O endereço do próximo elemento;

Pode-se observar que os endereços de cada elemento da lista vinculada na memória podem ser descontínuos. Para encontrar um determinado elemento, você deve primeiro encontrar o elemento anterior, e o próximo elemento pode ser encontrado com base no endereço do elemento anterior. . Se o "ponteiro principal" não for fornecido, toda a lista vinculada ficará inacessível.

Nesse caso, é mais apropriado usar uma estrutura para construir uma lista vinculada. Uma estrutura contém vários membros e membros do tipo ponteiro são usados ​​para armazenar o endereço do próximo nó.

estrutura Estudante

        {

número inteiro;

pontuação int;

struct Aluno *próximo;

        }

Entre eles, num e score são usados ​​para armazenar dados do usuário, e next é usado para armazenar o endereço do próximo nó.

4.2 Lista vinculada estática

Caso:

Criar uma lista vinculada estática, composta por nós com dados de três alunos, e exigir a saída dos dados de cada nó;

#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 exemplo, crie uma lista vinculada para que head aponte para o nó a, a.next aponte para o nó b, b.next aponte para o nó c e c.next aponte para nulo. Isso forma um relacionamento de lista vinculada.

Ao gerar uma lista vinculada, você deve primeiro usar p, fazer p apontar para a e, em seguida, gerar os dados em p=p->next para preparar o próximo nó para saída.

4.3 Lista vinculada dinâmica

4.3.1 Alocação dinâmica de memória

Antes de falar sobre listas vinculadas dinâmicas, vamos primeiro apresentar a você a alocação dinâmica de memória.

Anteriormente, dissemos que as variáveis ​​​​são divididas em variáveis ​​​​globais e as variáveis ​​​​locais são alocadas na área de armazenamento estático da memória. As variáveis ​​​​locais armazenadas não estaticamente são alocadas na área de armazenamento dinâmico do. memória. Esta área de armazenamento é chamada.pilha。

Além disso, a linguagem C também permite o estabelecimento de áreas de alocação dinâmica de memória para armazenar alguns dados temporários. Esses dados são abertos quando necessários e liberados quando não são necessários. Esses dados são armazenados temporariamente em uma área de armazenamento especial gratuita.amontoar。

A alocação dinâmica de memória é obtida por meio de funções fornecidas pelo sistema: funções malloc, calloc, free e realloc.

1. Use a função malloc para abrir uma área de armazenamento dinâmica

função: void *malloc (unsigned int tamanho);

Função:

        Aloque um espaço contínuo de tamanho (unidade: bytes) na área de armazenamento dinâmico da memória.

valor de retorno:

O endereço do primeiro byte alocado; este endereço não tem tipo, apenas um endereço simples;

2. Use a função calloc para abrir uma área de armazenamento dinâmica

função：void * calloc(n sem sinal,tamanho sem sinal);

Função:

Aloque n bytes de espaço contínuo com tamanho na área de armazenamento dinâmico da memória. Este espaço é relativamente grande o suficiente para guardar um array;

Use a função calloc para abrir espaço de armazenamento dinâmico para uma matriz unidimensional, n é o número de elementos da matriz e tamanho é o comprimento do elemento.

valor de retorno:

O endereço do primeiro byte alocado; este endereço não tem tipo, apenas um endereço simples;

3. Use a função realloc para realocar a área de armazenamento dinâmico

função:void * realloc(void *p ,unsigned int tamanho);

Função:

Realoque a memória dinâmica alocada.

Use a função recallloc para alterar o tamanho do espaço dinâmico apontado por p para size. O valor de p permanece inalterado;

valor de retorno:

O endereço do primeiro byte da memória dinâmica após a atualização é essencialmente o endereço apontado por p.

4. Use a função gratuita para liberar a área de armazenamento dinâmico

função: vazio livre(void *p);

Função:

Libere o espaço dinâmico apontado pela variável ponteiro p para que esta parte do espaço possa ser utilizada por outras variáveis.

p é o valor de retorno obtido da última chamada às funções malloc e calloc;

valor de retorno:

nenhum;

Observação: As declarações das quatro funções acima estão todas no arquivo de cabeçalho stdlib.h.

tipo de ponteiro vazio:

Os valores de retorno das funções malloc function e calloc function acima são do tipo void *, o que significa que não apontam para nenhum tipo de dado. Não entenda como apontando para qualquer tipo, mas aponta para um tipo vazio. ou não aponta para dados de um determinado tipo.

Ao chamar a memória dinâmica, o programa utiliza apenas o endereço puro trazido de volta pela função, e não utiliza o atributo que aponta para qual tipo de dado. Se desejar utilizar este endereço, ele deve ser convertido.

Por exemplo:

inteiro *p；

p=(int*)malloc(100);

Caso:

Crie dados dinâmicos, insira as notas de 5 alunos e use uma função para verificar se há alunos com menos de 60 pontos e produza as notas não qualificadas;

#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 da operação:

Análise de resultados:

Não há array definido no programa, mas uma área dinâmica de alocação gratuita é aberta para uso como array.

Na função malloc, nenhum valor específico é passado diretamente para alocar espaço dinâmico. Em vez disso, sizeof é usado para calcular o número de bytes do inteiro do sistema e, em seguida, 5 elementos são criados. Use p para apontar para o endereço do primeiro byte e convertê-lo para o tipo int, e p+1 aponta para o próximo elemento.

4.3.2 Criação de lista vinculada dinâmica

Escreva uma função para criar uma lista vinculada dinâmica com dados de 4 alunos.

#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 da operação:

Análise de resultados: Para criar uma lista vinculada dinâmica, três ponteiros de estrutura são especificados primeiro e, em seguida, a função malloc é usada para criar um nó. Todos os três ponteiros de estrutura apontam para este nó e, em seguida, p1 usa a função malloc para criar o nó e p2 Próximo. aponta para o nó criado Depois de apontar para p2=p1, p1 cria p2 Próximo aponta para o nó criado, p2=p1.... até que o valor do elemento em p1 seja 0. Próximo de p2 não aponta para o nó criado. nó recém-criado O nó aponta para NULL. Desta forma, uma lista vinculada dinâmica é criada.

Entrada e saída da lista vinculada 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 da operação:

5. Tipo de união

5.1 Visão Geral

Às vezes, você deseja armazenar diferentes tipos de variáveis ​​em uma unidade de memória. Por exemplo, coloque variáveis ​​inteiras, variáveis ​​de caracteres e variáveis ​​de ponto flutuante em uma unidade de memória começando no mesmo endereço. . Uma seção da estrutura da memória é chamada de "união".

Defina a forma geral de um sindicato:

nome do sindicato

        {

lista de membros;

}Lista de variáveis;

Por exemplo:

Dados da União

        {

int eu;

char ch;

flutuar f;

}abc;

O comprimento da memória ocupada por uma variável de estrutura é a soma dos comprimentos da memória ocupada por cada membro, enquanto o comprimento da memória ocupada por uma união é o comprimento do membro mais longo;

5.2 Cotações

Somente as variáveis ​​de união que foram definidas antecipadamente podem ser referenciadas. Observe que não estamos fazendo referência às variáveis ​​de união, mas aos membros das variáveis ​​de união referenciadas.

ai refere-se à variável inteira na variável union;

a.ch refere-se à variável de caractere na variável de união;

af refere-se à variável real na variável união;

5.3 Recursos

1. O segmento de memória pode ser usado para armazenar vários tipos diferentes de membros, mas apenas um deles pode ser armazenado em cada momento, em vez de vários ao mesmo tempo.

2. As variáveis ​​​​de união podem ser inicializadas, mas só pode haver uma constante na tabela de inicialização.

3. O membro da variável de união é o membro atribuído da última vez e a variável original anterior é sobrescrita e substituída.

4. O endereço de uma variável de união é igual ao endereço de seus membros.

5. Você não pode atribuir um valor a um nome de variável de união, nem tentar fazer referência a um nome de variável para obter um valor.

6. Tipo de enumeração

Se algumas variáveis ​​tiverem apenas alguns valores possíveis, elas podem ser definidas como tipos de enumeração; a chamada enumeração consiste em listar os valores possíveis um por um.

A declaração de um tipo de enumeração começa com enum, por exemplo;

eunm Dia da semana{dom,segunda,terça,qua,qui,sex,sábado};

O acima declara um tipo de enumeração enum Weekday. Este tipo pode então ser usado para definir variáveis.

enum Dia da semana dia útil, fim de semana;

Entre eles, dia útil e fim de semana são definidos como variáveis ​​​​de enumeração, e as chaves são chamadas de elementos de enumeração ou constantes de enumeração.

A forma geral de declarar um tipo de enumeração:

enum [nome da enumeração] {lista de elementos da enumeração};

Exemplo:

Existem 5 tipos de bolas na caçapa: vermelha, amarela, azul, branca e preta. Retire 3 bolas do saco de cada vez. Pergunte sobre as formas possíveis de obter 3 bolas de cores diferentes e organize-as.

#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 da operação:

7. Use typedef para declarar um novo nome de tipo

Use typedef para especificar um novo nome de tipo para substituir o nome de tipo existente;

1. Simplesmente substitua o nome do tipo original por um novo nome de tipo.

Por exemplo:

typedef int Inteiro;

typedef float Real;

Assim, as duas linhas a seguir são equivalentes:

int i，j；——— Inteiro i,j;

2. Nomeie um nome de tipo simples em vez de um método de representação de tipo complexo

  Dê um nome ao novo tipo para representar o tipo de estrutura:

estrutura typedef

        {

int homem;

                ......

} Dados;

Em seguida, use o novo nome de tipo Data para definir a variável;

Data de aniversário;

Dados * p;

      Nomeie um novo nome de tipo em vez do tipo de array:

typedef int Num[100];

Num a;

      Nomeie um novo nome de tipo para representar o tipo de ponteiro：

typedef char * String;

Cadeia de caracteres p,a[10];

      Nomeie um novo nome de tipo para representar um ponteiro para uma função;

typedef int (* Ponteiro)();

Ponteiro p1,p2;

           Resumo: De acordo com a forma de definir variáveis, substitua o nome da variável por um novo nome de tipo e adicione typedef na frente para declarar que o novo nome de tipo representa o tipo original.

typetef especifica apenas um novo nome de tipo para um tipo existente, mas não cria um novo tipo.

typetef e #define têm semelhanças superficiais.

typedef int Contagem

#define Contagem int

A função deles é usar Count em vez de int, mas na verdade eles são diferentes. #define é processado na pré-compilação, só pode ser usado como uma simples substituição de string, enquanto typedef é processado na fase de compilação. Na verdade, não é uma substituição simples. Em vez disso, um novo nome de tipo é gerado e a variável é definida.