Technologieaustausch

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

1. Strukturen definieren und nutzen

1.1 Übersicht

Die Datentypen, die wir zuvor gesehen haben, wie z. B. int, float, char usw., werden einfach in Programmen verwendet. Wenn wir komplexe Daten gemäß unseren eigenen Anforderungen erstellen möchten, müssen wir Strukturen verwenden.

Beispielsweise gehören die Schülernummer, der Name, das Geschlecht, das Alter usw. eines Schülers zu demselben Schüler, aber diese Variablen gehören zu unterschiedlichen Typen. Wenn Sie nur unterschiedliche Variablen verwenden, um einfache Definitionen zu erstellen, ist es schwierig, die Beziehung zwischen ihnen abzubilden . Innere Verbindung. Dann erstellen wir eine Variable, die diese Daten kombinieren und in die Variable einfügen kann, sodass sie viel einfacher zu verwenden ist. Dies ist das Erlernen der Struktur.

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

In:

struct Student ist ein Strukturtyp;

struct ist ein Schlüsselwort, das einen Strukturtyp deklariert.

Student ist der Name der Struktur, um sie von anderen Strukturen zu unterscheiden;

Die geschweiften Klammern enthalten die Mitglieder der Struktur. Die Gruppe wird zusammen als Mitgliederliste bezeichnet, und ihre Benennung stimmt mit der Benennung der Variablen überein.

Hinweis: Strukturtypen können mehrere Typen haben, wie zum Beispiel: struct Student;

Mitglieder einer Struktur können auch vom Typ einer anderen Struktur sein;

Struktur Datum

{        

int Monat;

int Tag;

int Jahr;

};

struct-Student

{

int-num;

Zeichenname[20];

Saiblingsgeschlecht;

int Alter;

Struktur Datum Geburtstag;

char Adresse[30];

}

1.2 Definition von Strukturvariablen

Zuvor haben wir nur einen Strukturtyp definiert, der einem Modell entspricht, und keine Variablen definiert. Als nächstes definieren wir Strukturvariablen und speichern darin spezifische Daten, 3 Methoden.

Methode 1: Deklarieren Sie zuerst den Strukturtyp und definieren Sie dann die Strukturvariablen

Definieren Sie Strukturvariablen basierend auf dem vorherigen Strukturtyp struct Student.

Struktur Student student1,student2;

Diese Methode ähnelt int a,b; die einzige Voraussetzung ist, dass bereits ein Strukturtyp vorhanden ist und die Strukturvariable basierend auf dem Typ definiert ist.

    Methode 2: Definieren Sie Variablen beim Deklarieren des Typs

bilden:

struct Strukturname

                {

Mitgliederliste;

}Variablennamenliste;

Beispiel:

struct-Student
                {
int-num;
Zeichenname[20];
Saiblingsgeschlecht;
int Alter;
Gleitkommazahl;
char Adresse[30];
}Schüler1,Schüler2;

      Methode 3: Strukturtypvariablen direkt definieren, ohne einen Typnamen anzugeben

bilden:

Struktur

                        {

Mitgliedsvariablen;

}Variablennamenliste;

Es handelt sich um einen unbenannten Strukturtyp, der nicht häufig verwendet wird.

Hinweis: 1. Die Mitgliedsnamen in den Strukturvariablen können mit den Variablennamen im Programm identisch sein.

2. Mitglieder von Strukturvariablen können allein verwendet werden; ihr Status und ihre Funktion entsprechen gewöhnlichen Variablen;

1.3 Initialisierung und Referenz von Strukturvariablen

Initialisieren Sie die Strukturvariablen, wenn Sie sie definieren.

      Beispiel:Fügen Sie die Informationen eines Schülers (einschließlich Schülernummer, Name, Geschlecht, Adresse) in eine Strukturvariable ein und geben Sie dann die Informationen des Schülers aus.

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

Ergebnisanalyse:

Initialisieren Sie beim Definieren einer Strukturvariablen übrigens die Anzahl der in geschweiften Klammern eingeschlossenen Konstanten. Hinweis: Dies ist keine Initialisierung der Strukturvariablen die Struktur.

Der Wert des Mitglieds in der Strukturvariablen, die Referenzmethode, lautet:

Name der Strukturvariablen.Name des Mitglieds

