C lässt alle Dinge entstehen | Hinweise vom Flacheren zum Tieferen verstehen [der letzte Teil]

C lässt alle Dinge entstehen | Hinweise vom Flacheren zum Tieferen verstehen [der letzte Teil]

Vorwort

• Wir haben bereits vier Teile gelernt. Wenn Sie die vorherigen Vorschläge nicht gelesen haben, können Sie die vorherigen lesen ~~

• C generiert alle Dinge | Hinweise vom Einfachen zum Tiefsten verstehen [Teil 1]

• C generiert alle Dinge | Zeiger vom Einfachen bis zum Tiefsten verstehen [Teil 2]

• C bringt alle Dinge hervor | Hinweise vom Einfachen zum Tiefsten verstehen [Teil 3] (Implementierung der Übertragungstabelle)

• C generiert alle Dinge | Zeiger vom Einfachen bis zum Tiefsten verstehen [Teil 4] (die Verwendung und Simulationsimplementierung von qsort)

---

• Als nächstes beginnen wir mit dem letzten Teil unserer Hinweise, um unseren Eindruck von Hinweisen zu vertiefen~~

Vergleich von sizeof und strlen

Größe von

• Beim Erlernen der Operatoren haben wir gelernt, sizeof und sizeof zu berechnen, wie groß der von Variablen belegte Speicherplatz ist. Die Einheit ist Byte. If If the Ist der Operand ein Typ, wird die Größe des Speicherplatzes berechnet, der von der mit dem Typ erstellten Variablen belegt wird.

• Beginnen wir mit dem Erlernen von sizeof~~

---

• Unter diesen istsize_t eigentlich speziell für sizeof konzipiert und gibt den Rückgabewerttyp von sizeof an
• sizeof kann keine negative Zahl berechnen, daher ist size_t für sizeof~~ konzipiert

Zum Beispiel:

int main()
{
    
    
	int a = 10;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));
	return 0;
}

• Wenn es sich um eine Variable handelt, können die Klammern weggelassen werden
• Wenn es sich um einen Typ handelt, kann er nicht weggelassen werden

• Die hier berechnete 4 bedeutet, dass sie 4 Bytes belegt.

---

• sizeofWir konzentrieren uns nur auf die Größe des belegten Speicherplatzes und kümmern uns nicht darum, welche Daten im Speicher gespeichert sind. Wir werden uns das gleich im Detail ansehen~~

strlen

strlen ist eine C-Sprachbibliotheksfunktion, deren Funktion darin besteht, die Länge einer Zeichenfolge zu ermitteln. Der Funktionsprototyp lautet wie folgt:

size_t strlen ( const char * str );

Es zählt die Zeichenfolge beginnend mit der Adresse in den Parametern der Funktion rückwärts und vor Anzahl der Zeichen in. Die Funktion sucht so lange rückwärts nach dem Zeichen , bis es gefunden wird. Es kann also zu einer Suche außerhalb der Grenzen kommen. strlenstr\0
strlen\0

Schauen wir uns den folgenden Code an

int main()
{
    
    
	char arr2[] = "abc";
	printf("%d\n", strlen(arr2));
	return 0;
}

• Was ist hier der berechnete Wert von strlen?3
• Wir können auch über das Debugging-Fenster sehen, wie es gespeichert wird ~~

• Sie können sehen, dass 61 im Speicherüberwachungsfenster hier 97 ist, 0 ist \0, strlen ist die Statistik vor \0 Die Anzahl der Zeichenfolgen, das Ergebnis ist3

• Wenn ich dann manuell eines\0 in der Mitte der Zeichenfolge hinzufüge, was wird es dann sein?

char arr2[] = "ab\0c";
printf("%d\n", strlen(arr2));

• Sie können sehen, dass das Ergebnis ist3

• Dann hat die Zeichenfolge nicht\0Was ist ihr Ergebnis?

char arr1[] = {
    
     'a', 'b', 'c' };
printf("%d\n", strlen(arr1));

• Wir können sehen, dass das Ergebnis 15 ist, was eigentlich ein Zufallswert ist. Ich weiß nicht, wie oft wir darauf stoßen werden\0.

• Vergleichen wirstrlen undsizeof

strlen:

