Condivisione della tecnologia

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

1. Definire e utilizzare le strutture

1.1 Panoramica

I tipi di dati che abbiamo visto prima, come int, float, char, ecc., vengono semplicemente utilizzati nei programmi. Se vogliamo creare dei dati complessi secondo le nostre esigenze, dobbiamo utilizzare le strutture.

Ad esempio, la matricola, il nome, il sesso, l'età, ecc. di uno studente appartengono allo stesso studente, ma queste variabili appartengono a tipi diversi Se si utilizzano variabili diverse per creare definizioni semplici, è difficile riflettere la relazione tra loro Connessione interiore. Quindi creiamo una variabile che possa combinare questi dati e inserirla nella variabile, in modo che sia molto più semplice da usare. Questo è l'apprendimento della struttura;

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

In:

struct Student è un tipo di struttura;

struct è una parola chiave che dichiara un tipo di struttura.

Student è il nome della struttura, per distinguerla dalle altre strutture;

Le parentesi graffe contengono i membri della struttura. Il gruppo insieme è chiamato elenco dei membri e la sua denominazione è coerente con la denominazione delle variabili;

Nota: i tipi di struttura possono avere più tipi, ad esempio: struct Student;

I membri di una struttura possono anche essere il tipo di un'altra struttura;

struttura Data

{        

int mese;

int giorno;

anno interno;

};

struttura Studente

{

numero intero;

nome del carattere[20];

sesso di carattere;

età intera;

struct Data compleanno;

char indirizzo[30];

}

1.2 Definizione delle variabili di struttura

In precedenza abbiamo definito solo un tipo di struttura, che è equivalente a un modello, e non abbiamo definito le variabili. Successivamente definiamo le variabili di struttura e memorizziamo dati specifici in esse, 3 metodi;

Metodo 1: dichiarare prima il tipo di struttura, quindi definire le variabili della struttura

In base al tipo di struttura precedente struct Student, definire le variabili di struttura;

struttura Studente studente1,studente2;

Questo metodo è simile a int a,b; l'unico prerequisito è che esista già un tipo di struttura e la variabile di struttura sia definita in base al tipo.

    Metodo 2: definire le variabili durante la dichiarazione del tipo

modulo:

nome della struttura struct

                {

lista dei membri;

}Elenco nomi variabili;

Esempio:

struttura Studente
                {
numero intero;
nome del carattere[20];
sesso di carattere;
età intera;
punteggio flottante;
char indirizzo[30];
}studente1,studente2;

      Metodo 3: definire direttamente le variabili del tipo di struttura senza specificare un nome di tipo

modulo:

struttura

                        {

Variabili membro;

}Elenco nomi variabili;

È un tipo di struttura senza nome e non è comunemente utilizzato;

Nota: 1. I nomi dei membri nelle variabili della struttura possono essere gli stessi dei nomi delle variabili nel programma;

2. I membri delle variabili di struttura possono essere utilizzati da soli; il loro stato e la loro funzione sono equivalenti alle variabili ordinarie;

1.3 Inizializzazione e riferimento delle variabili di struttura

Inizializzare le variabili di struttura durante la loro definizione;

      Esempio:Inserisci le informazioni su uno studente (incluso numero di studente, nome, sesso, indirizzo) in una variabile di struttura, quindi genera le informazioni sullo studente;

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

Analisi dei risultati:

Quando si definisce una variabile di struttura, inizializzare i suoi membri. L'elenco di inizializzazione è un numero di costanti racchiuse tra parentesi graffe. Queste costanti sono membri assegnati contemporaneamente alla variabile di struttura la struttura. Inizializzazione del tipo di corpo.

Il valore del membro nella variabile di struttura, il metodo di riferimento è:

Nome della variabile di struttura.Nome del membro

studente1.nome

      Per i membri della struttura che appartengono a un altro tipo di struttura, i membri di livello più basso devono essere trovati livello per livello. Ad esempio, la struttura Student menzionata sopra contiene la struttura Data compleanno, il metodo di riferimento è:

Compleanno dello studente.mese

Le strutture dello stesso tipo possono essere assegnate tra loro:studente1= studente2;

        Esempio:Inserisci l'ID studente, il nome e i voti di due studenti e genera l'ID studente, il nome e il voto dello studente con i voti più alti;

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

Quando si utilizza la funzione scanf per inserire variabili di struttura, è necessario inserirle separatamente. Non è possibile utilizzare il nome della variabile di struttura nella funzione scanf per inserire i valori di tutti i membri contemporaneamente. Nota che la funzione scanf non ha & davanti di student1.name, perché il nome dell'array rappresenta originariamente l'indirizzo ottenuto.