student1.name

      Für Strukturmitglieder, die zu einem anderen Strukturtyp gehören, müssen die Elemente der niedrigsten Ebene Ebene für Ebene gefunden werden. Die oben erwähnte Struktur Student enthält beispielsweise die Struktur Date Birthday.

Schülergeburtstagsmonat

Strukturen gleichen Typs können einander zugeordnet werden:Schüler1 = Schüler2;

        Beispiel:Geben Sie den Studentenausweis, den Namen und die Noten von zwei Studenten ein und geben Sie den Studentenausweis, den Namen und die Note des Studenten mit den besseren Noten aus;

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

Wenn Sie die Scanf-Funktion zur Eingabe von Strukturvariablen verwenden, müssen Sie diese separat eingeben. Sie können nicht den Strukturvariablennamen in der Scanf-Funktion verwenden, um die Werte aller Mitglieder gleichzeitig einzugeben. Beachten Sie, dass die Scanf-Funktion nicht über ein & verfügt von student1.name, da der Array-Name ursprünglich die Adresse darstellt.

2. Strukturarray verwenden

2.1 Strukturarray definieren

Als wir die Strukturvariablen zuvor definiert haben, haben wir sie einzeln definiert. Wenn es sich jedoch um eine Gruppe verwandter Daten handelt, die an der Operation teilnehmen müssen, ist es offensichtlich erforderlich, Daten wie die Informationen von 10 Schülern zu verwenden ist das Strukturarray, jedes Arrayelement des Strukturarrays ist eine Struktur.

Beispiel: Es gibt drei Kandidaten und jeder Wähler kann nur für eine Person stimmen. Es ist erforderlich, ein Programm zum Auszählen der Stimmen zu schreiben. Geben Sie zunächst den Namen des Kandidaten ein und zeigen Sie schließlich das Ergebnis der Abstimmung jeder Person an.

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

Definieren Sie die allgemeine Form eines Strukturarrays:

        struct Strukturname

        {

Variablenliste

} Array-Name [Array-Länge];

oder

Deklarieren Sie zunächst einen Strukturtyp, z. B.: struct student, und definieren Sie dann das Strukturarray.

        Strukturtyp-Array-Name [Array-Länge];

Die Form der Initialisierung eines Strukturarrays besteht darin, nach der Definition Folgendes hinzuzufügen:

      ={Anfangswertliste};     

2.2 Strukturarray verwenden

        Beispiel:Es liegen Informationen zu n Schülern vor (einschließlich Schülerausweis, Name und Noten), und es ist erforderlich, die Informationen jedes Schülers in der Reihenfolge der Note auszugeben.

#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. Strukturzeiger

3.1 Zeiger auf Strukturvariablen

Der sogenannte Strukturzeiger ist ein Zeiger auf eine Strukturvariable. Die Startadresse einer Strukturvariablen ist der Zeiger der Strukturvariablen.

Eine Zeigervariable, die auf ein Strukturobjekt zeigt, kann entweder auf eine Strukturvariable oder auf ein Element eines Strukturarrays zeigen. Der Basistyp der Zeigervariablen muss mit dem Typ der Strukturvariablen identisch sein.

Zum Beispiel: struct Student * pt;

Beispiel:Geben Sie die Informationen der Mitglieder in der Strukturvariablen über die Zeigervariable aus, die auf die Strukturvariable zeigt.

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

Ergebnisanalyse:

In der Funktion greift die erste printf-Funktion über den Strukturvariablennamen stu1 auf Mitglieder zu.

Die zweite printf-Funktion greift auf ihre Mitglieder über eine Zeigervariable zu, die auf eine Strukturvariable zeigt. (*pt) stellt die Strukturvariable dar, auf die gezeigt wird, und (*pt).num stellt das Strukturmitglied dar, auf das gezeigt wird.

Darüber hinaus ist es in der C-Sprache zulässig, (*pt).num durch pt->num zu ersetzen;

3.2 Zeiger auf Strukturarray

Zeigervariablen können verwendet werden, um auf Elemente des Strukturarrays zu zeigen.

Beispiel:Es gibt drei Schülerinformationen, die im Strukturarray platziert sind, und die Schülerinformationen müssen ausgegeben werden.

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

Im Programm ist pt ein Zeiger auf eine Strukturvariable vom Typ struct Student, nicht auf ein bestimmtes Mitglied der Struktur Strukturvariable und die andere ist eine Strukturmitgliedsvariable. p++, der Wert von p erhöht die Länge der Struktur.

