1. Schlüsselwörter im Zusammenhang mit Datentypen
Wird zum Definieren von Variablen oder Typen verwendet.
Variablenformat definieren: Typvariablenname;
Benennungsregeln für Variablennamen: Buchstaben, Zahlen, Unterstriche, dürfen jedoch nicht mit Zahlen beginnen.
char、short、int、long、float、double
struct、union、enum、signed、unsigned、void
1. Zeichentyp char
(1) Mit char definierte Variablen sind Zeichenvariablen.
(2) Belegen 1 Byte
. (3) Wertebereich: 0 bis 255.
(4) Wenn Zeichenvariablen im Speicher gespeichert werden, wird der dem Zeichen entsprechende ASCII-Code gespeichert. Wert (0 bis 255). )
(5) Häufig verwendete Zeichen-ASCII-Vergleichstabelle
| Charakter | ASCII-Code |
|---|---|
| A | 97 |
| A | 65 |
| 0 | 48 |
(6) Verwenden Sie einfache Anführungszeichen, um ein Zeichen in Anführungszeichen zu setzen.
(7) Codebeispiel
#include <stdio.h>
int main()
{
char ch1 = 'a';
char ch2 = 97; // ch2的数据范围为0~255
printf("ch1 = %c\n", ch1); // a
printf("ch2 = %c\n", ch2); // a 将数值97对应的ASCII码赋值给变量ch2
return 0;
}
(8) Speicher
char ch = 'a'; // 占一个字节，存储的是97
97对应的二进制为：0110 0001
a) Byte: Die Grundeinheit des Speichers, ein Byte besteht aus 8 Bit.
b) Beim Speichern kann der Computer nur Binärkombinationen von 1 und 0 speichern.
c) Zeichendaten werden nicht im Speicher selbst gespeichert, sondern im entsprechenden Zeichen . ASCII-Code
d) Integer-Variablen speichern die Binärdatei, die ihren Werten entspricht.
unsigned int a = 97; // 97对应的二进制为0110 0001
(9) Maschinenzahlen und wahre Werte
a) Die Maschinennummer ist die binäre Darstellung der Zahl im Computer. Sie ist vorzeichenbehaftet. Das höchste Bit ist das Vorzeichenbit. 0 ist eine positive Zahl und 1 ist eine negative Zahl.
b) Der wahre Wert von 0000 0001 ist +1; der wahre Wert von 1000 0000 ist -1 (das höchste Bit ist das Vorzeichenbit, und die Umwandlung des wahren Werts umfasst nicht das Vorzeichenbit).
(10) Originalcode, Umkehrcode, Komplementcode
a) Quellcode, Umkehrcode und Komplementcode sind verschiedene Codierungsmethoden für Maschinen zum Speichern von Zahlen. Die Maschine verwendet Komplementcode zum Speichern von Zahlen im Speicher.
b) Originalcode
Originalcode = Vorzeichenbit + wahrer Wert, das heißt, das erste Bit ist das Vorzeichenbit und der Rest sind wahre Werte
+1 = 0000 0001（原码）
-1 = 1000 0001（原码）
c) Einserkomplementcode. Das
Einserkomplement einer positiven Zahl ist der Originalcode selbst;
das Einserkomplement einer negativen Zahl bedeutet, dass das Vorzeichenbit unverändert bleibt und der wahre Wert des Originalcodes invertiert wird.
+1 = 0000 0001（原码）= 0000 0001（反码）
-1 = 1000 0001（原码）= 1111 1110（反码）
d) Komplementcode
Der Komplementcode einer positiven Zahl ist der Originalcode selbst;
der Komplementcode einer negativen Zahl ist ihr Komplement +1
+1 = 0000 0001（原码） = 0000 0001（反码） = 0000 0001（补码）
-1 = 1000 0001（原码） = 1111 1110（反码） = 1111 1111（补码）
(11) Warum verwenden wir beim Speichern im Computerspeicher Komplementcode?
a) Logik des menschlichen Gehirns
首先根据符号位判断数字的正负；
然后根据真值计算结果
b) Das Problem: Die Maschine verwendet zur Berechnung den Originalcode, was die Beurteilungslogik des Vorzeichenbits erfordert, was zu einer hohen Komplexität des Schaltungsdesigns führt.
c) Lösung: Beteiligen Sie auch das Vorzeichenbit an der Operation. Das heißt, die Subtraktion wird in eine Addition umgewandelt, wodurch der Beurteilungsprozess des Vorzeichenbits entfällt
d) Prozessanalyse
Dezimaloperationslogik:
1 - 1 = 1 + （-1） = 0
Die Operationslogik bei Verwendung des Originalcodes:
1 - 1 = 1 + （-1）
= 0000 0001（原码） + 1000 0001（原码）
= 1000 0010（原码）
= -2 // 很显然是错误的，因此机器内部不使用原码进行运算
Verwenden Sie inversen Code, um das Problem des Originalcode-Subtraktionsfehlers zu lösen. Operationslogik:
1 - 1 = 1 + （-1）
= 0000 0001（反码） + 1111 1110（反码）
= 1111 1111（反码）
= 1000 0000（原码）
= -0 // 虽然结果是对的，但对于机器来说，数字0的符号位没有任何意义，而且存在+0和-0两种编码方式
Verwenden Sie den Komplementcode, um das Problem der Berechnung von positiven und negativen 0 mit dem Komplementcode zu lösen. Die Operationslogik lautet:
1 - 1 = 1 + （-1）
= 0000 0001（补码） + 1111 1111（补码）
= 0000 0000（补码）
= 0000 0000（原码）
= 0
e) Der Ursprung des Datenbereichs 128
Beim Speichern im Computerspeicher werden Zahlen mithilfe von Komplementcodes codiert, wodurch das Problem der positiven und negativen Nullen im Komplementcode gelöst wird, dh die Codierung von 0 ist vorzeichenbehaftet und es gibt zwei Codierungsmethoden.
（-1） + （-127）= 1000 0001（原码）+ 1111 1111（原码）
= 1111 1111（补码） + 1000 0001（补码）
= 1000 0000（补码）
Daher wird 0 durch 0000 0000 dargestellt, und die vorherige -0, also 1000 0000, wird zur Darstellung von -128 verwendet. Daher verfügt -128 weder über den Komplementcode noch über den Originalcode.
Inzwischen gilt für eine achtstellige Binärzahl:
使用原码时，数据范围为[-127, 127] // +0和-0都用来表示0
使用补码时，数据范围为[-128, 127] // 左区间最小值可以多表示一位，因为+0表示0，-0表示-128
2. kurzer kurzer Ganzzahltyp
(1) Die mit short definierte Variable ist eine kurze Ganzzahlvariable
(2) Sie belegt 2 Bytes
(3) Sie ist standardmäßig signiert und der Wertebereich ist: -32768~32767.
(4) Codebeispiele
short int a = 5; // a的范围为-32768~32767
3. Int-Integer-Typ
(1) Mit int definierte Variablen sind ganzzahlige Variablen.
(2) Unter einer 32-Bit-Systemplattform, das heißt, der Compiler ist 32-Bit, belegt er 4 Bytes; unter einer 16-Bit-Plattform, das heißt, der Compiler ist 16 -Bit, es belegt 2 Bytes
(3), standardmäßig signiert, Datenbereich: -2 Milliarden ~ 2 Milliarden
(4) Codebeispiel
#include <stdio.h>
int main()
{
char a;
short int b;
int c;
printf("sizeof(char) = %d\n", sizeof (a)); // 1
printf("sizeof(short int) = %d\n", sizeof (b)); // 2
printf("sizeof(int) = %d\n", sizeof (c)); // 4
return 0;
}
4. Long-Long-Integer-Typ
(1) Eine mit long definierte Variable ist eine Long-Integer-Variable.
(2) Sie belegt 4 Bytes in einem 32-Bit-System.
(3) Codebeispiel
long a = 64;
5. Float einzelner Gleitkommatyp (reelle Zahl)
(1) Die mit float definierte Variable ist eine einzelne reelle Gleitkommazahl
(2) Belegt 4 Bytes
(3) Achten Sie darauf, nach dem Wert ein f hinzuzufügen, um den Wert zu ändern. Wenn nicht hinzugefügt, wird standardmäßig der Typ double verwendet
(4 ) Codebeispiel
float a = 3.1f;
6. Double-Double-Gleitkommatyp (reelle Zahl)
(1) Die mit double definierte Variable ist eine doppelte Gleitkomma-Realzahl
(2) Belegt 8 Bytes
(3) Codebeispiel
double a = 3.1;
7. Strukturstruktur
(1) Mit struct definierte Variablen sind Variablen vom Strukturtyp
8. Union (Union)
(1) Mit Union definierte Variablen sind Variablen vom Typ Union (Union).
9. Enumeration
(1) Mit enum definierte Variablen sind Variablen vom Typ Aufzählung
10. unterzeichnet (unterzeichnet)
(1) Verwenden Sie beim Definieren von Zeichendaten (char) und ganzzahligen Daten (kurz, int, lang) signiert, um sie zu ändern, um anzuzeigen, dass die definierten Daten signiert sind. (2) Die Daten sind signiert: Positive Zahlen können gespeichert werden, und
Negative Nummern können gespeichert werden
(3) Standard ist signiert
(4) Codebeispiel
signed int a = -5;
int b = -6; // 默认情况下，signed可以省略，默认就是有符号类型的数据
11. unsigniert (unsigniert)
(1) Beim Definieren von Daten vom Zeichentyp (char) und vom Ganzzahltyp (kurz, int, lang) zeigt die Schattenänderung ohne Vorzeichen an, dass es sich bei den definierten Daten um Daten vom Typ ohne Vorzeichen handelt. (2) Daten vom Typ ohne Vorzeichen: können nur gespeichert werden Positive Zahlen und
0
( 3) Codebeispiel
unsigned int a = 10;
12. void leerer Typ
(1) char, int und float können alle Variablen definieren
(2) void kann keine Variablen definieren und es gibt keine Variable vom Typ void
(3) void wird verwendet, um die Parameter oder den Rückgabewert einer Funktion zu ändern, was darauf hinweist, dass die Funktion hat keine Parameter oder Rückgabewert
(4) Codebeispiel
void fun(void)
{
// 函数体
}
2. Speichern Sie verwandte Schlüsselwörter
2.1 Registerregister
(1) Mit Register geänderte Variablen sind Registervariablen.
(2) Schlüsselwortbedeutung: Teilen Sie dem Compiler beim Kompilieren mit, dass die Variable eine Registervariable ist, und versuchen Sie , ihren Speicherplatz in einem Register zuzuweisen.
(3) Die definierten Variablen sind nicht unbedingt wahr wird im Register gespeichert
(4) Wenn die CPU Daten abruft, geht sie zum Register, um die Daten abzurufen, und nicht zum Speicher, um den Datenblock abzurufen
(5) Register sind wertvoller, daher können keine Registerarrays definiert werden
(6) Das Register kann nur Zeichentypen und Ganzzahlen ändern, nicht jedoch Gleitkommatypen
register char ch;
register short int a;
register int b;
(7) Da die durch Register geänderten Variablen möglicherweise im Register und nicht im Speicher gespeichert werden, kann die Adresse der Registervariablen nicht übernommen werden. (8) Nur
die im Speicher gespeicherten Daten haben eine Adresse.
register int a;
int *p;
p = &a; // 错误！！！ a可能存放在寄存器中，因此可能没有地址
2.2 statisch statisch
(1) Static kann globale Variablen, lokale Variablen und Funktionen ändern
2.3 Konstante Konstante
(1) const bedeutet Konstante
(2) Mit const geänderte Variablen sind schreibgeschützt und ihre Werte können nicht geändert werden
(3) const kann auch Zeiger ändern
(4) Codebeispiele
const int a = 10;
a = 100; // 错误！！！a被const修饰，不能在修改其值
2,4 Automatik
(1) auto int a; entspricht int a
(2) Das Schlüsselwort auto wird grundsätzlich nicht verwendet
2,5 extern
(1) Es bedeutet extern.
(2) Wird für Deklarationen von Funktionen und globalen Variablen verwendet.
(3) Wird im Allgemeinen in Header-Dateien verwendet
3. Schlüsselwörter im Zusammenhang mit Kontrollanweisungen
3.1 Wählen Sie Aussagen zur Urteilskontrolle aus
if、else、Wechseln Sie die Groß- und Kleinschreibung standardmäßig
3.2 Schleifenkontrollanweisungen
brechen, fortsetzen, für, während, tun
3.3 Jump-Anweisung
gehe zu
4. Andere Schlüsselwörter
4,1 Größe
(1) Wird verwendet, um die Größe des von Variablen und Arrays belegten Speicherplatzes in Bytes zu messen.
(2) Codebeispiel
int a = 10;
int size_a;
size_a = sizeof(a);
(3) Schlüsselwort sizeof und Funktion strlen()
#include<stdio.h>
#include<string.h>
void testSizeofStrlen()
{
char arr[] = "abc";
/*对于字符串来说，sizeof计算的字符串长度包括'\0'
* 因此sizeof计算出的字符串长度会多一个字节*/
printf("sizeof(arr) = %d\n", sizeof (arr)); // 4
/*strlen(const char* str)是一个函数，因此调用该函数需要引用头文件<string.h>
* 传入的参数是一个地址，而不是数值
* 该函数从字符串的开头位置往后计数，遇到'\0'停止，最终的字符串长度不包括'\0'*/
printf("strlen(arr) = %d\n", strlen(arr)); // 3
return;
}
int main()
{
testSizeofStrlen();
return 0;
}
4.2 Typedef-Umbenennung
(1) Wird verwendet, um einen vorhandenen Typ, also einen Alias, umzubenennen.
(2) Es wird kein neuer Typ erstellt.
(3) Format
typedef 已有类型名 新类型名;
(3) Codebeispiele
/*char类型，1个字节，在内存中存储的是ASCII码*/
typedef signed char s8; // %d
typedef unsigned char u8; // %d
/*short类型，2个字节，带h就表示是short类型*/
typedef signed short s16; // %d or %hd
typedef unsigned short u16; // %d or %hu
/*整型，4个字节，有符号就用%d，无符号就用%u*/
typedef signed int s32; // %d
typedef unsigned int u32; // %u
/*长长整型，8个字节，带ll就是long long类型，有符号用%lld，无符号用%llu*/
typedef signed long long s64; // %lld
typedef unsigned long long u64; // %llu
4.3 flüchtig leicht zu ändern
(1) Mit flüchtige Variablen definierte Variablen können leicht geändert werden,
d das Register. Backup
4.4 Benennung von Identifikatoren
(1) Benennungsregeln für Bezeichner: Besteht aus Buchstaben, Zahlen und Unterstrichen und kann nicht mit Zahlen beginnen.
(2) Benennungsstil
// Linux风格
stu_name; // 英文字母全部小写，以下划线连接
// 驼峰风格
TestStuName(); // 方法名用大驼峰
stuName; // 变量名用小驼峰
// 大小写敏感
int Stu;
int stu;