• sizeof ist der Operator
• sizeof berechnet die Größe des vom Operanden belegten Speichers, die Einheit ist Bytes
• Achten Sie nicht darauf, welche Daten im Speicher gespeichert sind

Größe von:

• strlen ist eine Bibliotheksfunktion. Um sie verwenden zu können, müssen Sie die Header-Datei einbinden.string.h
• srtlen wird verwendet, um die Länge einer Zeichenfolge zu ermitteln und die Anzahl der Zeichen vor \0 zu zählen
• Achten Sie darauf, ob\0 im Speicher vorhanden ist. Wenn nicht\0, wird die Suche später fortgesetzt und möglicherweise die Grenze überschritten

---

• Wenn sizeof die Größe berechnet, wird sie tatsächlich basierend auf dem Typ berechnet.
• Was steht also unten?

short s = 10;
int i = 2;
int n = sizeof(s = i + 4);
printf("%d\n", n);
printf("%d\n", s);

• Schauen wir uns die Ergebnisse an~~

• Warum 2 und 10? Lass es uns analysieren~~

• Es wird eine kurze Ganzzahl s erstellt, die zwei Bytes belegt, i ist eine Ganzzahl, die vier Bytes belegt

• Ich möchte das Ergebnis von i+4 hier in den s-Typ einfügen. Ich habe 4 Ganzzahlen in den Raum von zwei Ganzzahlen eingefügt. Dies muss gekürzt werden. Nach der Kürzung hat s das letzte Wort, also sind es 2 Bytes.

• Dann wird der zweite Ausdruck, der in sizeof platziert ist, nicht tatsächlich berechnet und nimmt nicht an der Berechnung teil! ! ! Der ursprüngliche Wert gibt also welchen Wert aus ~~

---

• Dann fragen sich einige Schüler vielleicht: Wenn der Ausdruck nicht an der Berechnung beteiligt ist, warum ist dann der Ausdruck über 2? Tatsächlich wird sizeof basierend auf dem Typ abgeleitet. s = i + 4 wird nicht ausgeführt. Die Berechnung von i + 4 ist ein ganzzahliger Typ. Das Ergebnis des ganzzahligen Typs muss in den Schusstyp eingefügt werden, also ist es das kurzer Typ, der aus 2 Wörtern besteht. Festival, verstehst du?~

---

Wenn Sie es immer noch nicht verstehen, werfen wir einen Blick auf einige schriftliche Testfragen, um Ihren Eindruck zu vertiefen~~

Analyse von Array- und Zeiger-Testfragen

eindimensionales Array

• Werfen wir zunächst einen Blick hierher. Was steht unten? Sie können es zuerst selbst analysieren, und dann werden wir es einzeln analysieren ~~

int main()
{
    
    
	int a[] = {
    
     1,2,3,4 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a + 0));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(a[1]));
	printf("%d\n", sizeof(&a));
	printf("%d\n", sizeof(*&a));
	printf("%d\n", sizeof(&a + 1));
	printf("%d\n", sizeof(&a[0]));
	printf("%d\n", sizeof(&a[0] + 1));
	return 0;
}

• Sie müssen wissen, dass der Array-Name die Adresse des ersten Elements ist, es gibt jedoch zwei Ausnahmen:
  • sizeof (Array-Name) – der Array-Name stellt das gesamte Array dar und die Größe des gesamten Arrays wird in Bytes berechnet
  • &Array-Name – Array-Name bedeutet, dass der Array-Name das gesamte Array bedeutet und die Adresse des gesamten Arrays herausgenommen wird.

---

• sizeofDarin befindet sich ein separater Array-Name. Der Array-Name gibt die Größe des gesamten Arrays an. Das Array enthält 4 Elemente, und jedes Element ist 4 Byte groß16

printf("%d\n", sizeof(a));

• Das a im Array-Namen wird hier nicht in sizeof platziert und ist es auch nicht&, also ist a die Adresse des ersten Elements, die Adresse und die Größe ist4/8Bytes

printf("%d\n", sizeof(a + 0));

• a ist die Adresse des ersten Elements des Arrays, a==&a[0], *a ist eigentlich das erste Element, also a[0], und das Die Größe beträgt 4Byte

printf("%d\n", sizeof(*a));

