Artikelverzeichnis
- 1. Datentyp
- Datenspeichermethode
- Konstanten und Variablen
- Array-String
- Zeiger
- Zeiger vorgerückt
- Sortierfunktion
- String-Funktionen
- Schlüsselwort (statische Definition)
- Struktur
- Zyklus
- Funktion
- Operator
- 1. Arithmetische Operatoren
- 2. Schichtoperator
- 3. Logische Operatoren
- dynamisches Gedächtnis
- Dateioperation
1. Datentyp
char //字符数据类型 'A'
short //短整型
int //整型
long //长整型
long long //更长的整型
float //单精度浮点数
double //双精度浮点数
double d = 3.14;
printf("%lf\n", d);
unsigned char i ;//0~255
char i//-128~0~127
1. Warum gibt es so viele Arten?
printf("%d\n",sizeof(char)); //1
printf("%d\n",sizeof(short)); //2
printf("%d\n",sizeof(int)); //4
printf("%d\n",sizeof(long)); //4/8
printf("%d\n",sizeof(long long));//8
printf("%d\n",sizeof(float)); //4
printf("%d\n",sizeof(double)); //8
注：同一类型的有符号数和无符号数所占字节数相同
short int age = 20; //2^16=65535
Das heißt, um verschiedene Werte im Leben umfassender zum Ausdruck zu bringen
Datenspeichermethode
Konstanten und Variablen
1. Geltungsbereich
Wenn eine lokale Variable und eine globale Variable identisch sind, hat die lokale Variable Vorrang.
//取地址符号&
scanf("%d%d",&num1,&num2);
//避免编译器提示语法不安全
#define _CRT_SECURE_NO_WARNINGS 1
Deklarieren Sie extren als externes Symbol
extern int g_val;
printf("g_val = %d\n", g_val);
2. Der Lebenszyklus von Variablen
- Der Lebenszyklus lokaler Variablen: Der Lebenszyklus des Betretens des Bereichs beginnt und der Lebenszyklus des Betretens des Bereichs endet.
- Lebenszyklus globaler Variablen: der Lebenszyklus des gesamten Programms
3. Konstanten
- wörtliche Konstante
- const modifizierte konstante Variable
- Durch #define definierte Bezeichnerkonstanten
- Aufzählungskonstante
const int num = 4;
num = 8 //不能进行更改
int n = 10;
int arr[n] = {
0};//应该放入常量表达式
enum Sex
{
MALE,
FEMALE,
SECRET
};
int main()
{
printf("%d\n",MALE); //0
printf("%d\n",FEMALE); //1
printf("%d\n",SECRET); //2
enum Sex sex = MALE;
sex = FEMALE; //可更改
FEMALE = 6; //不能更改
}
Array-String
int main()
{
char arr1[] = "abc";
//'a','b','c','\0'
//'\0'：字符串的结束标志
char arr2[] = {
'a','b','c'};
char arr3[] = {
'a','b','c','\0'};
printf("%s\n",arr1); //abc
printf("%s\n",arr2); //abc烫烫烫bc
printf("%s\n",arr3); //abc
printf("%d\n",strlen(arr1));//3
printf("%d\n",strlen(arr2));//随机值
printf("%d\n",strlen("c:\test\32\test.c"));//13
//32是两个8进制数字，转化为10进制后ASCII码值所对应的字符
char arr4[5] = {
'a',98};
printf("%d\n",sizeof(arr4));//2,所占字节大小
printf("%d\n",sizeof(arr1));//4
}
1. Zweidimensionales Array
int arr[][4] = {
{
1,2,3,4},{
5,6,7,8}};
//列下标不能省略
Der Parameter hat die Form eines Arrays.
Der Parameter hat die Form eines Zeigers
*((*p+i)+j) = (*(p+i)[ j ])
Zeiger
Speichern Sie die Adresse der Speichereinheit, die Speichereinheit ist in Bytes
*–> Dereferenzierungsoperator
Die Zeigergröße beträgt 4 Bytes auf einer 32-Bit-Plattform
double d = 3.14;
double* pd = &d;
//sizeof(pd) = sizeof(double*)
指针类型决定了指针解引用操作的时候，能够访问空间的大小
int *p;//能够访问4个字节
char *p;//能够访问1个字节
指针类型决定了指针的步长
int *p; //p+1->4
cahr *p; //p+1->1
double *p; //p+1->8
1. Array von Zeigern
2. Array-Zeiger
3. Zusammenfassung
Zeiger vorgerückt
1. Funktionszeiger
2. Array von Funktionszeigern
Kann die Switch-Anweisung ersetzen
3. Ein Zeiger auf ein Array von Funktionszeigern
Sortierfunktion
String-Funktionen
Schlüsselwort (statische Definition)
Statische Änderung lokaler Variablen: Verlängert den Lebenszyklus lokaler Variablen.
Statische Änderung globaler Variablen: Einschränkung des Bereichs globaler Variablen. Wenn eine andere Funktion extern deklariert, tritt ein Fehler auf.
Statische Änderung von Funktionen: Änderung des Link-Attributs der Funktion , wodurch die externen Linkattribute in interne Linkattribute umgewandelt werden
Makrodefinition
#define MAX(X,Y) (X>Y?X:Y)
int main()
{
max = MAX(a,b);//max = (a>b?a,b)
}
Struktur
//结构体变量.成员
//结构体指针->成员
struct Book
{
char name[20];
};
int main()
{
struct Book b1 = {
"CCC"};
struct Book* pb = &b1;
printf("%s\n",b1.name);
printf("%s\n",(*pb).name);
printf("%s\n",pb->name);
//更改成员数据
b1.name = "uuuu"//err
strcpy(b1.name,"uuuu");//string.h
}
Zyklus
int i = 1;
while(i<10)
{
if(i == 5)
continue;
printf("%d",i);
i++;
}
//陷入死循环，当i=5时，跳到while，然后到continue，还会回到while
//ctrl+z 可结束
while(ch = getchar()! = EOF)
{
putchar(ch);
}
char password[20] = {
0};
scanf("%s",password);
ret = getchar();
//当输入完后，按下回车键，‘\n’就会被ret接收
while(ch=getchar()!='\n')
{
;
}
//将缓冲区读取完
Die Schleifenkontrollvariable der for-Anweisung:
1. Ändern Sie nicht die Schleifenvariable im Hauptteil der for-Schleife, um zu verhindern, dass die for-Schleife die Kontrolle verliert.
2. Es wird empfohlen, den Wert der Schleifenkontrollvariablen der for-Anweisung zu ändern Übernehmen Sie die Schreibmethode „Öffnen Sie das Intervall nach dem Schließen vor“
int i=0,k=0;
for(i=0,k=0;k=0;i++)
k++;
//不进入循环，k=0为假
#include<windows.h>
Sleep(1000);
#include<stdlib.h>
system("cls");//清空屏幕
//时间戳
srand((unsigned int) time());
ret = rand()
Funktion
1. Funktionsaufruf
Nachdem der formale Parameter instanziiert wurde, entspricht er tatsächlich einer temporären Kopie des tatsächlichen Parameters.
Der Aufruf nach Adresse kann eine echte Verbindung zwischen der Funktion und den Variablen außerhalb der Funktion herstellen, dh das Innere der Funktion kann die Variablen außerhalb der Funktion direkt manipulieren
Die printf-Funktion gibt die Anzahl der Zeichen zurück
2. Rekursion
1. Es gibt Einschränkungen. Wenn diese Einschränkung erfüllt ist, wird die Rekursion nicht fortgesetzt
//计算字符串长度
//char arr[] = "bit";
//int len = my_strlen(arr);
int my_strlen(char *str)
{
if(*str!='\0')
return 1+my_strlen(str+1);
else
return 0;
}
3. Arrays als Funktionsparameter
//arr是数组，对数组arr进行传参，实际上传递过去的是数组arr的首元素的地址 &arr[0]
buble_sort(arr,sr);
4. Zeiger als Parameter
Operator
1. Arithmetische Operatoren
Neben dem %-Operator funktionieren mehrere andere Operatoren mit Ganzzahlen und Gleitkommazahlen.
2. Schichtoperator
1. Arithmetische Rechtsverschiebung: Verwerfen der rechten Seite, Auffüllen des ursprünglichen Vorzeichenbits auf der linken Seite.
2. Logische Rechtsverschiebung: Auffüllen der Null auf der linken Seite
3. Logische Operatoren
^异或运算，相同为0，不同为1
！逻辑反操作
EOF：文件结束标志
取反
int a = 0；//4个字节，32bit位
int b = ~a;//b是有符号数的整形
//存储的是补码，打印出的是原码，b=-1
dynamisches Gedächtnis
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
//像内存申请10个整形的空间
int* p = (int *)malloc(10*sizeof(int));
if(p==NULL)
{
//打印错误原因的一个方式
printf("%s",strerror(errno));
}
free(p)
p=NULL;
return 0;
}
flexibles Array
Dateioperation
