2. Grundlegende Datentypen und Variablen

1.Datentyp

Dieses Mal verstehen wir hauptsächlich die grundlegenden Datentypen und booleschen Typen

Hinweis: [ ] bedeutet, dass Sie
1,1 Zeichen
char
[signed] char
unsigned char weglassen und nicht schreiben können

1.2 Integer
short Ganzzahltyp
short [int]
[signed] short [int]
unsigned short [int]

整型
int
[signed] int
unsigned int

⻓整型
long [int]
[signed] long [int]
unsigned long [int]

Längere Ganzzahltypen (eingeführt in C99)
long long [int]
[signed] long long [int]
unsigned long long [int]

1.3 Gleitkommatyp
Float Gleitkommatyp mit einfacher Genauigkeit,
Double Gleitkommatyp mit doppelter Genauigkeit,
Long Double

1.4. Boolean-Typ (eingeführt seit C99)
1. Der Boolean-Typ wird durch _Bool dargestellt.
2. Die Verwendung des Boolean-Typs erfordert die Referenzierung der Header-Datei <stdbool.h>
. 3. Der Wert der Boolean-Typvariablen ist wahr oder falsch

//布尔类型
#include <stdio.h>
#include <stdbool.h>
int main() {
    
    
	_Bool flag = true;
	if (flag) {
    
    
		printf("i'm true");
	}
	else{
    
    
		printf("i'm false");
	}
	return 0;
}

2.signiert和unsigniert

Die C-Sprache verwendet vorzeichenbehaftete und vorzeichenlose Schlüsselwörter, um Zeichen- und Ganzzahltypen zu ändern.
Das Schlüsselwort „signed“ gibt an, dass ein Typ ein Vorzeichen hat und negative Werte enthält; das
Schlüsselwort „unsigned“ gibt an, dass der Typ kein Vorzeichen hat und nur Null und positive ganze Zahlen (nicht negativ) darstellen kann.

Daher muss bei der Einführung der oben genannten Datentypen der Datentyp, wenn er nur nicht negative Ganzzahlen darstellen soll, mit dem Schlüsselwort „unsigned“ geändert werden. Andernfalls kann er mit dem Schlüsselwort „signed“ geändert werden, aber die meisten Datentypbereiche selbst umfassen positive Werte ganze Zahlen. Negativ, also vorzeichenbehaftet, kann grundsätzlich weggelassen werden.

Beispiel:

//定义整型变量a
signed int a;
int a;//signed可以省略

//定义非负整型变量a
unsigned int a;

Welche Vorteile bietet es am Beispiel des Integer-Typs, eine int-Variable ohne Vorzeichen zu deklarieren?
Der Vorteil besteht darin, dass der maximale ganzzahlige Wert, der durch die gleiche Speicherlänge dargestellt werden kann, doppelt so groß ist.
Beispiel:
Der Wertebereich des 16-Bit-Short-Int-Werts mit Vorzeichen ist: -32768~32767, der Maximalwert ist 32767;
während der Wertebereich des Short-Int-Werts ohne Vorzeichen ist: 0~65535, der Maximalwert ist 65535

3. Wertebereich des Datentyps

Die Datei limits.h beschreibt den Wertebereich des Integer-Typs.
Die Datei float.h beschreibt den Wertebereich des Gleitkomma-Typs.

Speichergröße und Wertebereich von Ganzzahltypen

Speichergröße und Wertebereich von Gleitkommatypen

Konstanten SCHAR_MIN und SCHAR_MAX für die Grenzwerte des Wertebereichs vom Typ Integer : die minimalen und maximalen Werte von vorzeichenbehafteten Zeichen.
SHRT_MIN, SHRT_MAX: Die minimalen und maximalen Werte von Short.
INT_MIN, INT_MAX: Der minimale und maximale Wert von int.
LONG_MIN, LONG_MAX: Die minimalen und maximalen Werte von long.
LLONG_MIN, LLONG_MAX: Die minimalen und maximalen Werte von long long.
UCHAR_MAX: Der Maximalwert des vorzeichenlosen Zeichens.
USHRT_MAX: Der Maximalwert des vorzeichenlosen Kurzschlusses.
UINT_MAX: Der Maximalwert von unsigned int.
ULONG_MAX: Der Maximalwert von unsigned long.
ULLONG_MAX: Der Maximalwert von unsigned long long.

Code-Demo