• a ist die Adresse des ersten Elements des Arrays (&a[0] -->int*), a+1–> &a[1], a+1 ist die Adresse des zweiten Elements, so ist das Ergebnis4/8

printf("%d\n", sizeof(a + 1));

• Berechnen Sie die Größe des zweiten Elements in Bytes. Das Ergebnis ist4

printf("%zd\n", sizeof(a[1]));

• &a nimmt die Adresse des Arrays heraus, aber die Adresse des Arrays ist auch eine Adresse und die Größe der Adresse beträgt 4 / 8 Bytes

printf("%zd\n", sizeof(&a));

• Hier &a dient dazu, die Adresse des Arrays herauszunehmen und sie dann zu dereferenzieren, was dem Offset entspricht. &a ist ein Array-Zeiger, das heißtint(*p)[4] = &a, * p access Die Größe eines Arrays, p+1 ist die Größe eines zu überspringenden Arrays, das Ergebnis ist16

printf("%d\n", sizeof(*&a));

• &a+1 ist die Adresse nach dem Überspringen des gesamten Arrays. Die Adressgröße beträgt 4/8 Bytes. Das Ergebnis ist4/8

printf("%zd\n", sizeof(&a + 1));

• Hier ist die Adresse des ersten Elements und das Ergebnis4/8

printf("%zd\n", sizeof(&a[0]));

• Hier ist die Adresse des zweiten Elements und das Ergebnis4/8

printf("%zd\n", sizeof(&a[0] + 1));

• Überprüfen wir es auf vs. Dies wird auf einer 32-Bit-Plattform gedruckt~~

• Dies läuft unter 64 Bit~~

---

Zeichenarray

• Schauen wir uns als Nächstes die Zeichenarrays an

int main()
{
    
    
	char arr[] = {
    
     'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));
	return 0;
}

• Der Array-Name wird separat in sizeof platziert. Die Größe des gesamten Arrays wird berechnet. Es sind 6 Zeichen vorhanden, das Ergebnis ist also6

printf("%d\n", sizeof(arr));

• arr ist die Adresse des ersten Elements des Arrays, arr+0 ist weiterhin die Adresse des ersten Elements. Die Adressgröße beträgt 4/8 Bytes

printf("%d\n", sizeof(arr + 0));

• arr ist die Adresse des ersten Elements des Arrays, *arr ist das erste Element und die Größe eines Zeichens beträgt 1 Bytes

printf("%d\n", sizeof(*arr));

• arr[1] ist das zweite Element des Arrays, die Größe beträgt 1 Byte

printf("%d\n", sizeof(arr[1]));

• &arr ist die Adresse des Arrays. Die Adresse des Arrays ist auch die Adresse. Die Größe ist4/8

printf("%d\n", sizeof(&arr));

• &arr+1 überspringt das gesamte Array und zeigt auf die Rückseite von f4/8

printf("%d\n", sizeof(&arr + 1));

• &arr[0] ist die Adresse des ersten Elements, &arr[0]+1 ist die Adresse des zweiten Elements4/8

printf("%d\n", sizeof(&arr[0] + 1));

• Werfen wir einen Blick auf die 32-Plattform

• Schauen wir uns die 64-Bit-Plattform an

---

• Kommen wir zum zweiten

char arr[] = {
    
     'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr+0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr+1));
printf("%d\n", strlen(&arr[0]+1));

• Dieses Array hat kein \0, strlen berechnet die Anzahl der Elemente vor \0, also ist es随机值

printf("%d\n", strlen(arr));

• Dieser Array-Name ist auch die Adresse des ersten Elements. +0 bedeutet keine Addition. Das Ergebnis ist随机值~~

printf("%d\n", strlen(arr+0));

• Hier ist arr die Adresse des ersten Elements und *arr-Dereferenzierung das Zeichena. Der ASCLL-Codewert ist 97. Wenn 97 an strlen übergeben wird, wird 97 berücksichtigt als Adresse, was illegal ist. Besuchen Sie, das Ergebnis wird报错

printf("%d\n", strlen(*arr));

• Dieser Code ähnelt dem vorherigen Code. Er greift auf den ASCLL-Codewert des zweiten Elements zu, der als Adresse übergeben wird.报错

printf("%d\n", strlen(arr[1]));

• &arr besteht darin, die Adresse dieses Arrays herauszunehmen, dh von der Startposition aus rückwärts zu zählen, und das Ergebnis ist auch so随机值

printf("%d\n", strlen(&arr));

• Dieses &arr ist die Adresse des ersten Elements und dann +1, wobei die Adresse des gesamten Arrays übersprungen wird und nicht bekannt ist, was darin gespeichert ist. Das Ergebnis ist随机值

printf("%d\n", strlen(&arr+1));

• &arr[0] ist die Adresse des ersten Elements, +1 ist die Adresse des zweiten Elements und dann rückwärts gezählt, ist das Ergebnis auch随机值

printf("%d\n", strlen(&arr[0]+1));

---

• Hier initialisieren wirabcdef\0, es gibt \0~~

char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));

