Partage de technologie

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

1. Définir et utiliser des structures

1.1 Aperçu

Les types de données que nous avons vus auparavant, tels que int, float, char, etc., sont simplement utilisés dans les programmes. Si nous voulons créer des données complexes selon nos propres besoins, nous devons utiliser des structures.

Par exemple, le numéro d'étudiant, le nom, le sexe, l'âge, etc. d'un étudiant appartiennent au même étudiant, mais ces variables appartiennent à des types différents. Si vous utilisez simplement différentes variables pour établir des définitions simples, il est difficile de refléter la relation entre elles. . Connexion intérieure. Ensuite, nous créons une variable qui peut combiner ces données et la mettons dans la variable, afin qu'elle soit beaucoup plus simple à utiliser. C'est l'apprentissage de la structure ;

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

dans:

struct Student est un type de structure ;

struct est un mot-clé qui déclare un type de structure.

Student est le nom de la structure, afin de la distinguer des autres structures ;

Les accolades contiennent les membres de la structure. L'ensemble du groupe est appelé une liste de membres et sa dénomination est cohérente avec celle des variables.

Remarque : Les types de structure peuvent avoir plusieurs types : struct Student ; struct Worker ;

Les membres d'une structure peuvent également être le type d'une autre structure ;

structure Date

{        

int mois;

int jour;

int année;

};

structure Étudiant

{

nombre entier;

nom de caractère[20];

sexe char;

âge int;

struct Date anniversaire;

char addr[30];

}

1.2 Définition des variables de structure

Auparavant, nous avons uniquement défini un type de structure, qui est équivalent à un modèle, et n'avons pas défini de variables. Ensuite, nous définissons des variables de structure et y stockons des données spécifiques, 3 méthodes :

Méthode 1 : déclarez d'abord le type de structure, puis définissez les variables de structure

Sur la base du type de structure précédent struct Student, définissez les variables de structure ;

struct Étudiant étudiant1,étudiant2;

Cette méthode est similaire à int a,b ; la seule condition préalable est qu'il existe déjà un type de structure et que la variable de structure est définie en fonction du type.

    Méthode 2 : définir des variables lors de la déclaration du type

formulaire:

nom de la structure struct

                {

liste des membres;

}Liste de noms de variables ;

Exemple:

structure Étudiant
                {
nombre entier;
nom de caractère[20];
sexe char;
âge int;
score flottant;
char addr[30];
}étudiant1,étudiant2;

      Méthode 3 : définir directement les variables de type structure sans spécifier de nom de type

formulaire:

structure

                        {

Variables membres ;

}Liste de noms de variables ;

Il s’agit d’un type de structure sans nom et n’est pas couramment utilisé ;

Remarque : 1. Les noms de membres dans les variables de structure peuvent être les mêmes que les noms de variables dans le programme ;

2. Les membres des variables de structure peuvent être utilisés seuls ; leur statut et leur fonction sont équivalents aux variables ordinaires ;

1.3 Initialisation et référence des variables de structure

Initialiser les variables de structure lors de leur définition ;

      Exemple:Mettez les informations d'un étudiant (y compris le numéro d'étudiant, le nom, le sexe, l'adresse) dans une variable de structure, puis affichez les informations de l'étudiant ;

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

Analyse des résultats :

Lors de la définition d'une variable de structure, initialisez ses membres. La liste d'initialisation est un certain nombre de constantes entourées d'accolades. Ces constantes sont des membres affectés à la variable de structure à un moment donné. Remarque : il s'agit d'une initialisation de la variable de structure. la structure. Initialisation du type de corps.

La valeur du membre dans la variable de structure, la méthode de référence est :

Nom de la variable de structure.Nom du membre

nom de l'étudiant1

      Pour les membres de structure appartenant à un autre type de structure, les membres de niveau le plus bas doivent être trouvés niveau par niveau. Par exemple, la struct Student mentionnée ci-dessus contient struct Date anniversaire ;

Mois d'anniversaire de l'étudiant

Des structures de même type peuvent être affectées entre elles :étudiant1= étudiant2；

        Exemple:Entrez le numéro d'étudiant, le nom et les notes de deux étudiants, et affichez le numéro d'étudiant, le nom et la note de l'étudiant ayant les notes les plus élevées ;

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