2. Utilizzare l'array di struttura

2.1 Definire la struttura dell'array

Quando abbiamo definito le variabili della struttura in precedenza, le abbiamo definite una per una. Tuttavia, se si tratta di un gruppo di dati correlati che deve partecipare all'operazione, è ovviamente necessario utilizzare i dati, come le informazioni di 10 studenti è l'array della struttura, ogni elemento dell'array della struttura è una struttura.

Ad esempio: ci sono tre candidati e ogni elettore può votare solo per una persona. È necessario scrivere un programma per contare i voti. Innanzitutto, inserire il nome del candidato e infine visualizzare il risultato del voto di ciascuna 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;
	}

Definire la forma generale di una matrice di struttura:

        nome della struttura struct

        {

elenco variabili

} nome dell'array [lunghezza dell'array];

O

Per prima cosa dichiarare un tipo di struttura, ad esempio: struct student, quindi definire l'array della struttura;

        Tipo di struttura nome array [lunghezza array];

La forma di inizializzazione di un array di struttura consiste nell'aggiungere dopo la definizione:

      ={Lista valori iniziali};     

2.2 Utilizzo della struttura array

        Esempio:Sono presenti informazioni su n studenti (inclusi ID studente, nome e voti) ed è necessario fornire le informazioni di ciascuno studente in ordine di voto;

#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. Puntatore della struttura

3.1 Puntatori a variabili di struttura

Il cosiddetto puntatore di struttura è un puntatore a una variabile di struttura. L'indirizzo iniziale di una variabile di struttura è il puntatore della variabile di struttura.

Una variabile puntatore che punta a un oggetto struttura può puntare a una variabile struttura o a un elemento di un array di struttura. Il tipo base della variabile puntatore deve essere lo stesso del tipo della variabile struttura.

Ad esempio: struct Student * pt;

Esempio:Emette le informazioni dei membri nella variabile di struttura attraverso la variabile puntatore che punta alla variabile di struttura;

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

Analisi dei risultati:

Nella funzione, la prima funzione printf accede ai membri attraverso il nome della variabile di struttura stu1;

La seconda funzione printf accede ai suoi membri tramite una variabile puntatore che punta a una variabile di struttura (*pt) rappresenta la variabile di struttura puntata e (*pt).num rappresenta il membro della struttura puntata.

Inoltre, nel linguaggio C, è consentito sostituire (*pt).num con pt->num;

3.2 Puntatore alla struttura array

Le variabili puntatore possono essere utilizzate per puntare a elementi dell'array della struttura.

Esempio:Ci sono tre informazioni sugli studenti, inserite nell'array della struttura, e le informazioni sullo studente devono essere emesse;

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

Nel programma, pt è un puntatore a una variabile di struttura di tipo struct Student. Viene utilizzato per puntare alla variabile di struttura, non a un determinato membro della struttura. pt=stu[1].name è illegale variabile di struttura e l'altra è una variabile membro di struttura. p++, il valore di p aumenta la lunghezza della struttura.

3.3 Utilizzare variabili di struttura e puntatori per strutturare variabili come parametri di funzione

Esistono tre modi per passare il valore di una variabile di struttura a una funzione;

1. Utilizzare i membri delle variabili della struttura come parametri. Questo metodo equivale a passare variabili ordinarie. Va notato che i parametri formali ed effettivi (membri della struttura) hanno lo stesso tipo;

2. Utilizzare le variabili di struttura come parametri effettivi. Quando una variabile di struttura viene utilizzata come parametro effettivo, viene passata anche per valore. Tutto il contenuto dell'unità di memoria occupata dalla variabile di struttura viene passato al parametro formale. Anche il parametro formale deve essere una variabile di struttura.

3. Utilizzare il puntatore alla variabile di struttura (array) come parametro effettivo per passare l'indirizzo della variabile di struttura (array) al parametro formale.

Esempio:

Sono presenti n strutture, inclusi ID studente, nomi e voti in 3 corsi. È necessario fornire le informazioni degli studenti con i voti medi più alti (inclusi ID studente, nomi, voti in 3 corsi e voti medi). .

#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. Quando si chiama la funzione di input, il parametro effettivo è la variabile puntatore pt e il parametro formale è l'array della struttura. Ciò che viene passato è l'indirizzo iniziale dell'elemento della struttura e la funzione non ha valore restituito;