• Was hier berechnet wird, ist die Größe des arr-Elements, und das Ergebnis ist7

printf("%d\n", sizeof(arr));

• arr stellt die Adresse des ersten Elements des Arrays dar, arr + 0 ist immer noch die Adresse des ersten Elements und die Größe beträgt 4/8 Bytes

printf("%d\n", sizeof(arr+0));

• arr stellt die Adresse des ersten Elements des Arrays dar, *arr ist das erste Element und die Größe beträgt1Bytes

printf("%d\n", sizeof(*arr));

• arr[1] ist das zweite Element, die Größe beträgt ebenfalls1Bytes

printf("%d\n", sizeof(arr[1]));

• &arr ist die Adresse des Arrays, aber es ist auch eine Adresse. Die Größe der Adresse beträgt 4/8 Bytes

printf("%d\n", sizeof(&arr));

• &arr ist die Adresse des Arrays, &arr+1 ist die Adresse, an der das gesamte Array übersprungen wird. Das Ergebnis sind4/8 Bytes

printf("%d\n", sizeof(&arr+1));

• Die Adresse des zweiten Elements, Größe4/8 Bytes

printf("%d\n", sizeof(&arr[0]+1));

---

• Ändern wir sizeof in strlen~~

char arr[] = "abcdef";
printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr+0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr+1));
printf("%d\n", strlen(&arr[0]+1));

• arr ist die Adresse des ersten Elements. Es berechnet die Anzahl der Elemente, bevor strlen auf \0 trifft. Das Ergebnis ist6

printf("%d\n", strlen(arr));

• arr+1 ist auch die Adresse des ersten Elements und das Ergebnis ist6

printf("%d\n", strlen(arr+0));

• Das Ergebnis hier ist报错, was einen illegalen Zugriff darstellt

printf("%d\n", strlen(*arr));

• Koriya-kai-Formation非法访问~~

printf("%d\n", strlen(arr[1]));

• &arr ist die Adresse des Arrays, aber diese Adresse zeigt auch auf die Startposition des Arrays. strlen beginnt an der Startposition und sucht rückwärts nach \0. Das Ergebnis ist6

printf("%d\n", strlen(&arr));

• &arr+1 ist die Adresse nach dem Überspringen des gesamten Arrays, beginnend von hier und rückwärts nach \0, d. h随机值

printf("%d\n", strlen(&arr+1));

• arr[0] + 1 ist die Adresse des zweiten Elements, die Länge beträgt5

printf("%d\n", strlen(&arr[0]+1));

• Werfen wir einen Blick auf die Ergebnisse~~

---

• Unsere Zeigervariable hierp speichert die Adresse dieser Zeichenfolge a

char *p = "abcdef";
printf("%d\n", sizeof(p));
printf("%d\n", sizeof(p+1));
printf("%d\n", sizeof(*p));
printf("%d\n", sizeof(p[0]));
printf("%d\n", sizeof(&p));
printf("%d\n", sizeof(&p+1));
printf("%d\n", sizeof(&p[0]+1));

• p ist eine Zeigervariable, die Größe beträgt4/8 Bytes

printf("%d\n", sizeof(p));

• p+1 ist die Adresse von „b“, also 4/8 Bytes

printf("%d\n", sizeof(p+1));

• *pIst das erste Zeichen, die Größe beträgt 1 Byte

printf("%d\n", sizeof(*p));