3.3 Verwenden Sie Strukturvariablen und Zeiger auf Strukturvariablen als Funktionsparameter

Es gibt drei Möglichkeiten, den Wert einer Strukturvariablen an eine Funktion zu übergeben;

1. Verwenden Sie die Mitglieder der Strukturvariablen als Parameter. Diese Methode entspricht der Übergabe gewöhnlicher Variablen. Es ist zu beachten, dass die formalen und tatsächlichen Parameter (Strukturmitglieder) denselben Typ haben.

2. Strukturvariablen als Aktualparameter verwenden. Wenn eine Strukturvariable als Aktualparameter verwendet wird, wird sie auch als Wert übergeben. Der gesamte Inhalt der von der Strukturvariablen belegten Speichereinheit wird an den Formalparameter übergeben.

3. Verwenden Sie den Zeiger auf die Strukturvariable (Array) als Aktualparameter, um die Adresse der Strukturvariablen (Array) an den Formalparameter zu übergeben.

Beispiel:

Es gibt n Strukturen, einschließlich Studentenausweise, Namen und Noten in 3 Kursen. Es ist erforderlich, die Informationen der Studenten mit den höchsten Durchschnittsnoten auszugeben (einschließlich Studentenausweise, Namen, Noten in 3 Kursen und Durchschnittsnoten). .

#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. Beim Aufruf der Eingabefunktion ist der eigentliche Parameter die Zeigervariable pt und der formale Parameter ist das Strukturarray. Übergeben wird die Startadresse des Strukturelements, und die Funktion hat keinen Rückgabewert.

2. Beim Aufruf der Max-Funktion ist der eigentliche Parameter die Zeigervariable pt, der formale Parameter ist das Strukturarray, die Startadresse des Strukturelements wird übergeben und der Funktionsrückgabewert sind Strukturtypdaten.

3. Beim Aufruf der Druckfunktion sind die tatsächlichen Parameter Strukturvariablen (Strukturarray-Elemente) und die formalen Parameter sind Strukturvariablen. Übergeben wird der Wert jedes Elements in der Strukturvariablen, und die Funktion hat keinen Rückgabewert.

4. Verknüpfte Liste

4.1 Übersicht

Die verknüpfte Liste ist eine allgemeine Datenstruktur, bei der es sich um eine Struktur für die dynamische Speicherzuweisung handelt.

Beim Speichern von Daten in einem Array muss die Array-Länge (mehrere Arrays) im Voraus definiert werden. Wenn einige Klassen 100 Schüler und andere 30 Schüler haben, wird dasselbe Array zum Speichern der Daten von Schülern verschiedener Klassen verwendet Es muss ein Array mit einer Länge von 100 definiert werden, was jedoch häufig zu einer Verschwendung von Ressourcen führt. Die verknüpfte Liste weist nicht die erforderlichen Speichereinheiten auf.

Die verknüpfte Liste verfügt über eine „Kopfzeiger“-Variable, die in der Abbildung durch „head“ dargestellt wird und eine Adresse speichert, die auf ein Element zeigt. Jedes Element in der verknüpften Liste wird als „Knoten“ bezeichnet und jeder Knoten sollte zwei Teile enthalten:

1. Tatsächliche Daten, die von Benutzern benötigt werden;

2. Die Adresse des nächsten Elements;

Es ist ersichtlich, dass die Adressen jedes Elements in der verknüpften Liste im Speicher diskontinuierlich sein können. Um ein bestimmtes Element zu finden, müssen Sie zuerst das vorherige Element finden, und das nächste Element kann basierend auf der Adresse des vorherigen Elements gefunden werden . Wenn der „Kopfzeiger“ nicht bereitgestellt wird, ist die gesamte verknüpfte Liste nicht zugänglich.

In diesem Fall ist es am besten, eine Struktur zum Erstellen einer verknüpften Liste zu verwenden. Eine Struktur enthält mehrere Mitglieder, und Mitglieder vom Zeigertyp werden zum Speichern der Adresse des nächsten Knotens verwendet.

struct-Student

        {

int-num;

int-Punktzahl;

Struktur Student *next;

        }

Unter diesen werden Num und Score zum Speichern von Benutzerdaten und Next zum Speichern der Adresse des nächsten Knotens verwendet.