#include <limits.h>
int main() {
    
    
//存储大小
	printf("char的存储大小：%d\n",sizeof(char));
	printf("short的存储大小：%d\n", sizeof(short));
	printf("int的存储大小：%d\n", sizeof(int));
	printf("long的存储大小：%d\n", sizeof(long));

	//short int和long int 就是 short和long 这定义类型可以省略int 
	printf("short int的存储大小：%d\n", sizeof(short int));
	printf("long int的存储大小：%d\n", sizeof(long int));

	printf("long long的存储大小：%d\n", sizeof(long long));
	printf("unsigned char的存储大小：%d\n",sizeof(unsigned char));
	printf("unsigned short的存储大小：%d\n",sizeof(unsigned short));
	printf("unsigned int的存储大小：%d\n",sizeof(unsigned int));
	printf("unsigned long的存储大小：%d\n",sizeof(unsigned long));
	printf("unsigned long long的存储大小：%d\n",sizeof(unsigned long long));

	printf("float的存储大小：%d\n", sizeof(float));
	printf("double的存储大小：%d\n", sizeof(double));
	printf("long double的存储大小：%d\n", sizeof(long double));//long double字节大小至少8字节，不同编译器得出的结果不同，但肯定大于等于double的8字节

	printf("--------------------------------------------\n");
	
//取值范围
	printf("char的取值范围：%d %d\n", SCHAR_MIN, SCHAR_MAX);
	printf("unsigned char的取值范围：%d\n", UCHAR_MAX);	

	printf("short的取值范围：%d %d\n", SHRT_MIN, SHRT_MAX);
	printf("unsigned short的取值范围：%d\n", USHRT_MAX);

	//%d 十进制有符号整数   
	printf("int的取值范围：%d %d\n", INT_MIN, INT_MAX);
	//%u （16位）十进制无符号整数(unsigned int的最大存储范围已经超出了%d所能表示的范围)
	printf("unsigned int的取值范围：%u\n", UINT_MAX);

	//%d=int  %ld=long  %lld=long long（long和long long的取值范围都已经超出了int的范围 所以对应的格式化占位符也要修改 否则会出错

	//%ld [32位]长整型数据类型
	printf("long的取值范围：%ld %ld\n", LONG_MIN, LONG_MAX);
	//%lu [32位]无符号长整型数据类型
	printf("unsigned long的取值范围：%lu\n", ULONG_MAX);

	//%lld 64位长整型数据类型
	printf("long long的取值范围：%lld %lld\n", LLONG_MIN, LLONG_MAX);
	//%llu 64位无符号长整型数据类型
	printf("unsigned long long的取值范围：%llu\n", ULLONG_MAX);

	return 0;
}

4.Variablen

Variablen sind Werte, die in der Sprache C geändert werden können. Beim Erstellen einer Variablen müssen Sie einen Datentyp für die Variable definieren.

Konstanten sind Werte, die sich in der C-Sprache nicht ändern. Beispielsweise ist der Wertebereich des oben erwähnten Ganzzahltyps
INT_MIN, und INT_MAX stellt den minimalen und maximalen Wertebereich des int-Typs dar. Diese beiden sind Konstanten.

Das Definieren von Variablen
ist sehr einfach: Datentyp + Variablenname (der Variablenname sollte nicht mit Schlüsselwörtern in Konflikt geraten).

char a;//字符变量
int b;//整型变量
float c;//浮点型变量

Initialisieren Sie eine Variable.
Geben Sie ihr beim Erstellen der Variablen einen Anfangswert.
Der Anfangswert muss dem Datentyp entsprechen.

int a = 1;
char b = '1'
float c = 1.1;

Variablen nicht initialisieren.
Ganzzahlige Variablen (int, short, long usw.): Der Standardwert ist 0.
Gleitkommavariablen (Float, Double usw.): Der Standardwert ist 0,0.
Zeichenvariable (char): Der Standardwert ist „\0“, also das Nullzeichen.

5. Globale Variablen und lokale Variablen

Globale Variablen: Variablen, die außerhalb von geschweiften Klammern definiert sind, sind globale Variablen. Globale Variablen
haben einen weiten Einflussbereich, beziehen sich auf das gesamte Projekt und können überall referenziert werden.

Lokale Variablen: In geschweiften Klammern definierte Variablen sind lokale Variablen.
Lokale Variablen können sich nur auf den lokalen Bereich auswirken und können im Allgemeinen in ihren eigenen geschweiften Klammern referenziert werden.

#include <stdbool.h>
//全局变量和局部变量
int global = 1;//全局变量
int main() {
    
    
	int local = 2;//局部变量
	if (true){
    
    
		int local_in = 3;//局部变量
		printf("局部变量：%d\n", local_in)//这里就可以调用local_in局部变量
	}

	printf("全局变量：%d\n", global);
	printf("局部变量：%d\n", local);
	//printf("局部变量：%d\n", local_in); //无法调用局部变量local_in，报错
}

