1.C语言初识

C语言初识 C语言初识基础知识hello world数据类型变量、常量变量命名变量分类变量的使用变量的作用域 常量字符字符串转义字符 选择语句循环语句 函数；数组函数数组数组下标 操作符操作符算术操作符移位操作符、位操作符赋值操作符单目操作符关系操作符逻辑操作符条件操作符__三目操作符 exp__表达式逗号表达式下标引用、函数调用和结构成员 关键字typedef__类型重命名static__register #define 定义常量和宏结构体 struct static; define; structstatic__register\#define 定义常量和宏结构体 struct 指针内存取变量地址指针变量 int* p;存放指针的变量 指针变量大小

C语言初识 基础知识

C面向过程，C++，Java面向对象。 text.h头文件 test.c test.cpp编译器会按C++编译 编辑、（编译、连接、运行 ctrl+F5）、调试 F5 F10 掌握了一定的语法，有时间就刷题，伴随整个学习过程。

Byte=8bit, 1024Byte=KB_MB_GB_TB_PB

hello world #include <stdio.h> int main() { printf("hello world\n"); returen 0;//返回整数 }

代码从main函数开始写。main函数是程序的开始，从main函数第一行执行，只能存在一个。 printf：是一个库函数，在屏幕上打印数据，使用前需要包含头文件#include <stdio.h> “”：是字符串 /n：是换行符 returen 0：返回整数

数据类型 数据类型意义字节char字符数据类型1short短整型2int整型4long长整型4\8long long整形8float单精度浮点数4double双精度浮点数8long double扩展精度浮点数8 #include <stdio.h> int main() { printf("%d\n", sizeof(char)); printf("%d\n", sizeof(short)); printf("%d\n", sizeof(int)); printf("%d\n", sizeof(long)); printf("%d\n", sizeof(long long)); printf("%d\n", sizeof(float)); printf("%d\n", sizeof(double)); printf("%d\n", sizeof(long double)); return 0; }

%d：以10进制的形式打印一个整数 sizeof：操作符，计算类型/变量所占内存大小

变量、常量

生活中的有些值是不变的（比如：圆周率，性别，身份证号码，血型等等） 有些值是可变的（比如：年龄，体重，薪资）。

变量命名

只能由字母（包括大写和小写）、数字和下划线（ _ ）组成。 不能以数字开头。 长度不能超过63个字符。 变量名中区分大小写的。 变量名不能使用关键字。

#include <stdio.h> int main() { int age=20; //类型 变量名 = 初始值 double weight = 55.5; //55.5默认为double float weight2 = 55.5f; //55.5f为float //变量名不能以数字开头 return 0; } 变量分类 #include <stdio.h> int global = 2019;//全局变量 int main() { int local = 2018;//局部变量 int global = 2020;//局部变量 printf("global = %d\n", global);//打印结果为global = 2020 return 0; }

局部变量 放在框外的变量 全局变量 放在框内 全局和局部冲突时，局部优先