4.2 Statische verknüpfte Liste

Fall:

Erstellen Sie eine statisch verknüpfte Liste, die aus Knoten mit Daten von drei Schülern besteht, und verlangen Sie, dass die Daten jedes Knotens ausgegeben werden.

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

Erstellen Sie beispielsweise eine verknüpfte Liste, sodass head auf Knoten a, a.next auf Knoten b, b.next auf Knoten c und c.next auf null zeigt. Dadurch entsteht eine verknüpfte Listenbeziehung.

Bei der Ausgabe einer verknüpften Liste müssen Sie zuerst p verwenden, p auf a zeigen lassen und dann die Daten in a ausgeben, um den nächsten Knoten für die Ausgabe vorzubereiten.

4.3 Dynamische verknüpfte Liste

4.3.1 Dynamische Speicherzuweisung

Bevor wir über dynamische verknüpfte Listen sprechen, stellen wir Ihnen zunächst die dynamische Speicherzuweisung vor.

Zuvor haben wir gesagt, dass Variablen in globale Variablen und lokale Variablen im statischen Speicherbereich des Speichers unterteilt sind. Nicht statisch gespeicherte lokale Variablen werden im dynamischen Speicherbereich des Speichers zugewiesen Dieser Speicherbereich wird aufgerufenStapel。

Darüber hinaus ermöglicht die C-Sprache auch die Einrichtung dynamischer Speicherzuweisungsbereiche zum Speichern einiger temporärer Daten. Diese Daten werden bei Bedarf geöffnet und bei Nichtgebrauch freigegeben. Diese Daten werden vorübergehend in einem speziellen freien Speicherbereich gespeichertHaufen。

Die dynamische Zuweisung von Speicher wird durch vom System bereitgestellte Funktionen erreicht: Malloc-, Calloc-, Free- und Realloc-Funktionen.

1. Verwenden Sie die malloc-Funktion, um einen dynamischen Speicherbereich zu öffnen

Funktion: void *malloc (vorzeichenlose int-Größe);

Funktion:

        Weisen Sie im dynamischen Speicherbereich des Speichers einen kontinuierlichen Speicherplatz mit einer Längengröße (Einheit: Bytes) zu.

Rückgabewert:

Die Adresse des ersten zugewiesenen Bytes; diese Adresse hat keinen Typ, sondern nur eine einfache Adresse;

2. Öffnen Sie mit der Calloc-Funktion einen dynamischen Speicherbereich

Funktion:void * calloc(unsigned n,unsigned size);

Funktion:

Weisen Sie n Bytes kontinuierlichen Speicherplatz mit einer Länge von size im dynamischen Speicherbereich des Speichers zu. Dieser Platz ist relativ groß genug, um ein Array zu speichern;

Verwenden Sie die Calloc-Funktion, um dynamischen Speicherplatz für ein eindimensionales Array zu öffnen. n ist die Anzahl der Array-Elemente und Größe ist die Länge des Elements.

Rückgabewert:

Die Adresse des ersten zugewiesenen Bytes; diese Adresse hat keinen Typ, sondern nur eine einfache Adresse;

3. Verwenden Sie die Realloc-Funktion, um den dynamischen Speicherbereich neu zuzuweisen

Funktion:void * realloc(void *p, vorzeichenlose int-Größe);

Funktion:

Allokierten dynamischen Speicher neu zuweisen.

Verwenden Sie die Funktion „recallloc“, um die Größe des dynamischen Raums, auf den p zeigt, in „size“ zu ändern. Der Wert von p bleibt unverändert;

Rückgabewert:

Die Adresse des ersten Bytes des dynamischen Speichers nach der Aktualisierung ist im Wesentlichen die Adresse, auf die p zeigt.

4. Verwenden Sie die Free-Funktion, um den dynamischen Speicherbereich freizugeben

Funktion: void frei(void *p);

Funktion:

Geben Sie den dynamischen Raum frei, auf den die Zeigervariable p zeigt, damit dieser Teil des Raums von anderen Variablen verwendet werden kann.

p ist der Rückgabewert, der vom letzten Aufruf der malloc- und calloc-Funktionen erhalten wurde;

Rückgabewert:

keiner;

Notiz: Die Deklarationen der oben genannten vier Funktionen befinden sich alle in der Header-Datei stdlib.h.

Leerer Zeigertyp:

Die Rückgabewerte der oben genannten Funktionen Malloc-Funktion und Calloc-Funktion sind beide vom Typ void *, was bedeutet, dass sie nicht auf einen Datentyp verweisen, sondern auf einen leeren Typ oder verweist nicht auf Daten eines bestimmten Typs.

Beim Aufruf des dynamischen Speichers verwendet das Programm nur die von der Funktion zurückgegebene reine Adresse und nicht das Attribut, das auf den Datentyp verweist. Wenn Sie diese Adresse verwenden möchten, muss sie konvertiert werden.

Zum Beispiel:

int *p;

p=(int*)malloc(100);

Fall:

Erstellen Sie dynamische Daten, geben Sie die Ergebnisse von 5 Schülern ein und verwenden Sie eine Funktion, um zu prüfen, ob es Schüler mit weniger als 60 Punkten gibt, und geben Sie die unqualifizierten Ergebnisse aus.

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

Operationsergebnis:

Ergebnisanalyse:

Im Programm ist kein Array definiert, es wird jedoch ein dynamischer Bereich mit freier Zuordnung zur Verwendung als Array geöffnet.

In der malloc-Funktion wird kein spezifischer Wert direkt übergeben, um dynamischen Speicherplatz zuzuweisen. Stattdessen wird sizeof verwendet, um die Anzahl der Bytes der System-Ganzzahl zu berechnen, und dann werden 5 Elemente erstellt. Verwenden Sie p, um auf die erste Byte-Adresse zu zeigen und sie in den Typ int zu konvertieren, und p+1 zeigt auf das nächste Element.

4.3.2 Erstellung einer dynamischen verknüpften Liste

Schreiben Sie eine Funktion, um eine dynamisch verknüpfte Liste mit Daten für 4 Schüler zu erstellen.

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

Operationsergebnis:

Ergebnisanalyse: Um eine dynamisch verknüpfte Liste zu erstellen, werden zuerst drei Strukturzeiger angegeben, und dann wird die Malloc-Funktion verwendet, um einen Knoten zu erstellen. Alle drei Strukturzeiger zeigen auf diesen Knoten, und dann verwendet p1 die Malloc-Funktion, um den Knoten zu erstellen, und p2 Zeigt auf den erstellten Knoten, p1 erstellt p2 und zeigt auf den erstellten Knoten, p2 = p1 ... bis der Wert des Elements in p1 0 ist. Next von p2 zeigt nicht auf Der neu erstellte Knoten zeigt auf NULL. Auf diese Weise wird eine dynamische verknüpfte Liste erstellt. Der Kopf zeigt auf den ersten Knoten.

Eingabe und Ausgabe einer dynamischen verknüpften Liste:

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

Operationsergebnis:

5. Union-Typ

5.1 Übersicht

Manchmal möchten Sie verschiedene Arten von Variablen in einer Speichereinheit speichern. Platzieren Sie beispielsweise Integer-Variablen, Zeichenvariablen und Gleitkommavariablen in einer Speichereinheit, beginnend bei derselben Adresse. Dadurch können mehrere Variablen dieselbe Speichereinheit teilen . Ein Abschnitt der Speicherstruktur wird als „Vereinigung“ bezeichnet.

Definieren Sie die allgemeine Form einer Union:

Gewerkschaft Gewerkschaftsname

        {

Mitgliederliste;

}Variablenliste;

Zum Beispiel:

Gewerkschaftsdaten

        {

int ich;

verkohlen ch;

Schwimmer f;

}ABC;

Die von einer Strukturvariablen belegte Speicherlänge ist die Summe der von jedem Mitglied belegten Speicherlängen, während die von einer Union belegte Speicherlänge die Länge des längsten Mitglieds ist.

5.2 Zitate

Es kann nur auf die zuvor definierten Unionsvariablen verwiesen werden. Beachten Sie, dass wir nicht auf die Unionsvariablen verweisen, sondern auf die Mitglieder der referenzierten Unionsvariablen.

ai bezieht sich auf die Ganzzahlvariable in der Unionsvariablen;

a.ch bezieht sich auf die Zeichenvariable in der Unionsvariablen;

af bezieht sich auf die reelle Variable in der Unionsvariablen;

5.3 Funktionen

1. Das Speichersegment kann zum Speichern mehrerer verschiedener Arten von Elementen verwendet werden, es kann jedoch jeweils nur eines davon gespeichert werden und nicht mehrere gleichzeitig.