• p[0] === *(p+0), was tatsächlich das erste Zeichen in der Zeichenfolge ist und die Größe 1 Byte beträgt

printf("%d\n", sizeof(p[0]));

• &p ist die Adresse von p, die auch die Adresse ist. Die Adressgröße beträgt 4/8 Byte.

printf("%d\n", sizeof(&p));

• &p + 1 ist ebenfalls eine Adresse, &p1+1 ist die Adresse nach dem Überspringen der p-Variablen

printf("%d\n", sizeof(&p+1));

• 4/8 – &p[0] + 1 ist die Adresse von b

printf("%d\n", sizeof(&p[0]+1));

Unter 32 Bit

Unter 64-Bit

char *p = "abcdef";
printf("%d\n", strlen(p));
printf("%d\n", strlen(p+1));
printf("%d\n", strlen(*p));
printf("%d\n", strlen(p[0]));
printf("%d\n", strlen(&p));
printf("%d\n", strlen(&p+1));
printf("%d\n", strlen(&p[0]+1));

• p zeigt auf die Adresse des ersten Elements dieser Zeichenfolge. Es gibt \0 in der Zeichenfolge. Ausgehend von der Adresse von a und beim Rückwärtszugriff lautet das Ergebnis6

printf("%d\n", strlen(p));

• Der Typ von p istchar*, und +1 überspringt Daten vom Typ char, sodass wir zum Zeichen 'b'

printf("%d\n", strlen(p+1));

• *p ruft das Zeichen ab'a', strlen übergibt den ASCLL-Codewert des Zeichens a als Adresse, was zu illegalem Zugriff führt, und das Ergebnis isterr

printf("%d\n", strlen(*p));	

• Dies ist dasselbe wie das vorherige und führt auch zu illegalem Zugriff, was gleichbedeutend mit ist *p == *(p+0) == p[0]

printf("%d\n", strlen(p[0]));

• Dieses Ergebnis ist ein Zufallswert, &p ist die Adresse von p und der Typ istchar*Es wird von der Startposition des von p eingenommenen Platzes aus gesucht. Dies ist nicht der Fall wissen, wann es auf \0 treffen wird, also wird es ein zufälliger Wert sein

printf("%d\n", strlen(&p));

• Nach dem Abrufen der Adresse wird der Typ dieses Codes zuchar**, +1 überspringt einen Datentypchar*, Es zeigt auf die Position am Ende der Zeichenfolge. Von hier aus suchen Sie rückwärts\0. Sie wissen nicht, wann Sie darauf stoßen werden, daher ist das Endergebnis immer noch随机值

printf("%d\n", strlen(&p+1));

• Dies ist dem zweiten sehr ähnlich, & und [] entsprechen dem Abbrechen, +1 zeigt auf'b' und das Ergebnis ist5

printf("%d\n", strlen(&p[0]+1));

---

Schauen wir uns zum Schluss noch das zweidimensionale Array an, das auch der schwierigere Teil ist.

Zweidimensionales Array

int a[3][4] = {
    
    0};
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(a[0][0]));
printf("%d\n",sizeof(a[0]));
printf("%d\n",sizeof(a[0]+1));
printf("%d\n",sizeof(*(a[0]+1)));
printf("%d\n",sizeof(a+1));
printf("%d\n",sizeof(*(a+1)));
printf("%d\n",sizeof(&a[0]+1));
printf("%d\n",sizeof(*(&a[0]+1)));
printf("%d\n",sizeof(*a));
printf("%d\n",sizeof(a[3]));

• sizeof (Array-Name) berechnet die Größe des gesamten Arrays. Dies ist ein zweidimensionales Array. Das Array besteht aus drei Zeilen und vier Spalten mit insgesamt zwölf Elementen. Der Typ jedes Elements ist int, also 4 Byte . Dann beträgt die Gesamtgröße48

printf("%d\n", sizeof(a));

• a[0][0] stellt das Element in der ersten Zeile und Spalte des Arrays dar, sodass jedes Element 4 Bytes ist

printf("%d\n", sizeof(a[0][0]));

• a[0]ist der Array-Name der ersten Zeile und wird separat in sizeof() platziert. Die Größe der gesamten ersten Zeile wird berechnet. Es enthält 4 Elemente und jedes Element ist 4 Bytes groß. Dann Das Ergebnis ist16