Lorsque vous utilisez la fonction scanf pour saisir des variables de structure, vous devez les saisir séparément. Vous ne pouvez pas utiliser le nom de la variable de structure dans la fonction scanf pour saisir les valeurs de tous les membres à la fois. Notez que la fonction scanf n'a pas & devant. de student1.name, car le nom du tableau représente à l'origine Got the address.

2. Utiliser un tableau de structure

2.1 Définir un tableau de structure

Lorsque nous avons défini les variables de structure plus tôt, nous les avons définies une par une. Cependant, si c'est un groupe de données liées qui doit participer à l'opération, il est évidemment nécessaire d'utiliser des données, comme les informations de 10 étudiants. est le tableau de structure, chaque élément du tableau de structure est une structure.

Par exemple : il y a trois candidats et chaque électeur ne peut voter que pour une seule personne. Il est nécessaire d'écrire un programme pour compter les votes. D'abord, entrez le nom du candidat et enfin affichez le résultat du vote de chaque personne.

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

Définir la forme générale d'un tableau de structure :

        nom de la structure struct

        {

liste de variables

} nom du tableau [longueur du tableau] ;

ou

Déclarez d'abord un type de structure, tel que : struct student, puis définissez le tableau de structure ;

        Nom du tableau de type de structure [longueur du tableau] ;

La forme d'initialisation d'un tableau de structure est d'ajouter après la définition :

      ={Liste de valeurs initiales} ;     

