1.C语言初识

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	字符数据类型	1
short	短整型	2
int	整型	4
long	长整型	4\8
long long	整形	8
float	单精度浮点数	4
double	双精度浮点数	8
long 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默认为doublefloat 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 = 2020return 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）

1. 局部变量：局部范围。
2. 全局变量：整个工程。
3. 声明外部符号才能使用全局变量：extern int g_val;
   生命周期
   变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段
   //变量创建的本质：在内存中开辟一块空间，存放数据。
   //销毁：把空间还给操作系统。
4. 局部变量：进入作用域生命周期开始，出作用域生命周期结束。
5. 全局变量：整个程序的生命周期

常量

#define SIZE 10//#define定义的标识符常量 
#define MAX 1000
#define CH 'W'
const int n = 3;//长变量本质还是变量int arr[10];//数组中必须使用常量，不能使用[n]
int arr[SIZE]; //#define定义的标识符常量

1. 字面常量。int a = 3；
2. 常变量：具有常属性的变量。 const int n = 3;
3. # define 定义的标识符常量 # define SIZE 10
4. 枚举常量：一一列举（性别、颜色、血型）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停止//6return 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	垂直制表符
\ddd	ddd表示1~3个八进制的数字。 如： \130 表示字符X
\xdd	dd表示2个十六进制数字。 如： \x30 表示字符0

int main()
{printf("%c\n",'\130'); //\ddd ddd表示1~3个8进制的数字。 如： \130--> X的ASCII码为130//8进制转化为10进制，130-->88printf("%c\n",'\x31'); //\xdd dd表示2个十六进制数字。 如： \x31 1//16进制转化为10进制，31-->49return 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");elseprintf("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");elseprintf("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; 
}

操作符

操作符

算术操作符

/除法

1. 整数除法：7/2
2. 浮点数除法：7.0/2_除数被除数，至少一个是浮点数
   %取模
3. mod_得到的是余数
4. 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);//会输出1return 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 = 2a = 1;b = a++;//后置++，先使用再++printf("a=%d b=%d\n", a, b);//a = 2 b = 1return 0;
}

(类型)强制类型转换

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

关系操作符

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

逻辑操作符

&& ||	逻辑与 逻辑或

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

int main()
{int a = 0;int b = 5;if (a && b)//全真才真{printf("true\n");}elseprintf("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，假就执行bprintf("%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,9printf("%d\n", arr[5]);//下标5，输出为6，下标引用操作符[]，数组下标从0开始return 0;
}

函数调用操作符()

int z = ADD(a , b);//函数调用操作符
printf("sth");//这个也是

关键字

auto	break	case	char	const	continue	default	do	double else	enum
extern float	for	goto	if	int	long	register	return	short	signed
sizeof	static struct	switch	typedef union	unsigned	void	volatile	while

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是用来修饰变量和函数的

1. 修饰局部变量-称为静态局部变量
2. 修饰全局变量-称为静态全局变量
3. 修饰函数-称为静态函数
   static 修饰局部变量的时候
   本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了
   static 修饰局部变量改变了变量的存储类型(位置)，使得这个静态变量的生命周期变长了，直到程序结束才结束

void test()
{//static int a = 5;//6 7 8 9 10 11 12 13 14 15int a = 5;//6 6 6 6 6 6 6 6 6 6a++;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.cextern 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.cextern int ADD(int x,int y);//声明外部符号
int main()
{int a = 0; int b = 0;scanf("%d %d", &a, &b);int s = ADD(a, b);//无法解析的外部符号 _ADDprintf("%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=400int m = M;printf("%d\n", sizeof(arr));//400printf("%d\n", M);//100return 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是用来修饰变量和函数的

1. 修饰局部变量-称为静态局部变量
2. 修饰全局变量-称为静态全局变量
3. 修饰函数-称为静态函数
   static 修饰局部变量的时候
   本来一个局部变量是存放在栈区的，如果被static修饰就存储到静态区了
   static 修饰局部变量改变了变量的存储类型(位置)，使得这个静态变量的生命周期变长了，直到程序结束才结束

void test()
{//static int a = 5;//6 7 8 9 10 11 12 13 14 15int a = 5;//6 6 6 6 6 6 6 6 6 6a++;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.cextern 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.cextern int ADD(int x,int y);//声明外部符号
int main()
{int a = 0; int b = 0;scanf("%d %d", &a, &b);int s = ADD(a, b);//无法解析的外部符号 _ADDprintf("%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=400int m = M;printf("%d\n", sizeof(arr));//400printf("%d\n", M);//100return 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地址，num4字节，每个字节都有地址，取出的是第一个字节的地址printf("%p\n", &num);//%p是以地址的形式打印__0x004ffbe8return 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就是aprintf("%d\n", a);//a=30return 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;
}