2. Quando si chiama la funzione Max, il parametro effettivo è la variabile puntatore pt, il parametro formale è l'array della struttura, viene passato l'indirizzo iniziale dell'elemento della struttura e il valore restituito dalla funzione sono i dati del tipo di struttura.

3. Quando si chiama la funzione print, i parametri effettivi sono variabili di struttura (elementi dell'array di struttura) e i parametri formali sono variabili di struttura. Ciò che viene passato è il valore di ciascun membro nella variabile di struttura e la funzione non ha valore restituito.

4. Elenco collegato

4.1 Panoramica

L'elenco collegato è una struttura dati comune, ovvero una struttura per l'allocazione dinamica della memoria.

Quando si memorizzano i dati in un array, la lunghezza dell'array (array multipli) deve essere definita in anticipo. Se alcune classi hanno 100 studenti e alcune classi hanno 30 studenti, se lo stesso array viene utilizzato per archiviare i dati di studenti in classi diverse, ciò avverrà. deve essere definito un array con una lunghezza di 100, ma questo spesso porta ad uno spreco di risorse L'elenco collegato non presenta tali carenze Apre le unità di memoria necessarie.

L'elenco collegato ha una variabile "puntatore head", rappresentata da head nella figura, che memorizza un indirizzo che punta a un elemento. Ogni elemento nell'elenco collegato è chiamato "nodo" e ciascun nodo dovrebbe includere due parti:

1. Dati effettivi richiesti dagli utenti;

2. L'indirizzo dell'elemento successivo;

Si può vedere che gli indirizzi di ciascun elemento nell'elenco collegato in memoria possono essere discontinui. Per trovare un determinato elemento, è necessario prima trovare l'elemento precedente e l'elemento successivo può essere trovato in base all'indirizzo dell'elemento precedente. . Se il "puntatore testa" non viene fornito, l'intero elenco collegato è inaccessibile.

In questo caso, è più appropriato utilizzare una struttura per creare un elenco collegato. Una struttura contiene diversi membri e i membri di tipo puntatore vengono utilizzati per memorizzare l'indirizzo del nodo successivo.

struttura Studente

        {

numero intero;

punteggio int;

struct Studente *successivo;

        }

Tra questi, num e score vengono utilizzati per memorizzare i dati dell'utente e next viene utilizzato per memorizzare l'indirizzo del nodo successivo.

4.2 Elenco collegato statico

Caso:

Creare una lista collegata statica, composta da nodi con i dati di tre studenti, e richiedere l'output dei dati di ciascun 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;
}

Ad esempio, crea un elenco collegato in modo che head punti al nodo a, a.next punti al nodo b, b.next punti al nodo c e c.next punti a null. Ciò forma una relazione di elenco collegato.

Quando si genera un elenco collegato, è necessario prima utilizzare p, fare in modo che p punti a a e quindi restituire i dati in a p=p->next per preparare il nodo successivo per l'output.

4.3 Elenco concatenato dinamico

4.3.1 Allocazione dinamica della memoria

Prima di parlare di elenchi collegati dinamici, presentiamo innanzitutto l'allocazione dinamica della memoria.

In precedenza abbiamo detto che le variabili sono divise in variabili globali e variabili locali. Le variabili globali sono allocate nell'area di archiviazione statica della memoria. Le variabili locali non archiviate staticamente sono allocate nell'area di archiviazione dinamica del memoria. Questa area di archiviazione è chiamatapila。

Inoltre, il linguaggio C consente anche la creazione di aree di allocazione dinamica della memoria per archiviare alcuni dati temporanei. Questi dati vengono aperti quando necessari e rilasciati quando non sono necessari. Questi dati vengono temporaneamente archiviati in una speciale area di archiviazione liberamucchio。

L'allocazione dinamica della memoria viene ottenuta attraverso le funzioni fornite dal sistema: funzioni malloc, calloc, free e realloc.

1. Utilizzare la funzione malloc per aprire un'area di archiviazione dinamica

funzione: void *malloc (unsigned int dimensione);

Funzione:

        Assegna uno spazio continuo di dimensione lunghezza (unità: byte) nell'area di archiviazione dinamica della memoria.

valore di ritorno:

L'indirizzo del primo byte allocato; questo indirizzo non ha tipo, solo un indirizzo semplice;

2. Utilizzare la funzione calloc per aprire un'area di archiviazione dinamica

funzione：void * calloc(unsigned n,unsigned size);