Wenn die aufgerufene lokale Variable in geschweiften Klammern definiert ist, die interner ist als der Aufrufpunkt, kann die lokale Variable nicht aufgerufen werden. Nehmen wir als
Beispiel das obige int local_in = 3: Wenn local_in durch externes Drucken aufgerufen wird, ist die Definition von local_in der interner ist als er selbst, kann nicht gefunden werden. Daher schlägt der Aufruf fehl und es wird ein Fehler gemeldet.

Wenn die lokale Variable und die globale Variable denselben Variablennamen haben

#include <stdbool.h>
//全局变量和局部变量
int global = 1;//全局变量
int main() {
    
    
	int global = 2;//局部变量
	printf("全局变量：%d\n", global);
}

Debug-Ergebnis

Grund: Die interne lokale Variable überschreibt den Wert der globalen Variablen. (Das Überschreiben bezieht sich hier nicht auf das Ändern von int global = 1 der globalen Variablen, sondern auf das Überschreiben des globalen Werts im Druckschritt, und die ursprünglich definierten Werte bleiben unverändert.)

Wo lokale Variablen und globale Variablen im Speicher gespeichert werden (verstehen)
1. Lokale Variablen werden im Stapelbereich des Speichers gespeichert.
2. Globale Variablen werden im statischen Bereich des Speichers gespeichert

6. Arithmetische Operatoren (+, -, *, /, %)

**+ - * / % **Diese arithmetischen Operatoren sind alle binäre Operatoren.
Hinweis: Binärer Operator bedeutet, dass der Operator zwei Operanden hat, dh an jedem Ende des Operators befindet sich eine Zahl.

//算数运算符
int main() {
    
    
	//加 减 乘（+ - *）
	int a = 1, b = 2, c = 3;
	int add = a + b + c;
	int sub = c - b - a;
	int mul = a * b * c;
	printf("add=%d  sub=%d  mul=%d\n", add, sub, mul);

	return 0;
}

Addition, Subtraktion und Multiplikation sind sehr regelmäßig. Lassen Sie uns die Division separat besprechen! ! !

int main() {
    
    
	// 除（/）
	int a = 1, b = 2, c = 3;
	float bf = 2, cf = 3;

	int div_i = c / b;
	float div_f1 = c / b;
	float div_f2= cf / bf;

	printf("div_i=%d\n", div_i);//1
	printf("div_f1=%f\n", div_f1);//1.000000
	printf("div_f2=%f\n", div_f2);//1.500000

	return 0;
}

Es erscheinen drei verschiedene Ergebnisse, die nacheinander besprochen werden.
Tipp: Die Ganzzahldivision in der Sprache C ist eine Ganzzahldivision. Sie gibt nur den ganzzahligen Teil zurück und verwirft den Dezimalteil.

1. printf(“div_i=%d\n”, div_i);//1
Formel int div_i = c / b Der Typ der Ergebnisvariablen div_i ist int, und die Operanden c und b an beiden Enden des Operators sind beide vom Typ int
Der Prozess ist:
Teilen Sie zwei int-Variablen c und b, das Ergebnis ist 1, weisen Sie es der Variablen div_i zu
und da div_i ein int-Typ ist, also div_i = 1
, und verwenden Sie dann den Platzhalter %d zum Ausgeben und Drucken

2. printf(“div_f1=%f\n”, div_f1);//1.000000
Formel float div_f1 = c / b Der Typ der Ergebnisvariablen div_f1 ist float, und die Operanden c und b an beiden Enden des Operators sind beide vom Typ int
Der Prozess ist:
Teilen Sie zwei int-Variablen c und b, das Ergebnis ist 1, weisen Sie es der Variablen div_f1 zu,
da div_f1 ein Float-Typ ist, also div_f1 = 1,000000
, und verwenden Sie dann den Platzhalter % f zum Ausgeben und Drucken

3. printf(“div_f2=%f\n”, div_f2);//1.500000
Formel float div_f1 = cf / bf Der Typ der Ergebnisvariablen div_f2 ist Float, und die Operanden c und b an beiden Enden des Operators sind beide Float-Typen
Hinweis: Die Variablen hier sind Divisionen vom Typ Gleitkomma ( solange mindestens eine Gleitkommavariable an der Operation beteiligt ist, führt die Sprache C eine Gleitkommadivision durch. ) Wenn Gleitkommazahlen dividiert werden, ist die Division keine ganzzahlige Division.
Entsprechend dem Prozess:
Teilen Sie zwei Float-Variablen c und b, das Ergebnis ist 1,500000, weisen Sie es der Variablen div_f2 zu,
da div_f2 ein Float-Typ ist, also div_f2 = 1,500000
, und verwenden Sie dann den Platzhalter %f zum Ausgeben und Drucken

Der Operator % stellt die Modulo-Operation dar, die den Rest der Division zweier Ganzzahlen zurückgibt.
(Dieser Operator kann nur für Ganzzahlen verwendet werden, nicht für Gleitkommazahlen.)