2.2 Utilisation du tableau de structure

        Exemple:Il existe des informations sur n étudiants (y compris la carte d'étudiant, le nom et les notes), et il est nécessaire d'afficher les informations de chaque étudiant par ordre de note ;

#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. Pointeur de structure

3.1 Pointeurs vers des variables de structure

Le soi-disant pointeur de structure est un pointeur vers une variable de structure. L'adresse de départ d'une variable de structure est le pointeur de la variable de structure.

Une variable pointeur pointant vers un objet structure peut pointer vers une variable structure ou vers un élément d'un tableau structure. Le type de base de la variable pointeur doit être le même que le type de la variable structure.

Par exemple : struct Student * pt ;

Exemple:Afficher les informations des membres dans la variable de structure via la variable de pointeur pointant vers la variable de structure ;

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

Analyse des résultats :

Dans la fonction, la première fonction printf accède aux membres via le nom de variable de structure stu1 ;

La deuxième fonction printf accède à ses membres via une variable pointeur pointant vers une variable de structure (*pt) représente la variable de structure pointée et (*pt).num représente le membre de structure pointé.

De plus, en langage C, il est permis de remplacer (*pt).num par pt->num ;

3.2 Pointeur vers un tableau structuré

Les variables de pointeur peuvent être utilisées pour pointer vers des éléments du tableau de structure.

Exemple:Il y a trois informations sur les étudiants, placées dans le tableau de structure, et les informations sur les étudiants doivent être sorties ;

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

Dans le programme, pt est un pointeur vers une variable de structure de type struct Student. Il est utilisé pour pointer vers la variable de structure, pas vers un certain membre de la structure. pt=stu[1].name est illégal. variable de structure et l’autre est une variable membre de la structure. p++, la valeur de p augmente la longueur de la structure.

3.3 Utiliser des variables de structure et des pointeurs vers des variables de structure comme paramètres de fonction

Il existe trois façons de transmettre la valeur d'une variable de structure à une fonction ;

1. Utilisez les membres des variables de structure comme paramètres. Cette méthode équivaut à passer des variables ordinaires. Il convient de noter que les paramètres formels et réels (membres de la structure) ont le même type ;

2. Utilisez les variables de structure comme paramètres réels. Lorsqu'une variable de structure est utilisée comme paramètre réel, elle est également passée par valeur. Tout le contenu de l'unité mémoire occupée par la variable de structure est transmis au paramètre formel. Le paramètre formel doit également être une variable de structure.

3. Utilisez le pointeur vers la variable de structure (tableau) comme paramètre réel pour transmettre l'adresse de la variable de structure (tableau) au paramètre formel.

Exemple:

Il existe n structures, y compris les cartes d'étudiant, les noms et les notes dans 3 cours. Il est nécessaire d'afficher les informations des étudiants ayant les notes moyennes les plus élevées (y compris les cartes d'étudiant, les noms, les notes dans 3 cours et les notes moyennes). .

#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. Lors de l'appel de la fonction d'entrée, le paramètre réel est la variable de pointeur pt et le paramètre formel est le tableau de structure. Ce qui est transmis est l'adresse de départ de l'élément de structure, et la fonction n'a pas de valeur de retour ;

2. Lors de l'appel de la fonction Max, le paramètre réel est la variable de pointeur pt, le paramètre formel est le tableau de structure, l'adresse de départ de l'élément de structure est transmise et la valeur de retour de la fonction est des données de type structure.

3. Lors de l'appel de la fonction d'impression, les paramètres réels sont des variables de structure (éléments du tableau de structure) et les paramètres formels sont des variables de structure. Ce qui est transmis est la valeur de chaque membre dans la variable de structure, et la fonction n'a aucune valeur de retour.

4. Liste chaînée

4.1 Aperçu

La liste chaînée est une structure de données commune, qui est une structure pour l'allocation dynamique du stockage.

Lors du stockage de données dans un tableau, la longueur du tableau (plusieurs tableaux) doit être définie à l'avance. Si certaines classes comptent 100 élèves et certaines classes 30 élèves, si le même tableau est utilisé pour stocker les données des élèves de différentes classes, il sera utilisé. doit être défini. Un tableau d'une longueur de 100, mais cela conduit souvent à un gaspillage de ressources. La liste chaînée n'a pas de tels défauts. Elle ouvre des unités de mémoire selon les besoins.

La liste chaînée possède une variable « pointeur de tête », représentée par head dans la figure, qui stocke une adresse qui pointe vers un élément. Chaque élément de la liste chaînée est appelé un « nœud », et chaque nœud doit comprendre deux parties :

1. Données réelles requises par les utilisateurs ;

2. L'adresse de l'élément suivant ;

On peut voir que les adresses de chaque élément de la liste chaînée dans la mémoire peuvent être discontinues. Pour trouver un certain élément, vous devez d'abord trouver l'élément précédent, et l'élément suivant peut être trouvé en fonction de l'adresse de l'élément précédent. . Si le "pointeur de tête" n'est pas fourni, la liste chaînée entière est inaccessible.

Dans ce cas, il est plus approprié d'utiliser une structure pour construire une liste chaînée. Une structure contient plusieurs membres, et les membres de type pointeur sont utilisés pour stocker l'adresse du nœud suivant.

structure Étudiant

        {

nombre entier;

score int;

struct Étudiant *suivant;

        }

Parmi eux, num et score sont utilisés pour stocker les données utilisateur, et next est utilisé pour stocker l'adresse du nœud suivant.

4.2 Liste chaînée statique

Cas:

Créer une liste chaînée statique, composée de nœuds avec les données de trois étudiants, et exiger que les données de chaque nœud soient sorties ;

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

Par exemple, créez une liste chaînée de sorte que head pointe vers le nœud a, a.next pointe vers le nœud b, b.next pointe vers le nœud c et c.next pointe vers null. Cela forme une relation de liste chaînée.

Lors de la sortie d'une liste chaînée, vous devez d'abord utiliser p, faire pointer p vers a, puis afficher les données dans a p=p->next pour préparer le nœud suivant pour la sortie.

4.3 Liste chaînée dynamique

4.3.1 Allocation dynamique de mémoire

Avant de parler de listes chaînées dynamiques, commençons par vous présenter l’allocation dynamique de mémoire.

Plus tôt, nous avons dit que les variables sont divisées en variables globales et en variables locales. Les variables globales sont allouées dans la zone de stockage statique de la mémoire. Les variables locales stockées de manière non statique sont allouées dans la zone de stockage dynamique de la mémoire. Cette zone de stockage est appelée mémoire.empiler。

De plus, le langage C permet également d'établir des zones d'allocation de mémoire dynamique pour stocker certaines données temporaires. Ces données sont ouvertes en cas de besoin et libérées lorsqu'elles ne sont pas nécessaires. Ces données sont temporairement stockées dans une zone de stockage libre spéciale.tas。

L'allocation dynamique de la mémoire est réalisée grâce aux fonctions fournies par le système : fonctions malloc, calloc, free et realloc.

1. Utilisez la fonction malloc pour ouvrir une zone de stockage dynamique

fonction: void *malloc (unsigned int taille);

Fonction:

        Allouez un espace continu de longueur (unité : octets) dans la zone de stockage dynamique de la mémoire.

valeur de retour :

L'adresse du premier octet alloué ; cette adresse n'a pas de type, juste une adresse simple ;

2. Utilisez la fonction calloc pour ouvrir une zone de stockage dynamique

fonction：void * calloc(non signé n,taille non signée);

Fonction:

Allouez n octets d'espace continu d'une longueur de taille dans la zone de stockage dynamique de la mémoire. Cet espace est relativement suffisamment grand pour enregistrer un tableau ;

Utilisez la fonction calloc pour ouvrir un espace de stockage dynamique pour un tableau unidimensionnel, n est le nombre d'éléments du tableau et la taille est la longueur de l'élément.

valeur de retour :

L'adresse du premier octet alloué ; cette adresse n'a pas de type, juste une adresse simple ;

3. Utilisez la fonction realloc pour réaffecter la zone de stockage dynamique

fonction:void * realloc(void *p ,unsigned int taille);

Fonction:

Réaffectez la mémoire dynamique allouée.

Utilisez la fonction rappelloc pour modifier la taille de l'espace dynamique pointé par p en taille. La valeur de p reste inchangée ;

valeur de retour :

L'adresse du premier octet de la mémoire dynamique après mise à jour est essentiellement l'adresse pointée par p.

4. Utilisez la fonction gratuite pour libérer la zone de stockage dynamique

fonction: void libre(void *p);

Fonction:

Libérez l'espace dynamique pointé par la variable pointeur p afin que cette partie de l'espace puisse être utilisée par d'autres variables.

p est la valeur de retour obtenue du dernier appel aux fonctions malloc et calloc ;

valeur de retour :

aucun;

Note: Les déclarations des quatre fonctions ci-dessus se trouvent toutes dans le fichier d'en-tête stdlib.h.

type de pointeur vide :

Les valeurs de retour des fonctions ci-dessus malloc et calloc sont toutes deux de type void *, ce qui signifie qu'elles ne pointent vers aucun type de données. Ne le comprenez pas comme pointant vers un type vide. ou ne pointe pas vers des données d'un certain type.

Lors de l'appel de la mémoire dynamique, le programme utilise uniquement l'adresse pure ramenée par la fonction, et n'utilise pas l'attribut pointant vers quel type de données. Si vous souhaitez utiliser cette adresse, il faut la convertir.

Par exemple:

int *p；

p=(int*)malloc(100);

Cas:

Créez des données dynamiques, saisissez les scores de 5 étudiants et utilisez une fonction pour vérifier s'il y a des étudiants avec moins de 60 points, et affichez les scores non qualifiés ;

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

résultat de l'opération :

Analyse des résultats :

Aucun tableau n'est défini dans le programme, mais une zone d'allocation libre dynamique est ouverte pour être utilisée comme tableau.

Dans la fonction malloc, aucune valeur spécifique n'est directement transmise pour allouer de l'espace dynamique. Au lieu de cela, sizeof est utilisé pour calculer le nombre d'octets de l'entier système, puis 5 éléments sont créés. Utilisez p pour pointer vers l'adresse du premier octet et convertissez-la en type int, et p+1 pointe vers l'élément suivant.

4.3.2 Création d'une liste chaînée dynamique

Écrivez une fonction pour créer une liste chaînée dynamique avec des données pour 4 étudiants.

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

résultat de l'opération :

Analyse des résultats: Pour créer une liste chaînée dynamique, trois pointeurs de structure sont d'abord spécifiés, puis la fonction malloc est utilisée pour créer un nœud. Les trois pointeurs de structure pointent vers ce nœud, puis p1 utilise la fonction malloc pour créer le nœud et p2 Next. pointe vers le nœud créé. Après avoir pointé sur p2=p1, p1 crée p2. Next pointe vers le nœud créé, p2=p1....jusqu'à ce que la valeur de l'élément dans p1 soit 0. Next de p2 ne pointe pas vers le nœud créé. nœud nouvellement créé. Le nœud pointe vers NULL De cette façon, une liste chaînée dynamique est créée. Le nœud pointe vers le premier nœud, et c'est le nœud principal.

Entrée et sortie de liste chaînée dynamique :

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

résultat de l'opération :

5. Type de syndicat

5.1 Aperçu

Parfois, vous souhaitez stocker différents types de variables dans une unité de mémoire. Par exemple, placer des variables entières, des variables de caractères et des variables à virgule flottante dans une unité de mémoire en commençant à la même adresse. Cela permet à plusieurs variables de partager la même unité de mémoire. . Une section de la structure de la mémoire est appelée une « union ».

Définir la forme générale d'une union :

nom du syndicat

        {

liste des membres;

}Liste de variables ;

Par exemple:

Données sur les syndicats

        {

int i;

char ch;

flotteur f;

}abc;

La longueur mémoire occupée par une variable de structure est la somme des longueurs mémoire occupées par chaque membre tandis que la longueur mémoire occupée par une union est la longueur du membre le plus long.

5.2 Citations

Seules les variables d'union qui ont été définies à l'avance peuvent être référencées. Notez que nous ne faisons pas référence aux variables d'union mais aux membres des variables d'union référencées.

ai fait référence à la variable entière dans la variable union ;

a.ch fait référence à la variable caractère dans la variable union ;

af fait référence à la variable réelle dans la variable union ;

5.3 Caractéristiques

1. Le segment mémoire peut être utilisé pour stocker plusieurs types différents de membres, mais un seul d'entre eux peut être stocké à chaque instant, plutôt que plusieurs à la fois.

2. Les variables d'union peuvent être initialisées, mais il ne peut y avoir qu'une seule constante dans la table d'initialisation.

3. Le membre de la variable union est le membre attribué la dernière fois et la variable d'origine précédente est écrasée et remplacée.

4. L'adresse d'une variable syndicale est la même que l'adresse de ses membres.

5. Vous ne pouvez pas attribuer une valeur à un nom de variable union, ni tenter de référencer un nom de variable pour obtenir une valeur.

6. Type d'énumération

Si certaines variables n'ont que quelques valeurs possibles, elles peuvent être définies comme types d'énumération ; ce qu'on appelle l'énumération consiste à lister les valeurs possibles une par une.

La déclaration d'un type d'énumération commence par enum par exemple ;

eunm Jour de la semaine{dim,lun,mar,mer,jeu,ven,sam};

Ce qui précède déclare un type d'énumération enum Weekday. Ce type peut ensuite être utilisé pour définir des variables.

enum Jour de la semaine jour ouvrable, week-end ;

Parmi eux, le jour ouvrable et le week-end sont définis comme des variables d'énumération, et les accolades sont appelées éléments d'énumération ou constantes d'énumération.

La forme générale de déclaration d'un type d'énumération :

enum [nom de l'énumération] {liste d'éléments d'énumération} ;

Exemple:

Il y a 5 sortes de boules dans la poche : rouge, jaune, bleue, blanche et noire. Sortez à chaque fois 3 boules du sac. Demandez les manières possibles d'obtenir 3 boules de couleurs différentes et disposez-les ;

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

résultat de l'opération :

7. Utilisez typedef pour déclarer un nouveau nom de type

Utilisez typedef pour spécifier un nouveau nom de type pour remplacer le nom de type existant ;

1. Remplacez simplement le nom du type d'origine par un nouveau nom de type.

Par exemple:

typedef int Entier;

typedef float Réel;

Ainsi, les deux lignes suivantes sont équivalentes :

int i, j, ——— Entier i, j;

2. Nommez un nom de type simple au lieu d'une méthode de représentation de type complexe

  Nommez le nouveau nom de type pour représenter le type de structure :

structure de typedef

        {

int munition;

                ......

} Données;

Utilisez ensuite le nouveau nom de type Data pour définir la variable ;

Anniversaire des données ;

Données * p;

      Nommez un nouveau nom de type au lieu du type de tableau :

typedef int Num[100];

Numéro a;

      Nommez un nouveau nom de type pour représenter le type de pointeur：

typedef char * Chaîne;

Chaîne p,a[10];

      Nommez un nouveau nom de type pour représenter un pointeur vers une fonction ;

typedef int (* Pointeur)();

Pointeur p1,p2;

           Résumé : Selon la manière de définir les variables, remplacez le nom de la variable par un nouveau nom de type et ajoutez typedef au début pour déclarer que le nouveau nom de type représente le type d'origine.

typetef spécifie uniquement un nouveau nom de type pour un type existant, mais ne crée pas de nouveau type.

typetef et #define ont des similitudes superficielles.

typedef int Nombre

#define Compte int

Leur fonction est d'utiliser Count au lieu de int, mais en fait ils sont différents. #define est traité en pré-compilation, il ne peut être utilisé que comme simple remplacement de chaîne, tandis que typedef est traité lors de la phase de compilation. Il ne s'agit pas en réalité d'un simple remplacement. Au lieu de cela, un nouveau nom de type est généré et la variable est définie.