2. Union-Variablen können initialisiert werden, die Initialisierungstabelle darf jedoch nur eine Konstante enthalten.

3. Das Mitglied der Unionsvariablen ist das zuletzt zugewiesene Mitglied, und die vorherige Originalvariable wird überschrieben und ersetzt.

4. Die Adresse einer Unionsvariablen ist dieselbe wie die Adresse ihrer Mitglieder.

5. Sie können einem Union-Variablennamen keinen Wert zuweisen und auch nicht versuchen, auf einen Variablennamen zu verweisen, um einen Wert zu erhalten.

6. Aufzählungstyp

Wenn einige Variablen nur wenige mögliche Werte haben, können sie als Aufzählungstypen definiert werden; die sogenannte Aufzählung besteht darin, die möglichen Werte einzeln aufzulisten.

Die Deklaration eines Aufzählungstyps beginnt beispielsweise mit enum;

eunm Wochentag {So, Mo, Di, Mi, Do, Fr, Sa};

Das Obige deklariert einen Aufzählungstyp enum Weekday. Dieser Typ kann dann zur Definition von Variablen verwendet werden.

Aufzählung Wochentag, Arbeitstag, Wochenende;

Unter diesen werden Arbeitstag und Wochenende als Aufzählungsvariablen definiert, und die geschweiften Klammern werden als Aufzählungselemente oder Aufzählungskonstanten bezeichnet.

Die allgemeine Form der Deklaration eines Aufzählungstyps:

enum [Aufzählungsname] {Aufzählungselementliste};

Beispiel:

Es gibt 5 Arten von Bällen in der Tasche: Rot, Gelb, Blau, Weiß und Schwarz. Nehmen Sie jedes Mal 3 Bälle aus der Tasche und fragen Sie nach den Möglichkeiten, 3 Bälle in verschiedenen Farben zu erhalten.

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

Operationsergebnis:

7. Verwenden Sie typedef, um einen neuen Typnamen zu deklarieren

Verwenden Sie typedef, um einen neuen Typnamen anzugeben, der den vorhandenen Typnamen ersetzt.

1. Ersetzen Sie einfach den ursprünglichen Typnamen durch einen neuen Typnamen.

Zum Beispiel:

Typdefinition int Integer;

Typdefinition Float Real;

Somit sind die folgenden zwei Zeilen äquivalent:

int i, j; ——— Ganzzahlige Zahl i, j;

2. Benennen Sie einen einfachen Typnamen anstelle einer komplexen Typdarstellungsmethode

  Benennen Sie den neuen Typnamen, um den Strukturtyp darzustellen:

typedef-Struktur

        {

int mun;

                ......

} Daten;

Verwenden Sie dann den neuen Typnamen „Data“, um die Variable zu definieren.

Daten Geburtstag;

Daten * p;

      Benennen Sie anstelle des Array-Typs einen neuen Typnamen:

Typdefinition int Num[100];

Anzahl a;

      Benennen Sie einen neuen Typnamen, um den Zeigertyp darzustellen：

Typdefinition: Zeichen * Zeichenfolge;

Zeichenfolge p,a[10];

      Benennen Sie einen neuen Typnamen, um einen Zeiger auf eine Funktion darzustellen.

typedef int (* Zeiger)();

Zeiger p1,p2;

           Zusammenfassung: Ersetzen Sie entsprechend der Art der Variablendefinition den Variablennamen durch einen neuen Typnamen und fügen Sie typedef vorne hinzu, um zu deklarieren, dass der neue Typname den ursprünglichen Typ darstellt.

typetef gibt nur einen neuen Typnamen für einen vorhandenen Typ an, erstellt jedoch keinen neuen Typ.

typetef und #define haben oberflächliche Ähnlichkeiten.

Typdefinition int Anzahl

#define Anzahl int

Ihre Funktion besteht darin, Count anstelle von int zu verwenden. Tatsächlich unterscheiden sie sich jedoch darin, dass #define in der Vorkompilierungsphase verarbeitet wird und nur als einfacher String-Ersatz verwendet werden kann, während typedef in der Kompilierungsphase verarbeitet wird. Es handelt sich eigentlich nicht um einen einfachen Ersatz. Stattdessen wird ein neuer Typname generiert und die Variable definiert.