Funzione:

Assegna n byte di spazio continuo con una lunghezza di dimensione nell'area di archiviazione dinamica della memoria. Questo spazio è relativamente grande abbastanza per salvare un array;

Utilizzare la funzione calloc per aprire spazio di archiviazione dinamico per un array unidimensionale, n è il numero di elementi dell'array e size è la lunghezza dell'elemento.

valore di ritorno:

L'indirizzo del primo byte allocato; questo indirizzo non ha tipo, solo un indirizzo semplice;

3. Utilizzare la funzione realloc per riallocare l'area di archiviazione dinamica

funzione:void * realloc(void *p ,unsigned int dimensione);

Funzione:

Riallocare la memoria dinamica allocata.

Utilizzare la funzione callloc per modificare la dimensione dello spazio dinamico puntato da p in size. Il valore di p rimane invariato;

valore di ritorno:

L'indirizzo del primo byte di memoria dinamica dopo l'aggiornamento è essenzialmente l'indirizzo indicato da p.

4. Utilizzare la funzione gratuita per liberare l'area di archiviazione dinamica

funzione: vuoto libero(void *p);

Funzione:

Rilascia lo spazio dinamico puntato dalla variabile puntatore p in modo che questa parte dello spazio possa essere utilizzata da altre variabili.

p è il valore restituito ottenuto dall'ultima chiamata alle funzioni malloc e calloc;

valore di ritorno:

nessuno;

Nota: Le dichiarazioni delle quattro funzioni precedenti sono tutte nel file di intestazione stdlib.h.

tipo di puntatore vuoto:

I valori restituiti delle funzioni di cui sopra, la funzione malloc e la funzione calloc, sono entrambi di tipo void *, il che significa che non punta a nessun tipo di dati. Non è inteso come se punta a qualsiasi tipo, ma punta a un tipo vuoto o non punta a dati di un certo tipo.

Quando si chiama la memoria dinamica, il programma utilizza solo l'indirizzo puro riportato dalla funzione e non utilizza l'attributo che punta a quale tipo di dati. Se si desidera utilizzare questo indirizzo, è necessario convertirlo.

Per esempio:

int *p;

p=(int*)malloc(100);

Caso:

Crea dati dinamici, inserisci i punteggi di 5 studenti e utilizza una funzione per verificare se ci sono studenti con meno di 60 punti e genera punteggi non qualificati;

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

risultato dell'operazione:

Analisi dei risultati:

Nel programma non è definito alcun array, ma viene aperta un'area dinamica di allocazione libera da utilizzare come array.

Nella funzione malloc, non viene passato direttamente alcun valore specifico per allocare lo spazio dinamico. Invece, sizeof viene utilizzato per calcolare il numero di byte dell'intero di sistema, quindi vengono creati 5 elementi. Usa p per puntare al primo indirizzo byte e convertilo nel tipo int, mentre p+1 punta all'elemento successivo.

4.3.2 Creazione di liste collegate dinamiche

Scrivi una funzione per creare un elenco collegato dinamico con dati per 4 studenti.

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

risultato dell'operazione:

Analisi dei risultati: Per creare un elenco collegato dinamico, vengono prima specificati tre puntatori alla struttura, quindi viene utilizzata la funzione malloc per creare un nodo. Tutti e tre i puntatori alla struttura puntano a questo nodo, quindi p1 utilizza la funzione malloc per creare il nodo e p2 Next punta al nodo creato. Dopo aver puntato a p2=p1, p1 crea p2 Next punta al nodo creato, p2=p1....finché il valore dell'elemento in p1 è 0. Next of p2 non punta al nodo creato. nodo appena creato. Il nodo punta a NULL In questo modo, viene creata una lista collegata dinamica. La testa punta al primo nodo ed è il nodo testa.

Input e output dell'elenco collegato dinamico:

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

risultato dell'operazione:

5. Tipo di unione

5.1 Panoramica

A volte, si desidera memorizzare diversi tipi di variabili in un'unità di memoria. Ad esempio, posizionare variabili intere, variabili di carattere e variabili a virgola mobile in un'unità di memoria a partire dallo stesso indirizzo. Ciò consente a più variabili di condividere la stessa unità di memoria Una sezione della struttura della memoria è chiamata "unione".

Definire la forma generale di un'unione:

nome del sindacato

        {

lista dei membri;

}Elenco variabili;

Per esempio:

unione dati

        {

int io;

carattere ch;

galleggiante f;

}a,b,c;