printf("%d\n", sizeof(a[0]));

• a[0] ist der Array-Name des Arrays in der ersten Zeile, aber der Array-Name steht nicht allein in sizeof, sodass der Array-Name die Adresse des ersten Elements des Arrays darstellt, nämlich das Adresse von a[0][0] , a[0]+1 ist die Adresse des zweiten Elements in der ersten Zeilea[0][1] und die Größe der Adresse ist 4/8 Bytes

printf("%d\n", sizeof(a[0] + 1));

• a[0] + 1 ist die Adresse des zweiten Elements in der ersten Zeilea[0][1], *(a[0] + 1) ist das zweite Element in der ersten Zeile und die Größe ist 4

printf("%d\n", sizeof(*(a[0] + 1)));

• a wird nicht allein in sizeof platziert. Es gibt kein &. Der Array-Name a ist die Adresse des ersten Elements des Arrays, also die Adresse der ersten Zeile. a+1 ist die Adresse der zweiten Zeile. , was a -- int(*)[4] ----> entsprichta+1 -- int(*)[4]

printf("%d\n", sizeof(a + 1));

• Das Folgende besteht darin, diese Zeile zu dereferenzieren und dann die gesamte zweite Zeile zu erhalten. Zu diesem Zeitpunkt ist die Berechnung die Größe der gesamten Zeile und das Ergebnis ist16

printf("%d\n", sizeof(*(a + 1)));

• Dies ist dasselbe wie das vorherige, außer dass es anders geschrieben ist, was äquivalent zu*(a + 1) ist. Es berechnet die Elementgröße der zweiten Zeile und die Ergebnis ist16

printf("%d\n", sizeof(a[1]));

• a[0] ist der Array-Name der ersten Zeile. Wenn Sie die Adresse davon erhalten, können Sie die Adresse der gesamten Zeile erhalten. Sein Typ ist auch ein Array-Zeiger int (*)[4] , dann < Wenn /span>+1, wird auch das gesamte Array übersprungen. Zu diesem Zeitpunkt haben wir die zweite Zeile erreicht und die Adresse der zweiten Zeile wird erhalten. Die Größe der Adresse beträgt 4/8Bytes

printf("%d\n", sizeof(&a[0] + 1));

• Dies ähnelt dem obigen. Die zweite Dereferenzierungszeile berechnet die Größe des Elements in der zweiten Zeile. Das Ergebnis ist16

printf("%d\n", sizeof(*(&a[0] + 1)));

• Der Array-Name a ist die Adresse des ersten Elements des Arrays, also die Adresse der ersten Zeile.*a ist eine Zeile, was äquivalent zu ist*(a+0) == a[0]

printf("%d\n", sizeof(*a));

• Hat dieses zweidimensionale Array nicht nur drei Zeilen? Das Array in der dritten Zeile heißt a[2]. Ist a[3] nicht außerhalb der Grenzen?

• Sie müssen wissen, dass es für jeden Ausdruck zwei Attribute gibt, eines ist [Wertattribut] und das andere ist [Typattribut].

• Beispiel: 3 + 5 = 8, sein Wertattribut ist die Zahl 8 und sein Typattribut ist int. Für [sizeof()] muss es jedoch bei der Berechnung nur das [Typattribut] kennen, ähnlich wie bei dem, was wir geschrieben haben zuvor können Sizeof(int), sizeof(char) usw. für diese integrierten Typen berechnet werden, ohne tatsächlich Platz zu schaffen.

• Für das folgende a[3] ist es sizeof() egal, ob Sie außerhalb der Grenzen liegen, obwohl es außerhalb der Grenzen zu liegen scheint, sondern es muss nur Ihr Typ bekannt sein. Dann ist a[3] das erste Element von Das zweidimensionale Array. Vier Zeilen, obwohl es keine vierte Zeile gibt, aber der Typ wird bestimmt, dann wird die Größe bestimmt. Durch Berechnen von sizeof (Array-Name) wird die Größe des gesamten Arrays berechnet, und das Ergebnis ist16

printf("%d\n", sizeof(a[3]));

• Werfen wir einen Blick auf die laufenden Ergebnisse~~