//取模%
int main() {
    
    
	int b = 2, c = 3;
	int mod = c % b;
	printf("mod=%d", mod);//1
	return 0;
}

Für Modulo-negative Zahlen gilt die Regel, dass das Vorzeichen des Ergebnisses durch das Vorzeichen des ersten Operanden bestimmt wird.

int main() {
    
    
	printf("%d\n", 11 % -5); // 1
	printf("%d\n", -11 % -5); // -1
	printf("%d\n", -11 % 5); // -1
	return 0;
}

7. Zuweisungsoperator (=)

Beim Erstellen einer Variablen wird ein Anfangswert initialisiert. Nach dem Erstellen der Variablen wird das Zuweisen eines Werts als Zuweisung bezeichnet.

//赋值运算符
int main() {
    
    
	int a = 100;//初始化
	a = 101;//赋值
	return 0;
}

Dauereinsatz

//连续赋值
int main() {
    
    
	int a = 100;//初始化
	int b = 101;//初始化
	int c = 102;//初始化
	a = b = c + 98;//不推荐变量连接成一块，看着费劲
	
	//建议分开写，方便观察读写
	b = c + 98;
	a = b;
	printf("a=%d b=%d c=%d",a,b,c);//从右向左依次赋值的 200 200 102
	
	return 0;
}

Zugeordnete Werte von rechts nach links

zusammengesetzter Zuweisungsoperator

//复合赋值
int main() {
    
    
	int a = 100;
	int b = 100;
	a += 3;//等同于 a = a + 3
	b -= 3;//等同于 b = b - 3

	printf("a=%d\n", a);//103
	printf("b=%d\n", b);//97

	return 0;
}

Häufig verwendete zusammengesetzte Zuweisungsoperatoren

*=	/=	%=	/=	%=
>>=	<<=	&=	|=	^=

8. Unäre Operatoren (++, –, + (positiv), - (negativ))

Die Operatoren ++, - -, + (positiv) und - (negativ) haben alle nur einen Operanden, es handelt sich also um unäre Operatoren.

+ (Positiv) - (Negativ)
Ich werde nicht zu viel über die positiven und negativen Vorzeichen sagen. Sie sind in der Mathematik positiv und negativ. Das positive
Vorzeichen (+) kann grundsätzlich weggelassen werden. Sie können es schreiben oder nicht.
Das Negative Das Zeichen (-) dient dazu, die Zahl negativ zu machen. Es ist auch eine sehr einfache Wahrheit, aber ich werde sie nicht zu sehr im Detail vorstellen.

++ und - -
++ erhöhen sich selbst, - - verringern sich selbst. Die Funktion von ++ besteht darin, die Variable +1 zu machen, und die Funktion von - - besteht darin, die Variable -1 zu machen.
++ und - - können platziert werden vor oder nach dem Operanden. Nachpositionierung und Nachpositionierung führen dazu, dass die Reihenfolge von +1 unterschiedlich ist.

Beispiel

int main() {
    
    
	int a = 1;
	int b = a++;
	printf("b=%d\n", b);//b=1
	printf("a=%d", a);//a=2
	return 0;
}

Das obige Beispiel ist eine automatische Inkrementierung, gefolgt von
int b = a++. Weisen Sie zuerst b a=1 zu, also b=1,
und erhöhen Sie dann a++ automatisch (entspricht a = a+1), also a=2

int main() {
    
    
	int a = 1;
	int b = ++a;
	printf("b=%d\n", b);//b=2
	printf("a=%d", a);//a=2
	return 0;
}

Das obige Beispiel ist ein Auto-Inkrement-Präfix
int b = ++a. Zuerst wird a++ automatisch inkrementiert (entspricht a = a+1), also a=2,
und dann a=2 zu b zugewiesen, also b=2

Auf die gleiche Weise können das Präfix und das Postfix der Selbstdekrementierung erhalten werden, daher werde ich kein Beispiel geben ^ _ ^

9. Erzwungene Typkonvertierung

int main() {
    
    
	int a = 3.14;
	printf("a=%d", a);
	return 0;
}

Es erscheint eine Warnung und einige Compiler melden direkt einen Fehler. Die Konvertierung von Gleitkommazahlen in Ganzzahlen führt zu Einbußen bei der Genauigkeit und zum Verlust des Dezimalteils der Daten.

Um die Warnung zu beseitigen, müssen Sie die erzwungene Typkonvertierung verwenden und (type) vor dem Wert oder Typ hinzufügen, der konvertiert werden muss.

//强制类型转换
int main() {
    
    
	int a = (int)3.14;//浮点数前加上  (强制转换的类型)
	printf("a=%d", a);
	return 0;
}

Es läuft erfolgreich ohne Fehler oder Warnung, verliert aber dennoch an Genauigkeit.