La lunghezza di memoria occupata da una variabile di struttura è la somma delle lunghezze di memoria occupate da ciascun membro mentre la lunghezza di memoria occupata da un'unione è la lunghezza del membro più lungo.

5.2 Citazioni

È possibile fare riferimento solo alle variabili dell'unione che sono state definite in anticipo. Tieni presente che non stiamo facendo riferimento alle variabili dell'unione ma ai membri delle variabili dell'unione a cui si fa riferimento.

ai si riferisce alla variabile intera nella variabile unione;

a.ch si riferisce alla variabile carattere nella variabile unione;

af si riferisce alla variabile reale nella variabile unione;

5.3 Caratteristiche

1. Il segmento di memoria può essere utilizzato per memorizzare diversi tipi di membri, ma è possibile memorizzarne solo uno alla volta, anziché più contemporaneamente.

2. Le variabili dell'unione possono essere inizializzate, ma può esserci solo una costante nella tabella di inizializzazione.

3. Il membro della variabile union è il membro assegnato l'ultima volta e la variabile originale precedente viene sovrascritta e sostituita.

4. L'indirizzo di una variabile dell'unione è lo stesso dell'indirizzo dei suoi membri.

5. Non è possibile assegnare un valore al nome di una variabile di unione, né tentare di fare riferimento a un nome di variabile per ottenere un valore.

6. Tipo di enumerazione

Se alcune variabili hanno solo pochi valori possibili, possono essere definite come tipi di enumerazione; la cosiddetta enumerazione consiste nell'elencare i possibili valori uno per uno.

La dichiarazione di un tipo di enumerazione inizia ad esempio con enum;

eunm Giorno feriale{dom,lun,mar,mer,gio,ven,sab};

Quanto sopra dichiara un tipo di enumerazione enum Weekday. Questo tipo può quindi essere utilizzato per definire le variabili.

enum Giorno feriale giorno lavorativo,fine settimana;

Tra questi, il giorno lavorativo e il fine settimana sono definiti come variabili di enumerazione e le parentesi graffe sono chiamate elementi di enumerazione o costanti di enumerazione.

La forma generale di dichiarazione di un tipo di enumerazione:

enum [nome dell'enumerazione] {elenco degli elementi dell'enumerazione};

Esempio:

Ci sono 5 tipi di palline nella tasca: rosse, gialle, blu, bianche e nere. Prendi ogni volta 3 palline dal sacchetto. Chiedi i modi possibili per ottenere 3 palline di colori diversi e disponili.

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

risultato dell'operazione:

7. Utilizzare typedef per dichiarare un nuovo nome di tipo

Utilizzare typedef per specificare un nuovo nome di tipo per sostituire il nome di tipo esistente;

1. Sostituisci semplicemente il nome del tipo originale con un nuovo nome del tipo.

Per esempio:

typedef int Intero;

typedef float Reale;

Pertanto le due righe seguenti sono equivalenti:

int i，j;——— Intero i,j;

2. Assegnare un nome di tipo semplice anziché un metodo di rappresentazione di tipo complesso

  Assegna un nome al nuovo tipo per rappresentare il tipo di struttura:

tipodef struttura

        {

int mun;

                ......

} Dati;

Quindi utilizzare il nuovo nome del tipo Data per definire la variabile;

Data di compleanno;

Dati * p;

      Assegna un nuovo nome al tipo invece del tipo di array:

definizione tipo int Num[100];

Numero uno;

      Assegnare un nuovo nome al tipo per rappresentare il tipo di puntatore：

typedef char * Stringa;

Stringa p,a[10];

      Assegna un nuovo nome al tipo per rappresentare un puntatore a una funzione;

typedef int (* Puntatore)();

Puntatore p1,p2;

           Riepilogo: in base al modo di definire le variabili, sostituire il nome della variabile con un nuovo nome di tipo e aggiungere typedef in primo piano per dichiarare che il nuovo nome di tipo rappresenta il tipo originale.

typetef specifica solo un nuovo nome di tipo per un tipo esistente, ma non crea un nuovo tipo.

typetef e #define hanno somiglianze superficiali.

typedef int conteggio

#define Conta int

La loro funzione è quella di utilizzare Count al posto di int, ma in realtà sono diversi. #define viene elaborato in precompilazione, può essere utilizzato solo come semplice sostituzione di stringa, mentre typedef viene elaborato in fase di compilazione. In realtà non è una semplice sostituzione. Viene invece generato un nuovo nome di tipo e la variabile viene definita.