变量的使用 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> int main() { int num1 = 0; int num2 = 0; int sum = 0; printf("输入两个操作数:>"); scanf("%d %d", &num1, &num2); //scanf(格式%d整型，&取地址操作符，取出num1的地址) sum = num1 + num2; printf("sum = %d\n", sum); return 0; }

使用scanf报错： 错误 C4996 ‘scanf’: This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. （微软编译器认为scanf函数不安全，建议使用scanf_s。但_s只有VS认识） （1.建议使用scanf， 在第一行加：#define _CRT_SECURE_NO_WARNINGS 1） （2.在newc++.file中加上#define _CRT_SECURE_NO_WARNINGS 1，默认添加）

#define _CRT_SECURE_NO_WARNINGS 1 //scanf：输入数据，从键盘读取到内存 //printf：输出数据，从内存输出到屏幕 //库函数-C语言编译器提供的函数，使用时需要包含头文件 #include <stdio.h> int main() { //int a = 0; //scanf("%d",&a); %d输入格式，&a取地址a，即数据存储地址 //printf("%d",a); char ch = 0; scanf("%c",&ch); printf("%c",ch); return 0; }

%c-字符 %d-整形 %s-字符串 %f-float %lf-double %p-地址的打印

变量的作用域 int g_val = 2024;//add.c 全局变量 extern int g_val;//需要声明外部符号才能使用全局变量 printf("%d",g_val);

作用域（scope）

局部变量：局部范围。全局变量：整个工程。声明外部符号才能使用全局变量：extern int g_val; 生命周期 变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段 //变量创建的本质：在内存中开辟一块空间，存放数据。 //销毁：把空间还给操作系统。局部变量：进入作用域生命周期开始，出作用域生命周期结束。全局变量：整个程序的生命周期 常量 #define SIZE 10//#define定义的标识符常量 #define MAX 1000 #define CH 'W' const int n = 3;//长变量本质还是变量 int arr[10];//数组中必须使用常量，不能使用[n] int arr[SIZE]; //#define定义的标识符常量 字面常量。int a = 3；常变量：具有常属性的变量。 const int n = 3;# define 定义的标识符常量 # define SIZE 10枚举常量：一一列举（性别、颜色、血型）enum SEX enum SEX {//列出枚举类型enum SEX可能的值,默认从0开始。 MALE=4, FEMALE, SECRET }; int main() { printf("%d\n",MALE); printf("%d\n", FEMALE); printf("%d\n", SECRET); return 0; } 字符 字符串 #include <string.h>//warning C4013: “strlen”未定义； int main() { char ch1[6] = { 'a','b','c','d','e','f' }; char ch2[] = "abcdef";//字符串的结束标志是一个 \0的转义字符 printf("%s\n", ch1); printf("%s\n", ch2); int len1 = strlen(ch1);//strlen:计算字符长度，\0不统计 int len2 = strlen(ch2); printf("%d\n",len1); printf("%d\n", len2); //abcdef烫烫烫MF袆,since打印到\0停止 //abcdef //19,since计算到\0停止 //6 return 0; }

字符串：由双引号（Double Quote）引起来的一串字符称为字符串字面值（String Literal）。字符串的结束标志是一个 \0的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串内容。

调试：逐语句(S)-F11__逐过程(0)-F10__跳出(T)-Shift+F11

转义字符 int main() { printf("(are you ok??)\n");//??)-->]，三字母词会被转为] printf("(are you ok\?\?)\n");//\? 在书写连续多个问号时使用，防止他们被解析成三字母词 return 0; } int main() { printf("c:\test\test.c\n"); printf("c:\\test\\test.c\n"); //c: est est.c,since \t 会被解析为制表符tab //c:\test\test.c //\\ 用于表示一个反斜杠，防止它被解释为一个转义序列符 return 0; } 转义字符释义\?在书写连续多个问号时使用，防止他们被解析成三字母词\’用于表示字符常量’\“用于表示一个字符串内部的双引号\\用于表示一个反斜杠，防止它被解释为一个转义序列符。\a警告字符，蜂鸣\b退格符\f进纸符\n换行\r回车\t水平制表符\v垂直制表符\dddddd表示1~3个八进制的数字。 如： \130 表示字符X\xdddd表示2个十六进制数字。 如： \x30 表示字符0 int main() { printf("%c\n",'\130'); //\ddd ddd表示1~3个8进制的数字。 如： \130--> X的ASCII码为130 //8进制转化为10进制，130-->88 printf("%c\n",'\x31'); //\xdd dd表示2个十六进制数字。 如： \x31 1 //16进制转化为10进制，31-->49 return 0; } 选择语句 //选择语句 int main() { printf("start study.\n"); printf("do you willing study?(1 or 0)\n"); int flag = 0; scanf("%d",&flag); if (flag == 1) printf("good!\n"); else printf("bad!\n"); return 0; }

if()后无；else无；赋值使用 ==

循环语句 int main() { int line = 0; while (line < 50) { printf("write code:%d\n",line); line++; } if (line == 50) printf("get good jio!\n"); else printf("continue!!!\n"); return 0; } 函数；数组 #include <stdio.h> int main() { return 0; } 函数 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> int ADD(int x, int y)//形参 { int z = x + y; return z; } int main() { int a = 0; int b = 0;//实参 scanf("%d %d", &a, &b); int sum = ADD(a, b); printf("%d\n",sum); return 0; } 数组 int main() { int arr[10];//整形数组 char ch[8];//字符型数组 } 数组下标 int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int i = 0; while (i < 10) { printf("%d\n", arr[i]);//数组下标从0开始arr[0] i++; } return 0; } 操作符 操作符 算术操作符

/除法

整数除法：7/2浮点数除法：7.0/2_除数被除数，至少一个是浮点数 %取模mod_得到的是余数7%2_只适用于整形运算 7.0默认为double 7.0f 认为是float 移位操作符、位操作符

>>右移 <<左移 &与 ^异或 |或

赋值操作符

= 赋值 符合赋值：a+=5–>a=a+5 +=自增 -= *= /= &= ^= |= >>= <<=

单目操作符

2+3 双目：有两个操作数

! - + & sizeof ~ – ++*(类型)逻辑反操作 负值 正值 取地址 操作数的类型长度（以字节为单位） 对一个数的二进制按位取反 前置、后置-- 前置、后置++间接访问操作符(解引用操作符)强制类型转换

单目：只有一个操作数 ！：真假变换（0假，非0真）

int main() { int a = 0;//0为假，非0为真 if (a)//a为真，进入if { printf("ture\n"); } if (!a)//a为假，进入if { printf("false\n"); } printf("%d\n",!a);//会输出1 return 0; }

sizeof__操作数的类型长度（以字节为单位）是个操作符不是函数

int main() { int a = 0; printf("%d", sizeof(a)); printf("%d", sizeof a );//a的括号可以去掉，说明sizeoif不是函数 printf("%d", sizeof(int));//但是int的不可以去掉4字节 printf("%d", sizeof(double));//8字节 return 0; }

++自增

int main() { int a = 1; int b = ++a;//前置++，先++再使用 printf("a=%d b=%d\n", a, b); //a = 2 b = 2 a = 1; b = a++;//后置++，先使用再++ printf("a=%d b=%d\n", a, b); //a = 2 b = 1 return 0; }

(类型)强制类型转换

int main() { int a = (int)3.14;//将3.14强制转换为整形 printf("%d\n", a);//输出为3 return 0; } 关系操作符

> >= < <= != 用于测试“不相等” == 用于测试“相等”

逻辑操作符 && ||逻辑与 逻辑或

&&逻辑与全真为真 ||逻辑或一真则真

int main() { int a = 0; int b = 5; if (a && b)//全真才真 { printf("true\n"); } else printf("false\n"); return 0; } 条件操作符__三目操作符 exp__表达式

exp1? exp2 : exp3 真 执行 不执行 假 不执行 执行

int main() { int a = 0; int b = 0; int m = 0; scanf("%d %d", &a, &b); m = (a > b ? a : b);//a大于b？真就输出执行a，假就执行b printf("%d\n", m); return 0; } 逗号表达式

exp1, exp2, exp3, …expN 从左向右依次计算 整个表达式的结果是最后一个表达式的结果

下标引用、函数调用和结构成员

[] () . -> 下标引用操作符[]

int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; // 0,1,2,3,4,5,6,7,8,9 printf("%d\n", arr[5]);//下标5，输出为6，下标引用操作符[]，数组下标从0开始 return 0; }

函数调用操作符()

int z = ADD(a , b);//函数调用操作符 printf("sth");//这个也是 关键字 autobreakcasecharconstcontinuedefaultdodouble elseenumextern floatforgotoifintlongregisterreturnshortsignedsizeofstatic structswitchtypedef unionunsignedvoidvolatilewhile

auto：自动__局部变量自动创建自动销毁，但是每个局部变量都有该性质，所以省略了auto int a; break：循环__终止 case：switch case char：数据类型__字符类型 const：修饰类型，常属性 continue：循环__继续 default：默认 do：循环__do while enum：枚举类型 extern：声明外部符号的，修饰变量 goto：分支语句 register：寄存器 return：函数的返回 signed：修饰类型__有符号的 static：静止 struct：结构体 typedef：类型重命名 union：联合体类型 void：函数返回值，函数的参数，修饰指针，空的 volatile：少见 while：循环

typedef__类型重命名 typedef unsigned int u_int; typedef unsigned long long ull; int main() { u_int num1 = 0; ull num2 = 2; return 0; } static__

在C语言中： static是用来修饰变量和函数的

修饰局部变量-称为静态局部变量修饰全局变量-称为静态全局变量修饰函数-称为静态函数 static 修饰局部变量的时候 本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了 static 修饰局部变量改变了变量的存储类型(位置)，使得这个静态变量的生命周期变长了，直到程序结束才结束 void test() { //static int a = 5;//6 7 8 9 10 11 12 13 14 15 int a = 5;//6 6 6 6 6 6 6 6 6 6 a++; printf("%d ", a); } int main() { int i = 0; while (i < 10) { test(); i++; } return 0; }

static修饰全局变量 全局变量具有外部链接属性，所以在其他源文件内部可以使用 static修饰全局变量，改变了全局变量的连接属性 又外部链接属性变成了内部连接属性，无法调用 无法解析的外部符号 _g_val 感觉作用域变小了，但是都在静态区

static int g_val = 2024;//add.c extern int g_val;//声明外部符号 int main() { printf("%d\n", g_val); return 0; }

static修饰函数和修饰全局变量一样 函数具有外部链接属性，被static修饰变成内部链接属性 使得该函数只能在自己源文件内部使用

static int ADD(int x, int y) { return(x + y); }//add.c extern int ADD(int x,int y);//声明外部符号 int main() { int a = 0; int b = 0; scanf("%d %d", &a, &b); int s = ADD(a, b);//无法解析的外部符号 _ADD printf("%d\n", s); return 0; } register int main() { //register仅仅是建议作用 //建议放在寄存器中，但不是真的放，取决于编译器 register int num = 10; return 0; } #define 定义常量和宏

定义常量

#define M 100 int main() { int arr[M] = { 0 };//int为4字节，4*100=400 int m = M; printf("%d\n", sizeof(arr));//400 printf("%d\n", M);//100 return 0; }

定义宏

#define ADD(x,y)(x+y)//宏定义：名字（参数）（实现体） int main() { int a = 10; int b = 20; int c = ADD(a, b); printf("%d\n", c); return 0; } 结构体 struct

char short int long long long float double 复杂类型：学生：名字char，年龄int，性别char

struct Stu//结构体 { char name[20];//一个汉字2个字符 int age; char sex[5];//需要5个字符 }; int main() { struct Stu s = {"ruarua",20,"man"}; printf("%s %d %s\n",s.name,s.age,s.sex);//结构体访问成员操作符s.成员 return 0; } static; define; struct static__

在C语言中： static是用来修饰变量和函数的

修饰局部变量-称为静态局部变量修饰全局变量-称为静态全局变量修饰函数-称为静态函数 static 修饰局部变量的时候 本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了 static 修饰局部变量改变了变量的存储类型(位置)，使得这个静态变量的生命周期变长了，直到程序结束才结束 void test() { //static int a = 5;//6 7 8 9 10 11 12 13 14 15 int a = 5;//6 6 6 6 6 6 6 6 6 6 a++; printf("%d ", a); } int main() { int i = 0; while (i < 10) { test(); i++; } return 0; }

static修饰全局变量 全局变量具有外部链接属性，所以在其他源文件内部可以使用 static修饰全局变量，改变了全局变量的连接属性 又外部链接属性变成了内部连接属性，无法调用 无法解析的外部符号 _g_val 感觉作用域变小了，但是都在静态区

static int g_val = 2024;//add.c extern int g_val;//声明外部符号 int main() { printf("%d\n", g_val); return 0; }

static修饰函数和修饰全局变量一样 函数具有外部链接属性，被static修饰变成内部链接属性 使得该函数只能在自己源文件内部使用

static int ADD(int x, int y) { return(x + y); }//add.c extern int ADD(int x,int y);//声明外部符号 int main() { int a = 0; int b = 0; scanf("%d %d", &a, &b); int s = ADD(a, b);//无法解析的外部符号 _ADD printf("%d\n", s); return 0; } register int main() { //register仅仅是建议作用 //建议放在寄存器中，但不是真的放，取决于编译器 register int num = 10; return 0; } #define 定义常量和宏

定义常量

#define M 100 int main() { int arr[M] = { 0 };//int为4字节，4*100=400 int m = M; printf("%d\n", sizeof(arr));//400 printf("%d\n", M);//100 return 0; }

定义宏

#define ADD(x,y)(x+y)//宏定义：名字（参数）（实现体） int main() { int a = 10; int b = 20; int c = ADD(a, b); printf("%d\n", c); return 0; } 结构体 struct

char short int long long long float double 复杂类型：学生：名字char，年龄int，性别char

struct Stu//结构体 { char name[20];//一个汉字2个字符 int age; char sex[5];//需要5个字符 }; int main() { struct Stu s = {"ruarua",20,"man"}; printf("%s %d %s\n",s.name,s.age,s.sex);//结构体访问成员操作符s.成员 return 0; } 指针 内存

指针是用来访问内存的，就是内存单元的地址。 每个内存单元的大小是1个字节Byte 。 32位的计算机有32根地址线，电信号，可以管理2^32个字节的空间=4GB内存 ![[Pasted image 20250101231015.png]] 变量是创建内存中的（在内存中分配空间的），每个内存单元都有地址，所以变量也是有地址的。

取变量地址

0x开头是16进制

int main() { int num = 10;//申请4字节空间 &num;//取num地址，num4字节，每个字节都有地址，取出的是第一个字节的地址 printf("%p\n", &num);//%p是以地址的形式打印__0x004ffbe8 return 0; }//一个整数4字节，32bit，16进制，4个二进制位转化一个16进制位

![[Pasted image 20250101232539.png]]

指针变量 int* p;存放指针的变量

*：p是指针变量 int：p指向的是int类型的变量

int main() { int a = 10; int* p;//p为一个整形指针变量 *p = 30;//*p,解引用p，*p就是a printf("%d\n", a);//a=30 return 0; } 指针变量大小

32位机器：地址是32个地址位，4字节；

64位机器：地址64位，8字节。

int main() { int a = 10; int* p = &a; printf("%zd\n", sizeof(p));//x86是4字节，x64是8字节 printf("%zd\n", sizeof(int*));//x86是4字节，x64是8字节 return 0; }