码智
码智

C语言基础学习

一、C语言入门

1、软件安装

这里使用的是Visual C++2010

下载安装即可，建议不勾选任何东西，轻量运行

2、编写hello world

// 区分大小写，注意
// 我的第一个C程序
#include   // 引入头文件，预编译

void main() {

	// 使用函数要引入头文件
	// printf是在，需要引入该头文件
	printf("hello world");
	getchar();	// 让窗口停留
    // 每条语句都要以分号(;)结尾
}

3、运行过程

  1. 编码：首先编写文件代码，也就是hello.c源文件
  2. 编译：将hello.c文件翻译成目标文件（hello.obj），由cl.exe完成这个操作
  3. 链接：将目标文件(hello.obj)和库文件（系统提供的）进行链接生成可执行文件（hello.exe），由link.exe完成
  4. 运行：执行.exe文件，我们写好的程序就运行起来了

注意：①cl.exe和link.exe是在我们软件安装目录下的VS/bin目录下的

​ ②我们的库文件它是由C程序提供的

​ ③修改过的程序要重新编译内容才会发生改变

​ ④编译到连接的过程中只要发生错误都会生成失败

文件存放的位置：

  • E:\Work\VS2010\MyProject01\Debug下有一个MyProject01.exe文件
  • E:\Work\VS2010\MyProject01\MyProject01下有一个hello.c文件，这个就是我们的源文件
  • E:\Work\VS2010\MyProject01\MyProject01\Debug下有一个hello.obj是我们编译过的文件

4、换行符的使用

  • /t 制表符
  • /n 换行符
  • \\ 一个\
  • \" 一个"
  • \’ 一个’
  • \r 回车,将当前位置移到本行开头

代码实现

#include   // 引入头文件，预编译

void main() {

	// 使用函数要引入头文件
	// printf是在，需要引入该头文件
	// printf("hello world");

	// 转义字符的运用
	printf("小智\r很帅\n");
	printf("姓名\t年龄\t籍贯\t住址\njohn\t12\t河北\t北京");

	getchar();	// 让窗口停留
}

5、注释

c语言有两种注释方式：

  1. 单行注释 //
  2. 多行注释 /**/

6、标准库的基本使用

#include   // 引入头文件，预编译
#include 
#include 

void main() {

	// 求2的三次幂
	double res = pow(2.0,3.0);
	printf("res=%2f",res);
	system("peuse");		// 函数表示暂停
}

二、变量

变量时程序的基本组成单位，它想相当于是内存中一个数据存储空间的表示

1、快速入门

#include 

void main() {
	int a = 1;
	double b = 1.1;
	char c = 'A';
	char name[] = "小智哥";	
	// 说明：%开头的为占位符
	// 输出整数%d
	// 输出浮点数%f
	// 输出字符%c
	// 输出字符串%s
	// 一定要一一对应，不然程序无法执行
	printf("num=%d source=%f.2f gender=%c name=%s", a, b, c, name);
	getchar();
}

C语言基础学习_第1张图片

2.1 概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个门牌号，通过门牌号找到我们的房间，而通过变量名可以访问到变量（值）

变量可以在声明的时候赋值，也可以先声明，后赋值，和java的一致

2、变量的数据类型

C语言基础学习_第2张图片

注意：①在C语言中没有字符串类型，使用字符数组表示字符串

​ ②在不同系统上，部分数据类型字节长度不一样，int2个字节或者4个字节

2.1 整型类型

C语言的整数类型就是用于存放整数值的，比如12 , 30, 3456等等

C语言基础学习_第3张图片

整数使用的细节

  1. 各种类型的存储大小与操作系统、系统位数和编译器有关，目前通用的以64位的为主

    C语言基础学习_第4张图片

  2. 在实际工作中，c程序通常运行在linux/unix操作系统下.二级考试，使用windows

  3. C 语言的整型类型，分为有符号signed 和无符号unsigned 两种，默认是signed

  4. C 程序中整型常声明为int型，除非不足以表示大数，才使用long或者long long

    #include 

void main() {

	long num1 = 12147483647;		// -737418241
	long long num2 = 12147483647;	// 12147483647

	// 如果输出的是long，则格式%ld 
	// 如果输出的是long long，则格式%lld
	printf("%lld", num2);
    // sizeof()方法可以获取数据类型的长度
    printf("\nlength=%d", sizeof(int));	// 4
	getchar();
}

  5. bit(位): 计算机中的最小存储单位。byte(字节):计 算机中基本存储单元。

    1byte = 8bit [二进制再详细说，简单举例一个short3 和int 3 ]

    示意图:

    short 3 在内存中占有2字节

    int3 在内存中占有 4个字节

    C语言基础学习_第5张图片

2.2 浮点类型

C语言的浮点类型可以表示一一个小数，比如123.4，7.8，0.12等等

C语言基础学习_第6张图片

注意：①关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位，浮点数是近视值

​ ②尾数部分可能丢失，造成精度损失。

浮点型使用细节

  1. 浮点型常量默认为double型，声明float 型常量时，须后加‘f’ 或‘F’。

  2. 浮点型常量有两种表示形式

    十进制数形式:如: 5.12 512.0f .512 (必须有小数点)

    科学计数法形式:如: 5.12e2 、5. 12E-2

  3. 通常情况下，应该使用double型，因为它比float型更精确。

  4. printf(“d1=%f”, d1);//在输出时，默认保留小数点6位

代码实现

#include 

void main() 
{
	float d1 = 1.18923432;
	float d2 = 1.1f;
	double d3 = 1.3;

	double d4 = 5.12;
	double d5 = .512;		// 等价于0.512

	double d6 = 5.12e2;		// 等价于 5.12 * (10^2)=512
	double d7 = 5.12e-2;	// 等价于 5.12 * (10^-2)=5.12/100=0.0512

	// 在输出时，如果%f默认保留小数点后6位
	printf("d1=%.15f d2=%f d3=%f d4=%f d5=%f d6=%f d7=%f", d1, d2, d3, d4, d5, d6, d7);
	getchar();
}

image-20210813211611707

2.3 字符类型

字符类型可以表示单个字符，字符类型是char，char 是1个字节(可以存字母或者数字)，多个字符称为字符串，在C语言中使用char数组表示，数组不是基本数据类型，而是构造类型[关于数组我们后面详细讲解.]

字符类型使用细节

  1. 字符常量是用单引号(")括起来的单个字符。例如: charcl = ‘a’; charc3= ‘9’;
  1. C中还允许使用转义字符‘\’ 来将其后的字符转变为特殊字符型常量。例如: charc3= ‘\n’ ; // "\n’表示换行符
  2. 在C中，char的本质是- 一个整数，在输出时，是ASCII码对应的字符。
  3. 可以直接给char赋一个整数，然后输出时，会按照对应的ASCII字符输出[97]
  4. char类型是可以进行运算的，相当于-一个整数，因为它都对应有Unicode码.

代码演示

#include 

void main()
{
	char c1 = 'a';
	char c2 = 97;
	// 这里会自动转换成int类型
	int sum = c1 + 10;	// 97 + 10 = 107

	// 如果是%c输出char类型的值的话就是本身
	// 如果是%d输出的话就会对照ASCLL编码表找到对应的数值输出
	printf("c1=%c c2=%c sum = %d", c1, c2, sum);
	getchar();

}

结果显示

image-20210813212637962

2.4 布尔类型

1)C语言标准(C89)没有定义布尔类型，所以C语言判断真假时以0为假，非0为真[案例]

2)但这种做法不直观，所以我们可以借助C语言的宏定义。

  1. C语言标准(C99)提供了_ Bool 型，Bool仍是整数类型，但与- -般整型不同的是， Bool变量只能赋值为0或1,非0的值都会被存储为1，C99 还提供了一个头文件 定义了bool 代表_ Bool， true 代表1，false 代表0。只要导入stdbool.h ，就能方便的操作布尔类型了，比如bool flag = false;[了解]

    ➢条件控制语句; if

    ➢循环控制语句; while …

代码演示

#include 

// 宏定义
#define BOOL int
#define TURE 1
#define FALSE 0

void main() {
	int isPass = -1;
	// 可以使用宏定义来完成
	// 定义一个布尔变量
	BOOL isOk = TURE;	// 等价于int isOK = 1
	if (isPass) {	// 0表示假的，1表示真的
		printf("通过考试");
	}
	if (isPass) {
		printf("ok");
	}
	int i = 1;
	int sum = i + TURE + FALSE;	// 2
	printf("sum=%d", sum);
	getchar();
}

2.5 基本数据类型转换

自动类型转换

C语言基础学习_第7张图片

C语言基础学习_第8张图片

1)有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度最大的那种数据类型，然后再进行计算(如int型和short型运算时，先把short转成int型后再进行运算)。

2)若两种类型的字节数不同，转换成字节数大的类型，若两种类型的字节数相同，且一种有符号，-种无符号，则转换成无符号类型

3)在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边的类型将转换为左边的类型，如果右边变量的数据类型长度比左边长时，将丢失一部分数据， 这样会降低精度，丢失的部分按四舍五入向前舍入

代码演示

#include 

void main() {

	char c1 = 'a';
	int num1 = c1;
	double d1 = num1;	// 它会自动类型提升

	float f1 = 2.2222f;
	double d2 = 4.2342342322;
	f1 = d2;	// 4.234234精度丢失

	printf("d1 = %.2f f1 = %f", d1, d2);
	getchar();
}
强制类型转换

将精度高的数据类型转换为精度小的数据类型。使用时要加上强制转换符(),但可能造成精度降低或溢出,格外要注意。

➢强制类型转换一般格式如下:

​ (类型名)表达式

​ 什么是表达式:任何有 值都可以称为表达式，比如1+2， int num=2

​ 这种强制类型转换操作并不改变操作数本身

要注意的是：不加强制转换符的是四舍五入，加了强转符就是直接截断小数点后面的

代码演示

#include 

void main() {

	double d1 = 2.34343;
	int num = (int)d1;	// 这里注意，它不是四舍五入，而是直接阶段小数点后的部分

	// 强制转换支队最近的数有效，如果希望针对更多的表达式转换，使用()
	int num2 = (int)(3.5 * 20 + 6 * 1.5);	// (int)(79)
	int num3 = (int)3.5 * 20 + 6 * 1.5;		// 60 + 9 = 69，所以要注意这个问题

	// d1依然是double
	printf("num=%d d1=%f num2=%d num3 = % d", num, d1, num2, num3);
	getchar();

}

3、指针入门

简单的来说，指正表示一个地址（存放的就是一个地址）

写法：int* ptr或者int *ptr都可以

C语言基础学习_第9张图片

注意：指针的类型一定要和数据类型是一致的，int类型的指针只能存放int类型的地址

代码演示

#include 

void main() {

	int num = 1;
	// 定义一个指针变量
	// 说明
	// 1 int*表示类型为指针类型
	// 2 名称ptr，ptr就是一个int*类型
	// 3 ptr指向一个int类型的变量的地址
	int* ptr = #

	// 说明1：如果要取出一个变量的地址，使用格式是%p
	// 说明2: &num表示取出num这个变量对应地址
	printf("num的值=%d num地址=%p", num, ptr);	// num的值=1 num地址=00BCFE6C

	// 1 指针变量，本身也有地址	&ptr
	// 2 指针变量，存放的地址	ptr
	// 3 获取指针指向的值	*ptr
 
	//ptr的地址是006FFA9C ptr存放的值为006FFAA8 ptr指向的值=1
	printf("\nptr的地址是%p ptr存放的值为%p ptr指向的值=%d", &ptr, ptr, *ptr);

	// 修改num的值
	*ptr = 99;
	printf("\nptr指向的值=%d", *ptr);	// 99

	float a = 22;
	float* ptr2 = &a;
	
	double sum = *ptr + *ptr2;
	printf("\nsum=%.2f", sum);	// 99

	getchar();
}

4、值传递和地址传递

C 语言传递参数(或者赋值)可以是值传递(pass by value), 也可以传递指针(a pointer passedbyvalue)，传递指针也叫地址传递。

  1. 默认传递值的类型:基本数据类型(整型类型、小数类型，字符类型),结构体,共用体。
  2. 默认 传递地址的类似:指针、数组

值传递和地址传递使用特点：

1)值传递:将变量指向的存储内容，在传递/赋值时，拷贝- -份给接收变量.

2)地址传递也叫指针传递:如果是指针，就将指针变量存储的地址，传递给接收变量，如果是数组，就将数组的首地址传递给接收变量。

C语言基础学习_第10张图片

代码演示

#include 

void main() {

	int num = 100;
	int* p = #
	int* p2 = p;
	*p2 = 66;
	printf("num=%d", num);	// 66

	getchar();
}

三、常量

3.1 基本介绍

1)常量是固定值， 在程序执行期间不能改变。这些固定的值，又叫做字面量。

2)常 量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

3)常量的值在定义后不能进行修改.

3.2 经常使用的常量

1 整数常量

1)整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数: 0x或0X表示十六进制，0表示八进制，不带前缀则默认表示十进制。整数常量也可以带一个后缀，后缀是U和L的组合，∪表示无符号整数( unsigned)，L表示长整数(long)。后缀可以是大写，也可以是小写，U和L的顺序任意

2)整数常量举例

C语言基础学习_第11张图片

int n1 = 0213;	// 八进制
int n2 = 0x4b;	// 十六进制

2 浮点常量

C语言基础学习_第12张图片

char c1 = 'a';	
char c2 = '\t';		//'\t'是字符常量

3 字符常量

char c1 = 'a';
char c2 = '\t';

4 字符串常量

char str1[20] = "我是靓仔";
char str2[30] = "春暖花开，世界和平";

3.3 常量的定义

1 定义常量的两种方式

① 使用#define预处理器

② 使用const关键字

2 #define预处理器

形式：#define 常量名 常量值

代码演示

#include 

#define PI 3.14	// 定义常量PI 常量值为3.14
void main() {

	//PI = 3.1415926;	常量不能被修改

	double area;

	double r = 1.2;	// 半径
	area = PI * r * r;
	printf("面积：%.2f", area);
	getchar();
}

3 const关键字

#include 

const double PI = 3.14;		// 类似于java的final关键字
void main() {

	double area;
	double r = 1.2;	// 半径
	area = PI * r * r;
	printf("面积：%.2f", area);
	getchar();
}

4 const和#define的区别

  1. const 定义的常量时，带类型，define 不带类型
  2. const是在编译、运行的时候起作用，而define是在编译的预处理阶段起作用
  3. define 只是简单的替换，没有类型检查。简单的字符串替换会导致边界效应 [案例演示].
  4. const常量可以进行调试的，define是不能进行调试的，主要是预编译阶段就已经替换掉了，调试的时候就没它了
  5. const 不能重定义，不可以定义两个一样的，而define通过undef取消某个符号的定义，再重新定义[案例]
  6. define 可以配合#ifdef、#ifndef、 #endif 来使用，可 以让代码更加灵活，比如我们可以通过#define来启动或者关闭调试信息。[案例]

案例

#define A 1;
#define B A + 3;
#define B2 (A + 3)
// define只是简单地替换，直接换
#define C A/B*3;	// 相当于是1/1+3*3 = 10
#define C2 A/B*3	// 相当于是1/(1+3)*3=0.75

#include 

#define DEBUG

void main() {

#ifdef DEBUG
	printf("ok, 调试信息");
#endif
#ifdef DEBUG
	printf("hello，另外的信息");
#endif

#undef DEBUG	// 取消DEBUG的定义
#define DEBUG 123	// 重新定义DEBUG
	printf("DEBUG=%d", DEBUG);
	getchar();
}

四、运算符

1 算数运算符

C语言基础学习_第13张图片

代码演示

#include 

void main() {

	int i = 10;
	int j = 3;
	int sum = i / j;	// sum = 3

	double i2 = 10;
	int j2 = 4;
	double sum2 = i2 / j2;	// sum2 = 2.50

	printf("sum=%d,sum2=%.2f", sum, sum2);
	getchar();
}

注意事项：

对于除号“1”，它的整数除和小数除是有区别的:整数之间做除法时，只保留整数部分而舍弃小数部分

​ 例如: intx=10/3,结果是3

标识符命名规范

1)程序中不得出现仅靠大小写区分的相似的标识符，intx,X;变量x与X容易混淆

2)所有宏定义、 枚举常数、常量(只读变量)全用大写字母命名，用下划线分隔单词

​ 比如:const double TAX RATE = 0.08; //TAX RATE只读变量

​ #define FILE_ PATH “/usr/tmp”

3)定义变量别忘了初始化。定义变量时编译器并不一定清空了这块内存，它的值可能是无效的数据,运行程序，会异常退出.

4)变量名、 函数名:多单词组成时，第-一个单词 首字母小写，第二个单词开始每个单词首字母大写: xxxYyyZzz [驼峰法，小驼峰，比如short stuAge = 20;]

​ 比如:tankShotGame tankShotGame

关键字

C语言基础学习_第14张图片

键盘输入语句

scanf，类似于java的scanner，控制台输入

一、scanf和gets

1.scanf()

语法：scanf(“格式控制字符串”,变量地址列表);

接受字符串时：scanf(“%s”,字符数组名或指针);

2.gets()

语法：gets(字符数组名或指针);

不同点：

scanf不能接受空格、制表符Tab、回车等；

而gets能够接受空格、制表符Tab和回车等；

scanf ：当遇到回车，空格和tab键会自动在字符串后面添加’\0’，但是回车，空格和tab键仍会留在输入的缓冲区中。

gets：可接受回车键之前输入的所有字符，并用’\0’替代 ‘\n’.回车键不会留在输入缓冲区中

二、printf和puts

不同点：puts方法输出完字符串后会自动换行。

五、二进制和位运算符

进制

对于整数，有四种表示方式:

  1. 二进制: 0,1，满2进1，C语言中没有二进制常数的表示方法。

  2. 2)十进制: 0-9 ，满10进1。

  3. 3)八进制: 0-7，满8进1.以数字0开头表示。

  4. 十六进制: 0-9及A-F,满16进1.以0x或0X开头表示。此处的A-F不区分大小写。[A->10B->11C->12D->13E->14 F->15 ]

    如: 0x21AF +1= 0X21B0

➢举例说明:

int num2 = 210; //十进制
int num3 = 01010; //八进制
int num4 = 0x1010;//十六进制

进制的图示

C语言基础学习_第15张图片

C语言基础学习_第16张图片

进制转换

1 其他进制转换成十进制

①二进制转十进制

规则:从最低位开始，将每个位上的数提取出来，乘以2的(位数-1)次方，然后求和。

案例:将二进制1011转成十进制的数

1011 = 1 * 2^0 + 1 * 2^1 + 0 * 1^2 + 1 * 2^3 = 1 + 2 + 0 + 8 = 11

②八进制转十进制

规则:从最低位开始，将每个位上的数提取出来，乘以8的(位数-1)次方，然后求和。

案例:将0123转成十进制的数

0123 = 3 * 8^0 + 2 * 8^1 + 1 * 8^2 = 3 + 16 + 64 = 83

③十六进制转十进制

规则:从最低位开始，将每个位上的数提取出来，乘以16的(位数-1)次方，然后求和

案例:将0X34A转成十进制的数

0X34A = 10 * 16^0 + 4 * 16^1 + 3 * 16^2 = 10 + 64 + 768 = 842

课后练习

110001100转成干进制

2^2 + 2^3 + 2^7 + 2^8 = 4 + 8 + 128 + 256 = 396

02456转成十进制

6 * 8^0 + 5 * 8^1 + 4 * 8^2 + 2 * 8^3 = 6 + 40 + 256 + 1024 = 1326

0xA45转成十进制

5 * 16^0 + 4 * 16^1 + 10 * 16^2 = 5 + 64 + 2560 = 2629

2 十进制转其他进制

①十进制转二进制

规则:将该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。

案例:将56转成二进制

C语言基础学习_第17张图片

②十进制转八进制

规则:将该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应的八进制。

案例:请将156转成八进制

234

③十进制转十六进制

规则:将该数不断除以16,直到南为0为止，然后将每步得到的余数倒过来，就是对应的十六进制。

案例:请将356转成十六进制

164

课堂练习

image-20210822172901400

123 -> 0111 1011

678 -> 01246

8912 -> 0X22D0

3 二进制转八进制和十六进制

①二转八

规则:从低位开始，将=二进制数每三位一组， 转成对应的八进制数即可。

案例:请将11010101转成八进制

11 010 101 -> 0325

②二转十六

规则:低位开始，将二进制数每四位一组, 转成对应的十六进制数即可。

案例:请将11010101转成十六进制

1101 0101 -> 0XD5

练习

C语言基础学习_第18张图片

11 100 101 -> 0345

11 1001 0110 -> 0X396

4 八进制和十六进制转二进制

①八转二

规则:将八进制数每1位，转成对应的一一个3位的二进制数即可。

案例:请将0237转成二进制

0237 -> 01 011 111

②十六转二

规则:将十六进制数每1位，转成对应的4位的-一个二进制数即可。

案例:请将0x23B转成二进制

0x23B -> 0010 0011 1011

练习

C语言基础学习_第19张图片

01230 -> 1 010 011 000

0XAB29 -> 1010 1011 0010 1001

原码、反码、补码

必须要记住，很重要

C语言基础学习_第20张图片

这里演示用四个字节
正数三码合一
2
原码: 00000000 00000000 00000000 00000010
反码: 00000000 00000000 00000000 00000010
补码:	00000000 00000000 00000000 00000010
    
-2
原码: 10000000 00000000 00000000 00000010
反码: 11111111 11111111 11111111 11111101
补码: 11111111 11111111 11111111 11111110

位运算符

C语言基础学习_第21张图片

示例

image-20210825200035242

~2

~2
2的补码: 00000000 00000000 00000000 00000010

补码取反: 11111111 11111111 11111111 11111101
然后将上面取反的补码转成原码就是我们的结果了

最高符号位为1，它是一个负数，所以要按照负数的规则来转
思路：先转成反码，反码再转成原码
转反码 = 补码 - 1
-> 11111111 11111111 11111111 11111100
反码 -> 原码
-> 10000000 00000000 00000000 00000011
所以~2的结果是 -3

~-5

~-5
-5的原码 -> 10000000 00000000 00000000 00000101
    反码 -> 01111111 11111111 11111111 11111010
    补码 -> 01111111 11111111 11111111 11111011
    
    取反 -> 10000000 00000000 00000000 00000100
    
    反码 -> 01111111 11111111 11111111 11111011
    原码 -> 00000000 00000000 00000000 00000100
结果是 4

2&-3

2&-3
-3的原码: 10000000 00000000 00000000 00000011
    反码: 11111111 11111111 11111111 11111100
    补码: 11111111 11111111 11111111 11111101
 2的补码: 00000000 00000000 00000000 00000010
      & : 00000000 00000000 00000000 00000000
    结果为0

2|3

 2|3
  2的补码: 00000000 00000000 00000000 00000010
  3的补码: 00000000 00000000 00000000 00000011
       | : 00000000 00000000 00000000 00000011
       结果为3

2^3

2^3
  2的补码: 00000000 00000000 00000000 00000010
  3的补码: 00000000 00000000 00000000 00000011
       ^ : 00000000 00000000 00000000 00000001
      结果为1

4&-5

-5的原码: 10000000 00000000 00000000 00000101
    反码: 11111111 11111111 11111111 11111010
    补码: 11111111 11111111 11111111 11111011
  4的补码:00000000 00000000 00000000 00000100
      & : 00000000 00000000 00000000 00000000
          结果为0

左移和右移

C语言基础学习_第22张图片

正数的右移就是除以2，又移几位就是除于几个2，左移就是乘于2，左移几位就是乘于几个2

负数的要通过推

举例子：

2的补码: 00000000 00000000 00000000 00000010
   2>>1: 00000000 00000000 00000000 00000001
   就是整体向右移动一位，符号位为0，所以用符号位补全溢出的高位

-1 >> 2

-1的原码: 10000000 00000000 00000000 00000001
    反码: 11111111 11111111 11111111 11111110
    补码: 11111111 11111111 11111111 11111111
   -1>>2: 11111111 11111111 11111111 11111111
    反码: 11111111 11111111 11111111 11111110
    原码: 10000000 00000000 00000000 00000001
        结果是-1

-1 << 2

-1的补码: 11111111 11111111 11111111 11111111
   -1<<2: 11111111 11111111 11111111 11111100
    反码: 11111111 11111111 11111111 11111011
    原码: 10000000 00000000 00000000 00000100
        结果为-4

六、程序流程控制

while和for死循环

image-20210912220452836

switch要注意的细节

C语言基础学习_第23张图片

goto

类似于水门的飞雷神，通过标志然后进行传送

image-20210827151853517

C语言基础学习_第24张图片

#include 

void main() {
	printf("start\n");
	goto lablel; //lable1称为标签
	printf("ok l\n");
	printf("ok2\n");
	lablel:
	printf("ok3\n");
	printf("ok4\n");
		getchar();
} //输出 ok3和ok4

练习

水仙花数

image-20210827152946275

#include 

void main() {

	int num = 154;	// 不是水仙花数
	int num1 = num / 100;		// 百位数
	int num2 = num % 100 / 10;	// 十位数
	int num3 = num % 10;		// 个位数
	if (num == num1 * num1 * num1 + num2 * num2 * num2 + num3 * num3 * num3) {
		printf("%d是水仙花数",num);
	}
	else {
		printf("%d不是水仙花数", num);
	}
	getchar();
}

求天数

image-20210827153826637

#include 

// 求月的天数，要考虑闰年和平年
// 思路：31天的月份和30的月份区分开，还要判断是否是闰年

void main () {
	// 31天的月份分别是:1月、3月、5月、7月、8月、10月、12月
	int year = 2021;
	int month = 2;

	switch (month)
	{
	case 1:
	case 3:
	case 5:
	case 7:
	case 8:
	case 10:
	case 12:
		printf("%d年的%d月份是%d天", year, month, 31);
		break;
	case 2:
		// 判断是否是闰年
		if (year % 4 == 0 && year / 100 != 0) {
			printf("%d年的%d月份是%d天", year, month, 29);
		}
		printf("%d年的%d月份是%d天", year, month, 28);
		break;
	default:
		printf("%d年的%d月份是%d天", year, month, 30);
		break;
	}
	getchar();
}

判断星期

image-20210827155233914

#include 

// 判断星期，星期一到星期三，打印AAA，星期四到星期五打印BBB，星期六到星期日打印CCC

void main() {
	int week = 1;
    
	switch (week)
	{
	case 1:
	case 2:
	case 3:
		printf("AAA");
		break;
	case 4:
	case 5:
		printf("BBB");
		break;
	case 6:
	case 7:
		printf("CCC");
		break;
	}
	getchar();
}

输出a-z和A-Z

image-20210827155839298

#include 

void main() {

	for (char c1 = 'a'; c1 <= 'z'; c1++)
	{
		printf("%c\n", c1);
	}
	for (char c2 = 'A'; c2 <= 'Z'; c2++)
	{
		printf("%c\n", c2);
	}
	getchar();
}

七、枚举

  1. 枚举是C语言中的一种构造数据类型，它可以让数据更简洁，更易读,对于只有几个有限的特定数据，可以
    使用枚举.

  2. 枚举对应英文(enumeration,简写enum)

  3. 枚举是一组常量的集合，包含- -组有限的特定的数据

  4. 枚举语法定义格式为

    enum
枚举名{枚举元素 1,枚举元素...;.

快速入门

#include 

// 枚举快速入门
enum DAY
{
	MON = 1,TUE = 2, WED = 3, THU = 4, FRI = 5, SAT = 6,SUN = 7
};

void main() {
	// 也可以在方法内部定义
	//enum DAY
	//{
	//	MON = 1, TUE = 2, WED = 3, THU = 4, FRI = 5, SAT = 6, SUN = 7
	//};
	enum DAY day = WED;
	printf("%d", day);
	getchar();
}

遍历枚举

for循环

#include 

// for循环遍历枚举
enum DAY 
{
	// 如果没有赋值，就会按照顺序赋值，如果第一个也没有赋值，那么就会从0开始赋值
	MON , TUE, WED, THU, FRI, SAT, SUN	
}day;	// 表示定义了一个枚举类型，同时定义了一个变量day(enum DAY类型)
void main() {
	for (day = MON; day <= SUN; day++) {
		printf("%d\n", day);
	}
	getchar();
}

switch循环

#include 

enum SEASONS
{
	SPRING=1, SUNMMER, AUTUMN, WINTER
}season;	// 定义枚举类型，变量名season

void main() {
	printf("请输入你喜欢的季节:(1.spring 2.summer 3.autumn 4.winter)：");
	scanf_s("%d", &season);
	switch (season)
	{
	case SPRING:
		printf("你喜欢的是春天");
		break;
	case SUNMMER:
		printf("你喜欢的是夏天");
		break;
	case AUTUMN:
		printf("你喜欢的是秋天");
		break;
	case WINTER:
		printf("你喜欢的是的冬天");
		break;
	default:
		printf("没有你喜欢的天");
		break;
	}
	getchar();
	getchar();
}

枚举的注意事项和细节

  1. 第一个枚举成员的默认值为整型的0, 后续枚举成员的值在前一个成员上加1。 我们在这个实例中把第一一个枚
    举成员的值定义为1,第二个就为2，以此类推. [看案例]

  2. 在定义枚举类型时改变枚举的元素的值

    enum DAY {
	MON, TUE, WED, THU=9, FRI, SAT, SUN //如果没有给赋值，就会按照顺序赋值.
} day;  // 表示定义了一- 个枚举类型enum Day，同时定义了一个变量day(类型是enum DAY)
// MON, TUE, WED 为 0 , 1 , 2
//说明FRI, SAT, SUN就是10, 11, 12

    所以后面数的赋值要根据前面数来定

  3. 枚举变量的定义也可以先定义枚举类型，再定义枚举变量

    enum DAY {
MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY day;

  4. 枚举变量的定义可以省略枚举名称，直接定义枚举变量

    enum {
	MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;	// 这样使用枚举，该枚举类型只能使用- - -次.

    注意：这种定义只能用一次

  5. 可以将整数转换成对应的枚举值

    #include 
int main() {
	enum SEASONS { SPRING = 1, SUMMER, AUTUMN, WINTER };
	enum SEASONS season;
	int n = 4;
	season = (enum SEASONS)n;	// 转换成枚举值
	printf("season = %d", season);
		getchar();
	return 0;
}

八、函数

头文件概述

  1. 头文件是扩展名为.h的文件,包含了C函数声明和宏定义，被多个源文件中引用共享。有两种类型的头文件:
    程序员编写的头文件和C标准库自带的头文件
  2. 在程序中要使用头文件， 需要使用C预处理指令#include来引用它。前面我们已经看过stdio.h 头文件，它是
    C标准库自带的头文件
  3. #include叫做文件包含命令,用来引入对应的头文件(.h文件)。#include也是C语言预处理命令的一-种。#include
    的处理过程很简单，就是将头文件的内容插入到该命令所在的位置，从而把头文件和当前源文件连接成-一个源
    文件，这与复制粘贴的效果相同。但是我们不会直接在源文件中复制头文件的内容，因为这么做很容易出错,
    特别在程序是由多个源文件组成的时候。
  4. 建议把所有的常量、宏、系统全局变量和函数原型写在头文件中，在需要的时候随时引用这些头文件

代码实现

首先我们要定义头文件，定义好头文件之后我们就编写对应函数的代码

在头文件文件夹中创建 myfun.h 文件
int sum(int a, int b);

void sayHello();

编写对应的代码

#include 

int sum(int a, int b) {
	return a + b;
}

void sayHello() {
	printf("hello");
}

测试函数

#include 
#include "myfun.h"	// 引入自定义的函数

void main() {
	int a = 2;
	int b = 3;
	int s = sum(a, b);
	printf("%d\n", s);
	sayHello();		// 调用sayHello方法
	getchar();
}

头文件的注意事项和细节说明

  1. 引用头文件相当于复制头文件的内容

  2. 源文件的名字可以不和头文件一样，但是为了好管理，一**-般头文件名和源文件名一样.**

  3. C语言中include<> 与include ""的区别
    include <>:引用的是编译器的类库路径里面的头文件，用于引用系统头文件。
    include"":引用的是你程序目录的相对路径中的头文件，如果在程序目录没有找到引用的头文件则到编译器的
    类库路径的目录下找该头文件，用于引用用户头文件。
    所以:
    *引用系统头文件，两种形式都会可以，include<> 效率高
    *引用用户头文件，只能使用include " "

注：" "它会先去找自定义的函数，找不到自定义的就会去找系统提供的

  1. 一个#include 命令只能包含一个头文件，多个头文件需要多个#include 命令

  2. 同一个头文件如果被多次引入，多次引入的效果和一次引入的效果相同，因为头文件在代码层面有防止重复引
    入的机制

  3. 在一个被包含的文件(.c)中又可以包含另一个文件头文件(.h)

  4. 不管是标准头文件，还是自定义头文件，都只能包含变量和函数的声明，不能包含定义，否则在多次引入时会
    引起重复定义错误(!!!

因为include是替换头文件里面的内容，如果是多次引入函数的定义的话就没事，因为它有查重的机制，如果是多次引入函数的声明的话就会出问题。

函数的调用过程

函数的调用规则（适用于java,c++,php）

  1. 当调用（执行）一个函数时，就会开辟一个独立的空间（栈）

  2. 每个栈空间都是相互独立的

  3. 当函数执行完毕后(或者执行到return语句)，会返回调用函数的位置，继续执行下面的代码

  4. 如果函数有返回值，则将返回值赋给接收的变量

    ①如果方法返回的数据是double类型的，我们可以ruturn比他小的类型，比如int类型，它会自动类型提升到double类型

    ②如果方法返回的数据是char类型的，return 一个int类型就会报错，需要进行强制类型转换才能return

  5. 当一个函数返回后，该函数对应的栈空间也就销毁了

C语言基础学习_第25张图片

举例说明

C语言基础学习_第26张图片

函数-递归调用

我调我自己，在方法内部调用自己

#include 

void test(int n) {
	if (n > 2) {
		test(n - 1);
	}
	printf("n=%d\n", n);
}
void main() {
	test(4);
	getchar();
}

C语言基础学习_第27张图片

函数递归需要遵守的重要规则

  1. 执行一个函数时，就创建一个独立的空间（栈）
  2. 函数的局部变量时独立的，不会相互影响
  3. 递归必须有退出递归的条件，如果没有就会无限递归，造成内存溢出
  4. 当一个函数执行完毕，或遇到return，就会返回，谁调用那么结果就返回给谁

递归练习题

➢题1: 斐波那契数
请使用递归的方式，求出斐波那契数1,1,2,3,5,8,13…
给你-一个整数n,求出它的斐波那契数是多少?

#include 

int fbn(int n) {
	if (n == 1 | n == 2) {
		return 1;
	}
	else {
		return fbn(n - 1) + fbn(n - 2);
	}
}

void main() {

	// 求斐波那契数
	int res = fbn(5);
	printf("res=%d", res);
	getchar();
}

➢题2:求函数值
已知f(1)=3; f(n)= 2*f(n-1)+1;
请使用递归的思想编程，求出f(n)的值?

#include 

int f(int n) {
	if (n == 1) {
		return 3;
	}
	else {
		return 2 * f(n - 1) + 1;
	}
}

void main() {
	// 求函数值
	int res = f(7);
	printf("res=%d", res);
	getchar();
}

➢题3:猴子吃桃子问题
有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!以后每天猴子都吃其中的一-半，然后再多吃一一个。
当到第十天时，想再吃时(还没吃)，发现只有1个桃子了。问题:最初共多少个桃子?

#include 
// 有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!以后每天猴子都吃其中的一 - 半，然后再多吃一一个。
// 当到第十天时，想再吃时(还没吃)，发现只有1个桃子了。问题:最初共多少个桃子 ?
int peach(int day) {
	if (day == 10) {
		return 1;
	}
	else {
		return (peach(day + 1) + 1) * 2;
	}
}

void main() {
	// 猴子吃桃子问题
	int res = peach(1);
	printf("res=%d", res);
	getchar();
}

函数的注意事项和细节讨论

  1. 函数的形参列表可以是多个。

  2. C 语言传递参数可以是值传递(pass by value)，也可以传递指针(a pointer passed by value)也叫引用传递。

  3. 函数的命名遵循标识符命名规范，首字母不能是数字，可以采用驼峰法或者下划线法，比如getMax()
    get_ max().

  4. 函数中的变量是局部的， 函数外不生效

  5. 基本数据类型默认是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。

  6. 如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量。从效果
    上看类似引用(即传递指针) [ 案例演示:]

    #include 
void test(int* p) {
	(*p)++;
}

void main() {
	int p = 3;
	test(&p);
	printf("p=%d", p);
	getchar();
}

  7. C语言不支持函数重载。

  8. C语言支持可变参数函数1/知道即可[案例演示]

    #include 
#include 

void test(int* p) {
	(*p)++;
}
int fun(int num, ...) {		// 可变形参就是将一堆参数放入到一个数组中
	int i, totalSum = 0;	// totalSum一定要初始化
	int val = 0;
	va_list v1;
	va_start(v1, num);
	printf("*v=%d\n", v1);
	for (i = 0 ; i < num; i++)
	{
		val = va_arg(v1, int);
		printf("val=%d\n", val);
		totalSum += val;
	}
	va_end(v1);
	return totalSum;
}

void main() {
	// 传入指针参数
	//int p = 3;
	//test(&p);
	//printf("p=%d", p);

	// 可变形参
	int res = fun(8, 1, 2, 3, 4, 5, 5, 6, 9);	// 第一个参数是它这个可变形参数组的长度
	printf("res=%d", res);
	getchar();
}

练习题

请编写一个函数swap(intnl, int **n2) 可以交换nl和:n2的值

#include 

void swap(int *n1, int *n2) {
	int temp = *n1;
	*n1 = *n2;
	*n2 = temp;
}

void main() {
	int n1 = 2;
	int n2 = 3;
	swap(&n1, &n2);
	printf("n1=%d, n2=%d", n1, n2);
	getchar();
}

函数参数的传递方式

两种传递方式

  1. 值传递
  2. 引用传递(传递指针、地址)

值传递和引用传递的特点

  • 值传递：变量直接存储值，内存通常在栈中分配

    默认是值传递的数据类型有： 1.基本数据类型2. 结构体3.共用体4.枚举类型

  • 引用传递：变量存储的是地址，这个地址对应的空间才是具体的值

    默认是引用传递的数据类型有： 指针和数组

如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量(*指针)。

变量的作用域

变量作用域就是指变量的有效范围

  1. 函数内部声明/定义的局部变量，作用域仅限于函数内部。
  2. 函数的参数， 形式参数，被当作该函数内的局部变量，如果与全局变量同名它们会优先使用局部变量(编译器
    使用就近原则)
  3. 在一个代码块，比如for/if中的局部变量，那么这个变量的的作用域就在该代码块
  4. 4)在所有 函数外部定义的变量叫全局变量，作用域在整个程序有效

初始化局部变量和全局变量

  1. 局部变量，系统不会对其默认初始化，必须对局部变量初始化后才能使用，否则，程序运行后可能会异常退出.

  2. 全局变量，系统会自动对其初始化，如下所示

    C语言基础学习_第28张图片

  3. 正确地初始化变量是一个良好的编程习惯，否则有时候程序可能会产生意想不到的结果，因为未初始化的变量
    会导致一些在内存位置中已经可用的垃圾值

作用域的注意事项和细节

  1. 全局变量(Global Variable)保存在内存的全局存储区中，占用静态的存储单元，它的作用域默认是整个程序，也
    就是所有的代码文件，包括源文件(.c 文件)和头文件(.h 文件)。[c 程序内存布局图!!!]

    C语言基础学习_第29张图片

  2. 局部变量(IocalVariable)保存在栈中，函数被调用时才动态地为变量分配存储单元，它的作用域仅限于函数内
    部。[内存布局分析]

  3. C语言规定，只能从小的作用域向大的作用域中去寻找变量，而不能反过来，使用更小的作用域中的变量

  4. 在同一个作用域,变量名不能重复，在不同的作用域，变量名可以重复，使用时编译器采用就近原则.

  5. 由{ }包围的代码块也拥有独立的作用域

练习

思考:下面的代码输 出什么内容?

#include 

double price = 200.0;	// 全局变量

void test01() {
	printf("%.2f\n", price);
}
void test02() {
	// 编译器采用就近原则
	double price = 250.0;
	printf("%.2f\n", price);
}

void main() {
	printf("main price = %.2f\n", price);
	test01();	// 200
	test02();	// 250
	test01();	// 200	因为调用test02的时候已经修改的是局部变量price的值，所以并没有修改全局变量
	getchar();
}

思考:下面的代码输 出什么内容?

#include 

int n = 10;

void fun1() {
	int n = 20;
	printf("fun1 n:%d\n", n);	// 局部变量
}

void fun2(int n) {
	printf("fun2 n:%d\n", n);	// 形参n
}

void fun3() {
	printf("fun3 n:%d\n", n);	// 全局变量n
}

void main() {
	int n = 30;
	fun1();		// 20
	fun2(n);	// 30
	fun3();		// 10
	getchar();
}

static关键字

c语言的static和java的是相反的，它和java中的private关键字的作用一样

局部变量使用static修饰

  1. 局部变量被static 修饰后，我们称为静态局部变量
  2. 对应静态局部变量在声明时未赋初值，编译器也会把它初始化为0。
  3. 静态局部变量存储于进程的静态存储区(全局性质)，只会被初始一-次，即使函数返回,它的值也会保持不变

代码演示

void main() {
	static int n;
	printf("n=%d", n);	// 0
	getchar();
}

#include 

//void main() {
//	static int n;
//	printf("n=%d", n);	// 0
//	getchar();
//}

void fun(void) {	// void就是告诉编译器没有形参，可写可不写
	int n = 10;
	printf("n=%d\n", n);
	n++;
	printf("n++=%d\n", n);
}

void fun_static(void) {
	static int n = 10;
	printf("\nstatic n=%d\n", n);
	n++;
	printf("\nn++=%d\n", n);
}

void main() {
	fun();
	printf("-----------\n");
	fun_static();
	printf("-----------\n");
	fun();
	printf("-----------\n");
	fun_static();
	getchar();
}

全局变量使用static修饰

  1. 普通全局变量对整个工程可见，其他文件可以使用exterm外部声明后直接使用。也就是说其他文件不能再定义
    一个 与其相同名字的变量了( 否则编译器会认为它们是同一个变量)，静态全局变量仅对当前文件可见，其他
    文件不可访问，其他文件可以定义与其同名的变量，两者互不影响[案例]
file01
int n = 10;
static int n2 = 20;

file02
extern int n2;
// extern int n;
void main() {
    //printf("%d", n);	// 10
	printf("%d", n2);
	getchar();
}

image-20210829104215962

  1. 定义不需要与其他文件共享的全局变量时，加上static关键字能够有效地降低程序模块之间的耦合，避免不同
    文件同名变量的冲突，且不会误使用

函数用static修饰

和修饰全局变量一个作用，都是只能在本文件中使用，其他文件不能使用

  1. 函数的使用方式与全局变量类似，在函数的返回类型前加上static,就是静态函数

  2. 非静态函数可以在另一个文件中通过extern 引用[ 案例]

  3. 静态函数只能在声明它的文件中可见，其他文件不能引用该函数[案例]

  4. 不同的文件 可以使用相同名字的静态函数，互不影响[案例]

    如果引用了其他文件的全局变量，那么就不能定义和这个相同的全局变量了

代码演示

file03
#include 

void fun1() {
	printf("我是靓仔智");
}

static void fun2() {
	printf("我是傻逼智");
}

file04
#include 

extern void fun1();
// extern void fun2();

void main() {
	//fun1();
	fun2();
	getchar();
}

image-20210829105442480

常用的系统函数

字符串常用的系统函数

  1. 得到字符串的长度
    size_ t strlen( const char *str)
    计算字符串str 的长度，直到空结束字符，但不包括空结束字符。
  2. 拷贝字符串
    char *strcpy(char *dest, const char *src)
    把SrC所指向的字符串复制到dest。
  3. 连接字符串(类似java的append)
    char *strcat( char * dest, const char *src)
    把src所指向的字符串追加到dest所指向的字符串的结尾。

代码演示

#include 
#include 		// 使用字符串要引入对应的函数库

// 测试常用的字符串函数
void main() {
	char str[30] = "abcde";
	char a[20] = "asd";
	char b[30] = "世界上最靓仔的是";
	int length = strlen(str);
	strcpy(a, "cccc");
	strcat(b, "靓仔智");
	printf("length=%d\n", length);
	printf("a=%s\n", a);	// cccc，覆盖了原来的数据
	printf("b=%s\n", b);	// 世界上最靓仔的是靓仔智
	getchar();
}

时间和日期相关函数

  1. 获取当前时间
    char *ctime( const time t *timer)

    返回一个表示当地时间的字符串，当地时间是基于参数timer。

    void main() {
	time_t curtime;	// time_h是一个结构体类型
	time(&curtime);	// time()完成初始化
	// ctime返回一个表示当前时间的字符串，当前时间是基于参数timer
	printf("当前时间：%s", ctime(&curtime));
	getchar();
}

  2. 编写一段代码来统计函数test执行的时间
    double difftime(time_ t timel, time_ _t time2)
    返回timel 和time2之间相差的秒数(timel-time2)。 .

    #include 
#include 

void test() {
	printf("test函数开始执行\n");
	int sum = 0;
	for (int i = 0; i < 66666; i++)
	{
		sum = 0;
		for (int j = 0; j < 10; j++)
		{
			sum += j;
			printf("%d", i);
		}

	}
}
void main() {
	//time_t curtime;	// time_h是一个结构体类型
	//time(&curtime);	// time()完成初始化
	 ctime返回一个表示当前时间的字符串，当前时间是基于参数timer
	//printf("当前时间：%s", ctime(&curtime));
	//getchar();

	// 执行test()前的时间
	time_t start_t, end_t;
	double diff_t;	// 存放时间差
	printf("程序启动\n");
	time(&start_t);	// 初始化当前时间

	test();	// 执行test

	// 执行test()后的时间
	time(&end_t);	// 得到当前时间
	diff_t = difftime(end_t, start_t);	// 时间差，结束时间-开始时间
	printf("执行test函数耗用了%.2f秒", diff_t);
	getchar();
}

数学相关函数

math.h头文件定义了各种数学函数和一个宏。在这个库中所有可用的功能都带有-一个double类型的参数，且都返
回double类型的结果
举例说明:

  1. double exp(double x)
    返回e的x次幂的值。
  2. double log(double x)
    返回x的自然对数(基数为e的对数)
  3. double pow(double x, double y)
    返回x的y次幂。
  4. double sqrt(double x)
    返回x的平方根。
  5. double fabs(double x)
    返回x的绝对值。

代码实现

#include 
#include 

void main() {
	double res = fabs(-3);	// 绝对值
	double res2 = sqrt(2);	// 平方根
	double res3 = exp(0);	// e的几次幂
	double res4 = log(1);	// 返回x的自然对数
	double res5 = pow(4, 5);// x的y次幂，第一个参数为x
	printf("res=%.2f res2=%.2f res3=%.2f res4=%.2f res5=%.2f", res, res2, res3, res4, res5);
	getchar();
}

基本数据类型和字符串类型的转换

在程序开发中，我们经常需要将基本数据类型转成字符串类型(即char数组)。或者将字符串类型转成基本数
据类型。

sprintf 函数的用法
  1. sprintf和平时我们常用的printf函数的功能很相似。sprintf函数打印到字符串中，而printf函数打印输出到屏幕
    上。sprintf函数在我们完成其他数据类型转换成字符串类型的操作中应用广泛
  2. 该函数包含在stdio.h的头文件中

基本数据类型转字符串类型

#include 

void main() {
	char str1[30];
	char str2[30];
	char str3[30];
	int a = 20;
	double b = 30.0;
	sprintf(str1, "%d", a);
	sprintf(str2, "%.2f", b);
	sprintf(str3, "%8.2f", b);	// %8.2f 含义是输出8位，小数点占用两位，如果不够8位，就会用空格在前面占位
	printf("str1=%s str2=%s str3=%s", str1, str2, str3);
	getchar();
}

C语言基础学习_第30张图片

字符串类型转基本数据类型

语法：通过的函数调用atoi .atof即可

注意事项：

  1. 在将 char数组类型转成基本数据类型时，要确保能够转成有效的数据，比如我们可以把"123"，转成一一个
    整数，但是不能把"hello"转成一-个整数
  2. 如果格式不正确，会默认转成0或者0.0

代码实现

#include 
#include 		// 引入需要的函数

void main() {
	char str1[20] = "23423";
	char str2[20] = "343.3";
	char str3[20] = "ab";
	char str4[20] = "1111";
	int a = atoi(str1);
	double b = atof(str2);
	char c = str3[0];		// 索引
	long d = atol(str4);
	printf("a=%d b=%.2f c=%c d=%d", a, b, c, d);
	getchar();
}

九、预处理命令

1 基本介绍

预处理是在编译之前执行的操作

  1. 使用库函数之前，应该用#include引入对应的头文件。这种以#号开头的命令称为预处理命令。
  2. 这些在编译之前对源文件进行简单加工的过程，就称为预处理(即预先处理、提前处理)
  3. 预处理 主要是处理以#开头的命令，例如#include 等。预处理命令要放在所有函数之外，而且-般都放
    在源文件的前面
  4. 预处理是C语言的一个重要功能，由预处理程序完成。当对一个源文件进行编译时，系统将自动调用预处理程
    序对源程序中的预处理部分作处理，处理完毕自动进入对源程序的编译
  5. C语言提供了多种预处理功能，如宏定义、文件包含、条件编译等，合理地使用它们会使编写的程序便于阅读、
    修改、移植和调试，也有利于模块化程序设计

2 快速入门

具体要求

开发-一个C语言程序，让它暂停5秒以后再输出内容"春暖花开，世界和平"，并且要求跨平台，在Windows和
Linux、下 都能运行，如何处理

提示

  1. Windows 平台下的暂停函数的原型是void Sleep(DWORD dwMilliseconds)， 参数的单位是“毫秒”，位
    于头文件。
  2. Linux 平台下暂停函数的原型是unsigned int sleep (unsigned int seconds)，参数的单位是“秒”，位于
    头文件
  3. #if、 #elif、 #endif 就是预处理命令，它们都是在编译之前由预处理程序来执行的。

代码实现

#include 
#if _WIN32	// 如果是windows平台，执行#include 
#include 
#elif _linux_	// 如果是linux平台，#include 
#include 
#endif

void main() {
	// 不同的平台下调用不同的函数
	#if _WIN32
	Sleep(5000);	// 毫秒
	#elif _linux_
	Sleep(5);		// 秒
	#endif
	puts("春暖花开，世界和平");	// puts和printf一样的功能
	getchar();
}

3 C语言宏定义

  1. #define 叫做宏定义命令，它也是C语言预处理命令的- -种。所谓宏定义，就是用一个标识符来表示一个字符
    串，如果在后面的代码中出现了该标识符，那么就全部替换成指定的字符串
  1. 宏定 义我们在讲解常量时，做过介绍，这里我们再系统的讲解一下.

#defineN 100就是宏定义，N为宏名，100 是宏的内容(宏所表示的字符串)。在预处理阶段，对程序中所有出现
的“宏名”，预处理器都会用宏定义中的字符串去代换，这称为**“宏替换”或“宏展开”**。
宏定义是由源程序中的宏定义命令#define完成的，宏替换是由预处理程序完成的

4 宏定义的形式

  1. #表示这是一条预处理命令，所有的预处理命令都以#开头。宏名是标识符的一种，命名规则和变量相同。字.
    符串可以是数字、表达式、if语句、函数等
  2. 这里所说的字符串是- -般意义.上的字符序列，不要和C语言中的字符串等同，它不需要双引号
  3. 程序中反复使用的表达式就可以使用宏定义

代码演示

#include 

#define M (n*n+3*n)	// 只是简单的替换，如果不带括号又是另一种结果了
void main() {
	int sum, n;
	printf("请输入一个数字");
	scanf("%d", &n);
	sum = 3 * M + 4 * M + 5 * M;	// 宏展开	3*(n*n+3*n) + 4*(n*n+3*n) + 5*(n*n+3*n) 
	printf("sum=%d\n", sum);
	getchar();
	getchar();
}

宏定义注意事项和细节

  1. 宏定义是用宏名来表示-一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的替换。字符串中可
    以含任何字符，它可以是常数、表达式、if语句、函数等，预处理程序对它不作任何检查，如有错误，只能在
    编译已被宏展开后的源程序时发现。

  2. 宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起替换

  3. 宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#undef命令[案
    例]

#define PI 3.14159
int main(){
printf("PI=%f", PI); .
return 0;
}
#undefPI //取消宏定义
void func({
// Code
printf("PI=%f", PD);//错误,这里不能使用到PI了
  1. 代码中的宏名如果被引号包围，那么预处理程序不对其作宏代替[案例]
#include 
#define OK 100
int main(){
	printf("OK\n");	// 这里就相当于是字符串输出，不能进行替换
	return 0;
}
  1. 宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名，在宏展开时由预处理程序层层代换[ 案例]
#define PI 3.1415926
#define S PI*y*y
/* PI是已定义的宏名*/
print("%f", S);
// 在宏替换后变为:
print("%f", 3.1415926*y*y);

  1. 习惯上宏名用大写字母表示，以便于与变量区别。但也允许用小写字母

  2. 可用宏定义表示数据类型，使书写方便[案例]

    #define UINT unsigned int
void main() {
	UINT a,b;	//宏替换 unsigned int a, b;
}

  3. 宏定义表示数据类型和用typedef定义数据说明符的区别:宏定义只是简单的字符串替换，由预处理器来处理;
    而typedef是在编译阶段由编译器处理的，它并不是简单的字符串替换,而给原有的数据类型起一-个新的名字，
    将它作为–种新的数据类型。

5 带参数的宏定义

  1. C语言允许宏带有参数。在宏定义中的参数称为“形式参数”，在宏调用中的参数称为“实际参数”，这点和
    函数有些类似
  2. 对带 参数的宏，在展开过程中不仅要进行字符串替换，还要用实参去替换形参
  3. 带参宏定义的一般形式为**#define 宏名(形参列表)字符串**,在字符串中可以含有各个形参
  4. 带参宏调用的一般形式为:宏名(实参列表); [案例+说明]

代码演示

#include 

// 1 MAX就是带参数的宏
// 2 (a, b)就是形参
// 3 (a>b)?a: b是带参数的宏对应字符串，该字符串中可以使用形参.
#define MAX(a, b) (a > b) ? a : b
void main() { 
	int x, y, max;
	printf("input two numbers\n");
	scanf("%d%d", &x, &y);
	max = MAX(x, y);	// 宏替换	max = (x > y) ? x : y
	printf("max=%d", max);
	getchar();
	getchar();
}

带参宏定义的注意事项和细节

  1. 带参宏定义中，形参之间可以出现空格，但是宏名和形参列表之间不能有空格出现

    #define MAX(a,b) (a>b)?a:b
如果写成了#define MAX (a, b) (a>b)?a:b
将被认为是无参宏定义，宏名MAX代表字符串(a,b) (a>b)?a:b
而不是: MAX(a,b)代表(a>b)?a:b 了

  2. 在带参宏定义中,不会为形式参数分配内存，因此不必指明数据类型。而在宏调用中,实参包含了具体的数据,
    要用它们去替换形参，因此实参必须要指明数据类型

  3. 在宏定义中，字符串内的形参通常要用括号括起来以避免出错。

    #include 
#define SQ(y) (y)*(y)//带参宏定义，字符串内的形参通常要用括号括起来以避免出错
int main(){
    int a, sq;
    printf("input a number: "); .
    scanf("%d", &a);
    // 如果没有括号就会变成：a + 1 * a + 1 = a + a + 1	就不是我们想要的结果了
    sq= SQ(a+1);//宏替换(a+1)* (a+1)
    printf("sq=%d\n", sq);
    system("pause");
    return 0;
}

6 带参宏定义和函数的差别

  1. 宏展开仅仅是字符串的替换，不会对表达式进行计算;宏在编译之前就被处理掉了，它没有机会参与编译，也
    不会占用内存。
  2. 函数是一 段可以重复使用的代码，会被编译，会给它分配内存，每次调用函数，就是执行这块内存中的代码.
  3. 案例说明 :要求使用函数计算平方值，使用宏计算平方值， 并总结二者的区别
#include 
#include 

//int SQ(int y) {
//	return y * y;
//}

#define SQ(y) (y)*(y)
void main() {
	int i = 1;
	while (i <= 5) {
		//printf("%d^2=%d\n", i - 1, SQ(i++));
		printf("%d^2=%d\n", i - 2, SQ(i++));	// 宏展开 (i++) * (i++)
		// 宏定义它是直接替换，因此在这里它++了两次，所以i的变化时1 ， 3 ，5
		// 函数它的i的变换是1,2,3,4,5 所以这就是两者的区别，要注意一下
	}
	system("pause");
}

7 预处理命令总结

预处理指令是以#号开头的代码行，#号必须是该行除了任何空白字符外的第-一个字符。#后是指令关键字，
在关键字和#号之间允许存在任意个数的空白字符，整行语句构成了一条预处理指令，该指令将在编译器进行编
译之前对源代码做某些转换

C语言基础学习_第31张图片

预处理指令使用注意事项

  1. 预处理功能是C语言特有的功能，它是在对源程序正式编译前由预处理程序完成的，程序员在程序中用预处理
    命令来调用这些功能。
  2. 宏定义可以带有参数，宏调用时是以实参代换形参，而不是“值传送”。
  3. 为了避免宏代换时发生错误，宏定义中的字符串应加括号，字符串中出现的形式参数两边也应加括号。
  4. 文件包含是预处理的-一个重要功能，它可用来把多个源文件连接成一- 个源文件进行编译，结果将生成-一个 目标
    文件。
  5. 条件编译允许只编译源程序中满足条件的程序段，使生成的目标程序较短，从而减少了内存的开销并提高了程
    序的效率。
  6. 使用预处理功能便于程序的修改、阅读、移植和调试，也便于实现模块化程序设计

十、数组

数组可以存放多个同–类型数据。数组也是一种数据类型，是构造类型。传递是以引用的方式传递(即传递的
是地址)

1 快速入门

#include 

void main() {
	/*一个养鸡场有6只鸡，它们的体重分别是3kg, 5kg, 1kg,
		3.4kg, 2kg, 50kg 。请问这六只鸡的总体重是多少? 
		平均体重是多少 ? 请你编一一个程序。
	*/

	double arr[6];
	double total = 0.0;
	double avg = 0.0;
	int i, length;
	
	arr[0] = 3;
	arr[1] = 5;
	arr[2] = 1;
	arr[3] = 3.4;
	arr[4] = 2;
	arr[5] = 50;

	// 数组长度 = 数据的总字节 / 每个数据的字节
	length = sizeof(arr) / sizeof(double);
	for (i = 0; i < length; i++)
	{
		total += arr[i];
	}
	avg = total / length;
	printf("total=%.2f avg=%.2f", total, avg);
	getchar();
}

2 数据的定义和内存布局

①数据的定义

数据类型 数组名[数组大小];
inta[5]; //a 数组名，类型int,[5] 大小，即a数组最多存放5个int数据
赋初值a[0]= 1;a[1]= 30; …

②数据的内存分布

image-20210903102324822

说明：1.数组名就代表该数组的首地址，既a[0]的地址

​ 2.数组各个元素是连续分布的

​ 例：int类型的数组 -> a[0] 的地址为0x1233 ,那么a[1]的就是0x1233 + int的字节数 = 0x1237, a[2]的地址0x123B，后面以此类推。。。；是什么类型的数组后面就加对应的字节数

小案例

#include 

void main() {

	double arr[5];
	int i, length;
	length = sizeof(arr) / sizeof(double);
	for (i = 0; i < length; i++)
	{
		printf("\n 请输入你的分数");
		scanf("%lf", &arr[i]);	// 是l不是1
	}

	for (i = 0; i < length; i++)
	{
		// 输出成绩
		printf("%d=%.2f", i, arr[i]);
	}

	getchar();	// 过滤回车
	getchar();
}

③三种初始化数组的方式

// 第一种
int arr[2];
arr[0] = 200;
// 第二种
int arr2[3] = { 1, 2, 3 };
// 第三种
int arr3[] = { 5, 4, 6 };

3 数据使用注意事项和细节

  1. 数组是多个相同类型数据的组合，一个数组一-旦声明/定义了，其长度是固定的,不能动态变化。
  2. 数组创建后， 如果没有赋值，则遵守如下规则
    全局数组默认值0
    非全局数组初值是机器垃圾值(即:原来系统分配给这块空间的值)
  3. 使用 数组的步骤1. 定义数组2给数组各个元素赋值3使用数组，也可以一一步到位
  4. 数组的 下标是从0开始的，不是从1开始。
  5. 数组下标必须在指定范围内使用，编译通过，在运行时会因为数组越界而异常中断:
    比如intarr[5] 有效下标为0-4
  6. C的数组属构造类型，是引用传递(传递的是地址)，因此当把一个数组传递给–个函数时/或者变量，函数/变
    量操作数组会影响到原数组(因为传参的时候传过去的是指针，也就是地址)

4 数组应用案例

1)创建一个 char类型的26个元素的数组，分别放置’A’-Z‘。使用for循环访问所有元素并打印出来。提示:字符数据运算’A’+1 -> ‘B’

#include 

void main() {
	/*
		创建一个 char类型的26个元素的数组，分别放置'A' - Z‘。使用for循环访问所有元素并打印出来。
	    提示:字符数据运算'A' + 1 -> 'B'
	*/
	char arr[26];
	int i;
	for (i = 0; i < 26; i++)
	{
		arr[i] = 'A' + i;
	}
	for ( i = 0; i < 26; i++)
	{
		printf("%c ", arr[i]);
	}
	getchar();
}

2)请求出一个数组的最大值，并得到对应的下标。

#include 

void main() {
	// 请求出一个数组的最大值，并得到对应的下标。
	int arr[] = {2, 3, 456, 554, 34, 5464};
	int i, length, maxIndex;
	double max = arr[0];
	length = sizeof(arr) / sizeof(int);
	for (i = 1; i < length; i++)
	{
		if (arr[i] > max) {
			max = arr[i];
			maxIndex = i;
		}
	}
	printf("最大值为%.2f, 对应的下角标为%d", max, maxIndex);
	getchar();
}

5 字符数组与字符串

字符数组实际上是一系列字符的集合，也就是字符串(String) 。在C语言中，没有专门的字符串变量，没有
string类型，通常就用一个字符数组来存放-一个字符串

#include 

void main() {

	char str[] = "莫个超是靓仔";
	printf("str=%s", str);
	getchar();
}

本 次

1 字符数组注意事项

  1. 在C语言中，字符串实际上是使用null 字符(\0’) 终止的一维字符数组。因此，一个以null 结尾的字符串，
    包含了组成字符串的字符。
  2. ^\0’是 ASCII码表中的第0个字符，用NUL表示，称为空字符。该字符既不能显示，也不是控制字符，输出该
    字符不会有任何效果，它在C语言中仅作为字符串的结束标志。
  3. 字符数组(字符 串)在内存中的布局分析[案例]

C语言基础学习_第32张图片

说明："?"表示是不知道的东西，可能是垃圾值，也可能是其他的东西

结论如果在给某个字符数组赋值时，(1 )赋给的元素的个数小于该数组的长度，则会自动在后面加\0’, 表示
字符串结束，(2)赋给的元素的个数等于该数组的长度，则不会自动添加\O’
char str2[]= {‘t,m’,‘o’} 输出什么?输出的是tmo 乱码.

C语言基础学习_第33张图片

补充：

char str2[] = { 't', 'o', 'm' };	// 这个也是不会自动添加'/0'的

2 字符串的访问和遍历

因为字符串的本质就是字符数组，因此可以按照数组的方式遍历和访问某个元素

代码演示

#include 
#include 
#include 

void main() {
	char str[] = "hello";
	int i;
	int length = strlen(str);
	printf("str=%s", str);
	printf("\n str的长度是%d", length);
	printf("\n 字符串第三个字是%c", str[2]);
	// 遍历字符数组
	for ( i = 0; i < length; i++)
	{
		printf("\n %c", str[i]);
	}
	system("pause");
}

6 字符串的表现形式

① 用字符数组存放字符串

char str[] = "我是靓仔智";
char str2[] = {'h','e','l','l','o'}；

② 用字符指针指向一个字符串

  1. C语言对字符串常量"hellotom"是按字符数组处理的，在内存中开辟了一一个字符数组用来存放字符串常量，程
    序在定义字符串指针变量str时==只是把字符串首地址(即存放字符串的字符数组的首地址)赋给pStr==.

  2. printf("%s\n",str); 可以输出str 指向的字符串

  3. 对应的内存布局图(!!)

    C语言基础学习_第34张图片

③ 两种方法表示字符串的讨论

  1. 字符数组由若千个元素组成，每个元素放一一个字符;而字符指针变量中存放的是地址(字符串/字符数组的首地址)，绝不是将字符串放到字符指针变量中(是字符串首地址)[图]

  2. 对字符数组只能对各个元素赋值，不能用以下方法对字符数组赋值

    char str[5];
str = "hello";	// 错误
str[2] = 'i';	// 正确
system("pause");

    C语言基础学习_第35张图片

  3. 对字符指针变量，采用下面方法赋值，是可以的

    char* str = "我是靓仔智";
str = "世界和平，春暖花开";		// 指向一个新开的空间呗

  4. 如果定义了一个字符数组，那么它有确定的内存地址(即字符数组名是一个常量);而定义一个字符指针变量时,
    它并未指向某个确定的字符数据，并且可以多次赋值[代码+图解]

7 字符串相关函数

① 常用函数

C语言基础学习_第36张图片

② 字符串函数应用案例

#include 
#include 

void main() {
	char str[] = "hello";
	char str2[] = "world";
	char str3[] = "";
	strcpy(str3, str2);		// s2复制到s1
	printf("复制的是%s\n", str);
	strcat(str, str2);	// 追加
	printf("append为%s\n", str);
	int result = strcmp(str, str2);	// 判断两个字符串是否相同，相同返回0
	printf("result=%d\n", result);
	char* p = strchr(str, 'e');		// 要用指针类型接收，没有找到返回null
	printf("p=%s\n", p);
	char* p2 = strstr(str, "ll");	// 要用指针类型接收，没有找到返回null
	printf("p2=%s\n", p2);
	getchar();
}

8 字符串使用注意项和细节

  1. 程序中往往依靠检测\0’ 的位置来判定字符串是否结束，而不是根据数组的长度来决定字符串长度。因此，字
    符串长度不会统计"\0’, 字符数组长度会统计[案例]

    #include 
#include 

void main() {
	char str[] = "hello";
	int len = strlen(str);		// 这个输出的就是5
	int arrLen = sizeof(str);	// 数组输出就是6，因为还有一个'\0'
	printf("%d  %d", len, arrLen);	// 5	6
	getchar();
}

  2. 在定 义字符数组时应估计实际字符串长度，保证数组长度始终大于字符串实际长度，否则， 在输出字符数组
    时可能出现未知字符.

    image-20210904095856417

  3. 系 统对字符串常量也自动加一个\0’作为结束符。例如"C Program”共有9个字符，但在内存中占10个字节，
    最后一个字节\0’是系统自动加上的。( 通过sizeof()函数可验证)

  4. 定 义字符数组时，如果给的字符个数比数组的长度小，则系统会默认将剩余的元素空间，全部设置为’\0’, 比
    如char str[6] = “ab” , str内存布局就是 [a] [b] [\0] [\0] [\0] [\0]

字符数组练习

image-20210904100659937

9 多维数组 - 二维数组

数组里面放了个数组（套娃）

语法：类型 数组名[大小] [大小]

①快速入门

C语言基础学习_第37张图片

代码演示

#include 

void main() {
	int i, j;
	int arr[4][6];

	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 6; j++)
		{
			arr[i][j] = 0;
		}
	}

	arr[1][2] = 1;
	arr[2][1] = 2;
	arr[2][3] = 3;

	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 6; j++)
		{
			printf("%d", arr[i][j]);
		}
		printf("\n");
	}

	getchar();
}

②二维数组内存分布

#include 

void main() {
	int i, j;
	int arr[4][6];

	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 6; j++)
		{
			arr[i][j] = 0;
		}
	}
	printf("二维数组arr的首地址=%p\n", arr);
	printf("二维数组arr[0]的地址=%p\n", arr[0]);
	printf("二维数组arr[0][0]的地址=%p\n", &arr[0][0]);
	printf("二维数组arr[0][1]的地址=%p\n", &arr[0][1]);
	getchar();
}

说明：arr、arr[0]和&arr[0] [0]的地址是一样的，都是首地址

内存分析图

C语言基础学习_第38张图片

注意：他们并不是一行行分开的，而是连续的地址

③直接初始化数组

  1. 定义 类型 数组名[大小] [大小] = {{值1, 值2, 值3},{值1, 值2, 值3},{值1, 值2, 值3}}；
  2. 或者 类型 数组名[大小] [大小] = 值1,值2,值3,值4,值5,值…};

C语言基础学习_第39张图片

④二维数组练习

#include 

/*	
	定义二维数组，用于保存三个班，每个班三名同学成绩，
	并求出每个班级平均分、以及所有班级平均分
*/

void main() {
	int i, j;
	// 定义一个二维数组
	double score[3][3];
	// 行数 = 总字节数 / 每一行的字节数
	int rows = sizeof(score) / sizeof(score[0]);
	int cols = sizeof(score[0]) / sizeof(double);
	double totalScore = 0.0;	// 所有学生总成绩
	double avgScore = 0.0;		// 各班平均分

	// 初始化
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			score[i][j] = 0;	
		}
	}
	// 从键盘输入成绩
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			printf("请输入%d班第%d个学生的成绩：", i + 1, j + 1);
			scanf("%lf", &score[i][j]);
		}
	}
	printf("\n\n");
	// 打印所有学生的成绩
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			printf("%.2f ", score[i][j]);
		}
		printf("\n");
	}
	printf("\n\n");
	// 计算所有学生总分和各班平均分
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			totalScore += score[i][j];
			avgScore += score[i][j];
		}
		printf("%d班的平均分为：%.2f\n", i + 1, avgScore / 3);
		avgScore = 0.0;
	}
	printf("\n\n所有学生的总分：%.2f", totalScore);
	getchar();
	getchar();
}

⑤二维数组使用细节和注意事项

  1. 可以只对部分元素赋值，未赋值的元素自动取“零”值[案例]

    int main({
    int a[4][5]= {{1}, {2}, {3},{}};
    int ij;
    for(i=0;i<4;i++) {
    for(j=0;j<5;j++){
    printf("%d ",a[i][j]);
    }
    print("\n"); .
    getchar(;
}

  2. 如果对全部元素赋值，那么第一维的长度可以不给出。比如:

    int a[3][3]= {1,2,3,4,5,6, 7,8, 9};
可以写为:
inta[][3]= {1,2,3,4,5,6, 7,8, 9};

  3. 二维数组可以看作是由一维数组嵌套而成的;如果- - 个数组的每个元素又是-一个数组，那么它就是二维数组。

    二维数组a[3][4]可看成三个- -维数组，它们的数组名分别为a[0]、 a[1]、 a[2]。
这三个-维数组都有4个元素，如，一维数组 a[0] 的元素为a[0][0]、 a[0][1]、 a[0][2]、 a[0][3]

十一、排序和查找

1 冒泡排序

C语言基础学习_第40张图片

代码实现

#include 

// 冒泡排序函数
void bubbleSore(int arr[], int len) {
	int i, j, t;
	for (i = 0; i < len - 1; i++)
	{
		for (j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
	}
}

void main() {
	int arr[] = {65, 43, 75, 23, 100};
	
	int i, len;
	len = sizeof(arr) / sizeof(int);
	bubbleSore(arr, len);
	printf("排序后\n");
	for (i = 0; i < len; i++)
	{
		printf("%d\n", arr[i]);
	}
	getchar();
}

2 查找

①顺序查找

逐个比较

#include 

int searchSeq(int arr[], int length, int index) {
	int i;
	for (i = 0; i < length; i++)
	{
		if (arr[i] == index)
		{
			return arr[i];
		}
	}

}

void main() {
	int length;
	int arr[] = {2, 4, -2, 22, 90};
	length = sizeof(arr) / sizeof(int);
	int index = searchSeq(arr, length, 90);
	printf("index=%d", index);
	getchar();
}

②二分查找

前提：必须是有序数组

说明：从中间开始查找，大于中间的数就往右边查找，小于就往左边查

代码实现

#include 

// 二分法查找
int binarySearch(int arr[], int leftIndex, int rightIndex, int findVal) {
	int i;
	int midIndex = (leftIndex + rightIndex) / 2;	// 中间值的索引
	int midVal = arr[midIndex];						// 中间值
	if (midVal > findVal)	// 中间值大于要找的值，往左边找
	{
		for (i = midIndex - 1; i > leftIndex; i--)
		{
			if (arr[i] == findVal)
			{
				return i;
			}
		}
	}
	else if (midIndex < findVal) {	// 中间值小于要找的值，往右边找
		for (i = midIndex + 1; i < rightIndex; i++)
		{
			if (arr[i] == findVal)
			{
				return i;
			}
		}
	}
	else
	{
		return 0;	// 返回该数的下标
	}
}

void main() {
	int arr[] = { 2, 30, 34, 45, 90 };
	int arrLen = sizeof(arr) / sizeof(int);
	int index = binarySearch(arr, 0, arrLen, 90);
	if (index != 1) {
		printf("找到了，它的索引值是：%d", index);
	}
	else
	{
		printf("没有找到");
	}
	getchar();
}

十二、断点调试

C语言基础学习_第41张图片

十三、指针

1 指针的基本介绍

和java中的引用数据类型类似，指针就是一个可以操作对应地址的变量的东西

  1. 指针是C语言的精华，也是C语言的难点。
  2. 指针， 也就是内存的地址;所谓指针变量，也就是保存了内存地址的变量。关于指针的基本使用，在讲变量的
    时候做了入门级的介绍
  3. 获取 变量的地址，用&，比如:
    int num= 10,获取num的地址: &num
  4. 指针类型， 指针变量存的是一个地址，这个地址指向的空间存的才是值
    比如: intptr = # ptr 就是指向int 类型的指针变量，即ptr是int 类型。
  5. 获取指针类 型所指向的值，使用: (取值符号)， 比如: int ptr,使用*ptr 获取ptr指向的值

什么是指针

指针是一一个变量，其值为另一个变量的地址(前示意图已经说明)，即，内存位置的直接地址。就像其他变量或
常量一样，在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为:

int *ip;	/*一个整型的指针*/
double *dp;	/*一个double 型的指针*/
float *fp; 	/*一个浮点型的指针*/
char *ch;  	/*一个字符型的指针*/

C语言基础学习_第42张图片

2 指针的算数运算

指针是一个用数值表示的地址。可以对指针执行算术运算。可以对指针进行四种算术运算: ++、-、+. -。

就是对指针中的地址进行算数运算，以单位来计算的，是什么类型就是什么单位，比如int类型的指针就是一个单位4个字节

①指针递增操作（++）

代码演示

#include 

void main() {
	int i, length, *ptr;
	int val[] = {23, 53, 45};
	length = sizeof(val) / sizeof(int);
	ptr = val;
	for (i = 0; i < length; i++)
	{
		printf("val[%d] 地址=%p \n", i, ptr);
		printf("val[%d]=%d \n", i, *ptr);
		ptr++;	// ptr = ptr的地址值 + 一个单位(1个int类型的字节数)
	}
 	getchar();
}

内存示意图

C语言基础学习_第43张图片

②指针递减操作（–）

原理和++一样

#include 

void main() {
	int i, *ptr, length;
	int var[] = {23, 34, 54};
	length = sizeof(var) / sizeof(int);
	ptr = &var[length - 1];	// 指针指向最后一个值
	for ( i = length - 1; i >= 0; i--)
	{
		printf("val[%d] 地址=%p \n", i, ptr);
		printf("val[%d]=%d \n", i, *ptr);
		ptr--;	// ptr = ptr的地址值 - 一个单位(1个int类型的字节数)
	}
	getchar();
}

注意：指针接收的是地址，不是值

③指针+、-操作

和普通的类型，不过指针是以单位来计算的，单位也就是对应指针类型的字节数

#include 

void main() {
	int arr[] = {10, 30, 230};
	int i, * ptr;
	ptr = arr;
	ptr += 2;	// ptr的地址 + 2个int字节（8个字节）
	printf("arr[2]=%d var[2]的地址=%p\nptr存储的地址=%p ptr指向的值=%d", arr[2], &arr[2], ptr, *ptr);
	getchar();
}

④练习

#include 

// 指向第三个元素
void main() {
	int i, * ptr;
	int var[] = { 20, 30, 50 };
	ptr = &var[2];
	printf("ptr指向的值为%d, 地址为%p a[2]的地址为%p", *ptr, ptr, &var[2]);
	getchar();
}

3 指针的比较

指针存储地址的比较，可以使用关系运算符进行比较，类型要一致，一定是两个指针类型，同时还要是相同的类型

比如：int类型的指针要和int类型的指针比较

代码演示

#include 

void main() {
	int var[] = {10, 20, 30};
	int* ptr ;
	ptr = var;
	if (ptr == var)		// 可以
	{
		printf("ok1");	// 输出
	}
	//if (ptr == var[0]);	// 类型不同，不能比较，报错
	//{
	//	printf("\nok2");
	//}
	if (ptr == &var[0])		// 可以
	{
		printf("\nok3");	// 输出
	}
	if (ptr >= &var[1])		// 可以
	{
		printf("\nok4");	// 不输出，为false
	}

	getchar();
}

#include 

const int MAX = 3;
void main() {
	int var[] = { 10, 20, 300 };
	int i, * ptr;
	ptr = var;
	i = 0;
	while (ptr <= &var[MAX - 2])	// &var[1]
	{
		printf("Address of var[%d]=%x\n", i, ptr);
		printf("Value of var[%d]=%d\n", i, *ptr);
		ptr++;
		i++;
	}	// 输出10、20
	getchar();
}

4 指针数组

存放指针的数组呗

①指针数组的定义

数据类型 *指针数组名[大小];

  1. 比如：int *ptr[3];
  2. ptr声明为一个指针数组
  3. 由3个整数指针组成。因此，ptr中的每个元素，都是一个指向int类型值的指针

②快速入门和内存布局图

#include 

const int MAX = 3;
void main() {
	int i, *ptr[3];
	int arr[] = { 10, 20, 30 };
	// 将指针数组中的指针指向值
	for ( i = 0; i < MAX; i++)
	{
		ptr[i] = &arr[i];
	}
	// 遍历通过指针输出各个值
	for ( i = 0; i < MAX; i++)
	{
		printf("Value of arr[%d]= %d ptr[%d]本身的地址%p\n", i, *ptr[i], i, &ptr[i]);
	}
	getchar();
}

内存布局图

C语言基础学习_第44张图片

③应用实例

请编写程序，定义一个指向字符的指针数组来存储字符串列表(四大名著书名)，并通过遍历 该指针数组，显
示字符串信息，(即: 定义一个指针数组，该数组的每个元素，指向的是- -个字符串)

代码实现

#include 

void main() {
	/*	请编写程序，定义一个指向字符的指针数组来存储字符串列表(四大名著书名)，
		并通过遍历 该指针数组，显
		示字符串信息，(即: 定义一个指针数组，该数组的每个元素，指向的是 - -个字符串)
	*/
	int i;
	char* books[4] = {
		"三国演义",
		"红楼梦",
		"水浒传",
		"西游记"
	};

	for ( i = 0; i < 4; i++)
	{
		printf("\nbooks[%d]=%s 指向的地址是%p", i, books[i], &books[i]);
	}
	getchar();
}

5 指向指针的指针(多重指针)

就是套娃，指针里面存放这另外一个指针的地址，也就是相当于两个指针都可以操作那个数据，但是多级的麻烦一点

比如：二级指针存放的是一级的指针地址，一级指针存放的是对应变量的地址，二级指针要操作对应的变量要通过一级指针，然后一级指针来操作对应的变量

代码实现

#include 

void main() {
	int var;
	int *ptr;	// 一级指针
	int **pptr;	// 二级指针
	int ***ppptr;
	var = 8;
	ptr = &var;
	pptr = &ptr;
	ppptr = &pptr;

	printf("var的地址 %p var=%d\n", &var, var);
	printf("ptr 本身的地址=%p ptr存放的地址=%p *ptr=%d\n", &ptr, ptr, *ptr);
	printf("pptr 本身的地址=%p pptr存放的地址=%p **ptr=%d\n", &pptr, pptr, **pptr);
	printf("ppptr 本身的地址=%p ppptr存放的地址=%p **ppptr=%d\n", &ppptr, ppptr, ***ppptr);
	getchar();
}

内存示意图

C语言基础学习_第45张图片

6 传递指针(地址)给函数

①传地址或指针给指针变量

#include 

void test(int* p);	// 函数声明
void main() {
	int i, num = 90;
	int* p = &num;
	test(p);
	printf("main中的num=%d", num);		// 91
	test(p);
	printf("\nmain中的num=%d", num);		// 92
	getchar();
}
void test(int* p) {
	*p += 1;
}

内存示意图

C语言基础学习_第46张图片

② 传数组给指针变量

#include 

// 传入数组
double getAverage(int* arr, int size);	// 函数声明
double getAverage2(int* arr, int size);	// 函数声明
void main() {
	// 带有5个整数的整型数组
	int balance[5] = { 1000, 2, 34, 54, 332 };
	double avg;
    // 这两个函数的目的是一样的
	//avg = getAverage(balance, 5);
	avg = getAverage2(balance, 5);
	printf("\nAverage value is：%f\n", avg);
	getchar();
}

double getAverage(int* arr, int size) {
	int i, sum = 0;
	double avg;
	for ( i = 0; i < size; i++)
	{
		sum += arr[i];	// arr[0]
		printf("\n arr存放的地址=%p", arr);
	}
	avg = (double)sum / size;
	return avg;
}

double getAverage2(int* arr, int size) {
	int i, sum = 0;
	double avg;
	for ( i = 0; i < size; i++)
	{
		sum += *arr;
		printf("\narr存放的地址=%p", arr);
		arr++;
	}
	avg = (double)sum / size;
	return avg;
}

7 函数返回值为指针

C语言允许函数的返回值是-一个指针(地址)，这样的函数称为指针函数。返回值为指针呗

① 快速入门

代码实现

#include 
#include 

// 比较两个字符串长度的函数
char* strlong(char* str1, char* str2) {
	printf("\n str1的长度 %d str2的长度 %d", strlen(str1), strlen(str2));
	if (strlen(str1) >= strlen(str2))
	{
		return str1;
	}
	else {
		return str2;
	}
}

void main() {
	char str1[30], str2[30], * str;	// str是一个指针，指向字符串
	printf("\n 请输入第1个字符串");
	gets(str1);
	printf("\n 请输入第2个字符串");
	gets(str2);
	str = strlong(str1, str2);
	printf("\n Longer string:%s \n", str);
	getchar();
}

② 指针函数注意事项和细节

  1. 用指针作为函数返回值时需要注意，函数运行结束后会销毁在它内部定义的所有局部数据，包括局部变量、局
    部数组和形式参数，函数返回的指针不能指向这些数据[案例演示]
  2. 函数运行结束后会销毁该函数所有的局部数据，这里所谓的销毁并不是将局部数据所占用的内存全部清零，而
    是程序放弃对它的使用权限，后面的代码可以使用这块内存[案 例演示]
  3. C语言不支持在调用函数时返回局部变量的地址，如果确实有这样的需求，需要定义局部变量为static变量
    [案例演示]

案例演示

#include 

// 返回一个指针类型
int* fun() {
	//int n = 10;	// 局部变量，在func返回时，就会销毁，但是引用还是在的
	
	static int n = 10;	// static修饰的变量存放在静态数据区
	return &n;
}

void main() {
	int* p;
	p = fun();
	printf("得到的值为%d", *p);
	getchar();
}

③ 应用案例

编写一个函数，它会生成10个随机数，并使用表示指针的数组名(即第-一个数组元素的地址)来返回它们。

#include 
#include 

// 随意生成一个10个元素的数组返回
int* returnArr() {
	int i;
	static int arr[10];
	for ( i = 0; i < 10; i++)
	{
		arr[i] = rand();
	}
	return arr;
}

void main() {
	int i, *p;
	p = returnArr();
	for ( i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}

	getchar();
}

8 函数指针

① 基本介绍

  1. 一个函数总是占用一段连续的内存区域，函数名在表达式中有时也会被转换为该函数所在内存区域的首地址,
    这和数组名非常类似。
  2. 把函数的这个首 地址(或称入口地址)赋予-一个指针变量，使指针变量指向函数所在的内存区域，然后通过指
    针变量就可以找到并调用该函数。这种指针就是函数指针。

指向函数的指针

② 函数指针定义

returnType (*pointerName)(param list);

  1. returnType 为函数指针指向的函数返回值类型
  2. pointerName 为函数指针名称
  3. paramlist为函数指针指向的函数的参数列表
  4. 参数列表中可以同时给出参数的类型和名称，也可以只给出参数的类型，省略参数的名称
  5. 注意( )的优先级高于*，第-一个括号不能省略，如果写作returnType pointerName(param list);就成了函数原型，
    它表明函数的返回值类型为returnType

③ 应用案例

用函数指针来实现对函数的调用,返回两个整数中的最大值.

代码实现

#include 

int max(int x, int y) {
	return x > y ? x : y;
}

void main() {
	int x, y, maxVal;

	// 说明	函数指针
	// 1 该函数指针的名字 pmax
	// 2 int表示该函数指针的函数时返回int类型
	// 3 (int, int)表示该函数指向的函数形参时接收两个int
	// 4 在的定义函数指针时，也可以写上参数名 int (*pmax)(int x, int y) = max;
	// 也可以int (*pmax)(int x, int y)
	int (*pmax)(int, int) = max;
	printf("请输入两个数：");
	scanf("%d %d", &x, &y);
	maxVal = (*pmax)(x, y);
	printf("max value为：%d pmax的值为：%p pmax本身的地址为:%p", maxVal, pmax, &pmax);
	getchar();
	getchar();
}

9 函数回调

就是使用函数指针

  1. 函数指针变量可以作为某个函数的参数来使用的，回调函数就是-一个通过函数指针调用的函数。
  2. 简单的讲:回调函数是由别人的函数执行时调用你传入的函数(通过函数指针完成)

代码演示

/* 回调函数 */
#include 
#include 

// 初始化数组
void initArr(int *arr, int length, int (*r)()) {	// 也可以这样int r()
	int i;
	for ( i = 0; i < length; i++)
	{
		// 也可以写成 arr[i] = (*r)();
		arr[i] = r();
	}
}

// 随机生成一个数字返回
int getRand() {
	return rand();
}

void main() {
	int i, arr[10];
	// 函数名就是它的地址
	initArr(arr, 10, getRand);

	for ( i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	getchar();
}

10 指针的注意事项和细节

  1. 指针变量存放的是地址，从这个角度看指针的本质就是地址。
  2. 变量声明的时候，如果没有确切的地址赋值，为指针变量赋-一个NULL值是好的编程习惯。
  3. 赋为NULL值的指针被称为空指针，NULL指针是一个定义在标准库中 的值为零的常量#define
    NULL 0 [案例]
  4. 指针使用一览(见后)

代码演示

#include 

void main() {
	int* p = NULL;	// p是空指针
	int i = 32;
	p = &i;
	printf("%d", *p);
	getchar();
}

11 动态内存分配

  1. 全局变量一一内存中的静态存储区
  2. 非静态的局部变量一—内存中的动态存储区一–stack栈
  3. 临时使用的数据–建立动态内存分配区域，需要时随时开辟，不需要时及时释放一–heap堆
  4. 根据需要向系统申请所需大小的空间，由于未在声明部分定义其为变量或者数组，不能通过变量名或者数组名
    来引用这些数据，只能通过指针来引用)

C语言基础学习_第47张图片

① 动态内存分配的相关函数

头文件#include 声明了四个关于内存动态分配的函数中。

  1. void* malloc(usigned int size)

    在内存的动态存储区（堆区）中分配一个长度为size的连续空间，返回值为所分配空间的第一个字节的地址

    eg：malloc(100); 开辟了100字节的临时空间，返回值为其第一个字节的地址

  2. void *calloc(unsigned n, unsigned size)

    在堆中分配n个长度为size的连续空间，一般用来存储数组，分配不成功，返回NULL

    eg：p = calloc(50,4); // 开辟50 * 4 个字节临时空间，把起始地址分配给指针变量p

  3. void free(void* p)

    释放变量p指向的动态空间

  4. void *realloc(void *p, unsigned int size)

    重新分配malloc或calloc函数获得的动态空间大小，将p指向的动态空间大小改变为size，p的值不变，分配失败返回NULL

    eg：realloc(p, 50); // 将p所指向的已分配的动态空间改为50字节

  5. void指针类型

    不指向具体的类型数据，只是提供一个纯地址，不指向任何具体的对象，就是存放地址的指针呗

    C语言基础学习_第48张图片

    说明：当吧void指针赋给不同类型的指针变量（或相反时），编译系统会自动进行转换

    image-20210912105736901

② 应用案例

动态创建数组，输入5个学生的成绩，另外一个函数检测成绩低于60分的，输出不合格的成绩。

代码演示

#include 
#include 

void cheek(int*);	// 函数声明
void main() {
	int i, *p;
	// 堆区中开辟一个5 * 4的空间，并将地址(void*)转成(int*)赋给p
	p = (int*)malloc(5 * sizeof(int));	// 也可以写成malloc(5 * sizeof(int))
	for ( i = 0; i < 5; i++)
	{
		scanf("%d", p + i);
	}
	cheek(p);
	free(p);	// 销毁堆区中p指向的空间
	getchar();
	getchar();
}
void cheek(int* p) {
	int i;
	printf("\n不及格成绩的有:");
	for ( i = 0; i < 5; i++)
	{
		if (p[i] < 60)
			printf("%d\t", p[i]);
	}
}

内存示意图

C语言基础学习_第49张图片

③动态分配内存的基本原则

  1. 避免分配大量的小内存块。 分配堆上的内存有一些系统开销，所以分配许多小的内存块比分配几个大内存块的
    系统开销大

  2. 仅在需要时分配内存。只要使用完堆上的内存块，就需要及时释放它(如果使用动态分配内存，需要遵守原则:
    谁分配，谁释放)，否 则可能出现内存泄漏

  3. 总是确保释放以分配的内存。在编写分配内存的代码时，就要确定在代码的什么地方释放内存

  4. 在释放内存之前， 确保不会无意中覆盖堆上已分配的内存地址，否则程序就会出现内存泄漏。在循环中分配内
    存时，要特别小心

  5. 指针使用- -览

    C语言基础学习_第50张图片

十四、结构体和共用体

结构体

结构体类似java的类

1 快速入门

#include 

void main() {
/*	张老太养了两只猫猫:
	一只名字叫小白，今年3岁, 白色。
	还有一只叫小花,今年100岁, 花色。
	请编写一个程序输出猫的名字，年龄，颜色。
*/
	struct Cat
	{
		char* name;	// 名字
		int age;	// 年龄
		char* color;// 颜色
	};
	// 使用结构体创建变量
	struct Cat cat1;	// 就是struct Cat的一个变量
	struct Cat cat2;
	// 给cat1的各个成员赋值
	cat1.name = "小白";
	cat1.age = 3;
	cat1.color = "白色";

	// 给cat2的各个成员赋值
	cat2.name = "小花";
	cat2.age = 100;
	cat2.color = "花色";

	// 输出两只猫的信息
	printf("第一只猫 name=%s age=%d coloe=%s", cat1.name, cat1.age, cat1.color);
	printf("\n 第二只猫 name=%s age=%d coloe=%s", cat2.name, cat2.age, cat2.color);
	getchar();
}

2 内存布局

C语言基础学习_第51张图片

3 创建结构体和结构体变量

struct 结构体名称 { //结构体名首字母大写，比如Cat, Person
	成员列表;
};

①方式1-先定义结构体，然后再创建结构体变量

这个在快速入门使用过，这里不演示

②方式2-在定义结构体的同时定义结构体变量

struct Stu
{
    char* naem;
    int age;
} stu1, stu2;

③方式3-匿名结构体

// 这种声明方式只能有stu1和stu2两个结构体变量，想声明也没法声明了
struct
{
    char* naem;
    int age;
} stu1, stu2;

4 成员

  1. 从叫法上看:有些书上称为成员,有些书说结构体包含的变量
  2. 成员是结构体的一个组成部分，- -般是基本数据类型、也可以是数组、指针、结构体等。比如我们前面定义
    Cat结构体的intage就是一个成员。
  3. 成员的类型可以是：基本类型、数组、指针或结构体等等

注意事项

  1. 创建一个结构体变量后，要对成员进行赋值，如果没有赋值的话会导致程序异常终止
  2. 不同的结构体变量的成员是独立的，互相不影响，和java中从新new一个是一样的，两者互不影响

成员的获取和赋值

通过结构体变量名.成员名

5 结构应用案例

盒子案例

编程创建一个Box结构体，在其中定义三个成员表示一个立方体的长、宽和高，长宽高可以通过控制台输入。.
定义一个函数获取立方体的体积(volume)。
创建- - 个结构体，打印给定尺寸的立方体的体积。

代码实现

#include 

// 打印给定尺寸的立方体的体积
struct Box
{
	double width;	// 宽
	double height;	// 高
	double chang;	// 长
};

/*
	获取立方体的体积
*/
double getVolume(struct Box *box) {
	return (*box).chang* (*box).width* (*box).height;
}

void main() {
	struct Box box;
	scanf("%lf", &box.height);
	scanf("%lf", &box.width);
	scanf("%lf", &box.chang);
	double volume = getVolume(&box);
	printf("体积为：%.2f", volume);
	getchar();
	getchar();
}

景区门票案例

  1. 一个景区根据游人的年龄收取不同价格的门票。
  2. 请编写游人结构体(Visitor)，根据年龄段决定能够购买的门票价格并输出
  3. 规则:年龄>18,门票为20元，其它情况免费。
  4. 可以循环从控制台输入 名字和年龄，打印门票收费情况，如果名字输入n，则退出程序。

代码实现

#include 
#include 

/*
	1) 一个景区根据游人的年龄收取不同价格的门票。
	2) 请编写游人结构体(Visitor)，根据年龄段决定能够购买的门票价格并输出
	3) 规则:年龄>18,门票为20元，其它情况免费。
	4) 可以循环从控制台输入 名字和年龄，打印门票收费情况，如果名字输入n，则退出程序。
*/
struct Visitor {
	char name[20];
	int age;
	double pay;	// 票价
};

void ticket(struct Visitor *visitor) {
	if ((*visitor).age > 18)
	{
		(*visitor).pay = 20;
	}
	else {
		(*visitor).pay = 0;
	}
}

void main() {
	// 声明一个结构体变量
	struct Visitor visitor;
	while (1)
	{
		printf("\n请输入一个你的名字：");
		scanf("%s", visitor.name);
		if (!strcmp("n", visitor.name))
		{
			break;	// 程序结束
		}
		printf("\n请输入一个你的年龄：");
		scanf("%d", &visitor.age);
		ticket(&visitor);
		printf("\n该游客的票价为：%.2f", visitor.pay);
	}
	printf("程序结束");
	getchar();
	getchar();
}

共用体

1 为什么需要结构体

现有一张关于学生信息和教师信息的表格。学生信息包括姓名、编号、性别、职业、分数，教师的信息包括姓
名、编号、性别、职业、教学科目。请看下面的表格:

C语言基础学习_第52张图片

传统方式来解决

定义结构体，根据人员的职业，使用对应的成员变量

问题：造成空间的浪费

解决方案

① 分别定义学生和老师的结构体，但是这种方式不利管理

② 使用共用体

2 基本介绍

共同使用同一块内存，也就是说指向同一个地址，一个变量的值发生了变化，其他值也要发生变化，但是不同的类型大小不同，所以按最大的来开辟空间，不同的类型输出的值也是不一定相同的

例如：int、short、char三种类型，那么这个共同体的占用大小就是4个字节

  1. 共用体(Union) 属于构造类型，它可以包含多个类型不同的成员。和结构体非常类似,但是也有不同的地方.
    共用体有时也被称为联合或者联合体

  2. 声明

union 共用体名{	// 也可以使用匿名共用体
	成员列表
};
  1. 结构体和共用体的区别在于:结构体的各个成员会占用不同的内存，互相之间没有影响;而共用体的所有成员
    占用同一段内存，修改一个成员会影响其余所有成员

3 快速入门和内存布局

快速入门

#include 

union Data
{
	int n;
	char ch;
	short m;
};

void main() {
	union Data a;	// 定义共用体变量a
	printf("%d,%d\n", sizeof(a), sizeof(union Data));	// 4,4
	a.n = 0x40;
	printf("%d, %c, %d\n", a.n, a.ch, a.m); // 64 @ 64
	a.ch = '9';
	printf("%d, %c, %d\n", a.n, a.ch, a.m);	// 57 9 57
	a.m = 0x2059;
	printf("%d, %c, %d\n", a.n, a.ch, a.m);	// 8281 Y 8281
	a.n = 0x3E25AD54;
	printf("%d, %c, %d\n", a.n, a.ch, a.m);	// 1042656596, T, -21164
    printf("内存分布%p,%p,%p", &a.n, &a.ch, &a.m);	// 三个变量指向同一块内存
	getchar();
}

内存布局

C语言基础学习_第53张图片

注意：虽然是4个字节，但是short是2个字节，所以，它只能是输出前面两个字节的数据，char也是只能输出1个字节的数据，所以数据类型的大小决定能输出什么样的值

4 最佳实践

现有一张关于学生信息和教师信息的表格。学生信息包括姓名、编号、性别、职业、分数，教师的信息包括姓
名、编号、性别、职业、教学科目。请看下面的表格:

C语言基础学习_第54张图片

代码实现

#include 

struct Person
{
	char name[20];
	int num;
	char sex;
	char profession;
	union {
		float score;	// 成绩	
		char course[20];	// 科目
	} sc;
};

void main() {
	int i;
	// 定义一个结构体数组
	struct Person persons[2];
	for ( i = 0; i < 2; i++)
	{
		printf("Input Info");
		scanf("%s %d %c %c", persons[i].name, &(persons[i].num), &(persons[i].sex), &(persons[i].profession));
		if ('s' == persons[i].profession)
		{
			printf("请输入该学生的成绩：");
			scanf("%f", &(persons[i].sc.score));
		}
		else
		{
			printf("请输入该老师课程：");
			scanf("%s", persons[i].sc.course);
		}
		fflush(stdin);
	}
	printf("nName\t\tNum\tSex\tProfession\tScore/ Course\n");
	for (i = 0; i < 2; i++) {
		if (persons[i].profession == 's') {  //如果 是学生
			printf("%s\t\t%d\t%c\t%c\t\t%f\n", persons[i].name, persons[i].num, persons[i].sex, persons[i].profession, persons[i].sc.score);
		}
		else { //如果 是老师
			printf("%s\t\t%d\t%c\t%c\t\t%s\n", persons[i].name, persons[i].num, persons[i].sex, persons[i].profession, persons[i].sc.course);
		}
	}
	getchar();
	getchar();
}

十五、文件操作

1 基本介绍

文件，对我们并不陌生，文件是数据源(保存数据的地方)的一种，比如大家经常使用的word文档,txt文件,excel文件…都是文件。文件最主要的作用就是保存数据,它既可以保存- -张图片，也可以保持视频,声音…

文件在程序中以流的形式来操作的

C语言基础学习_第55张图片

相关函数在stdio.h

2 标准文件

  1. C语言把所有的设备都当作文件。所以设备(比如显示器)被处理的方式与文件相同。以下三个文件会在程序
    执行时自动打开，以便访问键盘和屏幕
  2. 文件指针是访问文件的方式
  3. C语言中的I/O (输入/输出)通常使用printf() 和scanf() 两个函数。scanf() 函数用于从标准输入(键盘)读取并格式化，printf() 函数发送格式化输出到标准输出(屏幕)

3 getchar()和putchar函数

  • int getchar(void)

    函数从屏幕读取下一一个可用的字符，并把它返回为一一个整数。这个函数在同一个时间内一次只能读一个。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。

  • int putchar(int c)

    函数把字符输出到屏幕上，并返回相同的字符。这个函数在同-一个时间内只会输出一个单- -的字符。您可以在循环内使用这个方法，以便在屏幕上输出多个字符

代码演示

#include 

void main() {
	int c;
	printf("Enter a value");
	c = getchar();	// 从键盘上读取一个键，并返回该键的键值

	printf("\nYou entered");
	putchar(c);		// 字符输出在屏幕的当前位置。
	printf("\n");
	getchar();
}

4 gets()&puts函数

  1. char gets(chars) 函数从stdin 读取一行到s所指向的缓冲区，直到一个终止符或EOF。所以它是可以读取多个字符的
  2. **int puts(const char *s)**函数把字符串s和一个尾随的换行符写入到stdout。
#include 

void main() {
	char str[100];
	printf("Enter a value");
	gets(str);

	printf("\nYou entered");
	puts(str);
	getchar();
}

5 文件读写

  1. 讲解了C语言处理的标准输入和输出设备。我们将介绍如何创建、打开、关闭文本文件或二进制文件。
  2. 一个文件,无论它是文本文件还是二进制文件,都是代表了一.系列的字节。C语言不仅提供了访问顶层的函数，
    也提供了底层(OS)调用来处理存储设备.上的文件。

①打开文件

使用fopen( )函数来创建- - 个新的文件或者打开-一个已有的文件，这个调用会初始化类型FILE的-一个对象，
类型FILE包含了所有用来控制流的必要的信息。下面是这个函数调用的原型:
*FILE fopen( const char * filename, const char * mode );

  1. 说明:在这里，filename 是字符串，用来命名文件，访问模式mode的值可以是下列值中的-一个

  2. 如 果处理的是二进制文件(图片，视频.)，则需使用下面的访问模式: “rb”, “wb”, “ab”, “rb+”, “r+b”, “wb+”, “w+b”,
    “ab+”, “a+b” //b :binary二 进制

  3. 函数的说明

    C语言基础学习_第56张图片

②关闭文件

关闭文件，使用fclose() 函数。函数的原型如下:
*int fclose( FILE fp );

  1. 如果成功关闭文件，fclose( )函数返回零，如果关闭文件时发生错误，函数返回EOF。这个函数实际上，会清
    空缓冲区中的数据，关闭文件，并释放用于该文件的所有内存。EOF是一个定义在头文件stdio.h中的常量。
  2. C标准库提供了各种函数来按字符或者以固定长度字符串的形式读写文件。
  3. 使用 完文件后(读，写)，一定要将该文件关闭

③写入文件

下面是把字符写入到流中的函数
*int fputc( intc, FILE fip );
说明:函数fputc()把参数c的字符值写入到fp所指向的输出流中。如果写入成功，它会返回写入的字符，如果发生错误，则会返回EOF。您可以使用下面的函数来把-一个以null 结尾的字符串写入到流中:
int fjputs( const char s, FILE fp );
说明:函数fiputs(把字符串s写入到fp所指向的输出流中。如果写入成功，它会返回一个非负值，如果发生.错误，则会返回EOF。您也可以使用int fprintf(FILE *fp,const char *format, …)**函数来写把一个字符串写入到文件中

代码演示

#include 
// 读取文件

void main() {
	// 1 创建一个文件指针
	FILE* f = NULL;

	// 2 打开文件
	f = fopen("D:\\test.txt", "w+");	// 文件会被清空
	//f = fopen("D:\\test.txt", "w+");	// 追加到原有文件的内容的后面

	// 3 将内容写入到文件中
	fprintf(f, "hello workld2");
	//fputc("helloworld2", f);

	// 4 关闭文件
	fclose(f);
	getchar();
}

④读取文件

下面是从文件读取单个字符的函数
int fgetc( FILE * fp );
说明: fgetc( 函数从fip 所指向的输入文件中读取一个字符。返回值是读取的字符，如果发生错误则返回EOF。

下面的函数从流中读取-一个字符串:
**char *fgets( char buf, int n, FILE fp );

  1. 说明: 函数fgets() 从fp所指向的输入流中读取n- 1个字符。它会把读取的字符串复制到缓冲区buf,并在最后追加一个null字符来终止字符串。如果这个函数在读取最后-一个字符之 前就遇到-一个换行符\n’ 或文件的末尾EOF, 则只会返回读取到的字符，包括换行符。
  2. 也 可以使用**int fscanf(FILE *fp, const char *format, …)**函数来从文件中读取字符串，但是在遇到第一个空格字符
    时，它会停止读取。

代码演示

#include 

void main() {
	// 1 定义一个文件指针
	FILE* f = NULL;
	// 2 定义一个缓冲区
	char buff[1024];
		// 3 打开文件
	f = fopen("d:\\test2.txt", "r");
	// 4 读取文件
	// 方式一 --> 遇到空格就会停止读取
	fscanf(f, "%s", buff);
	printf("%s\n", buff);
	// 方式二 --> 读取整个文件的内容
	while (fgets(buff, 1024, f) != NULL)
	{
		printf("%s", buff);
	}

	// 5 关闭文件
	fclose(f);
	getchar();
}

十六、项目实战

[20]; // 科目
} sc;
};

void main() {
int i;
// 定义一个结构体数组
struct Person persons[2];
for ( i = 0; i < 2; i++)
{
printf(“Input Info”);
scanf("%s %d %c %c", persons[i].name, &(persons[i].num), &(persons[i].sex), &(persons[i].profession));
if (‘s’ == persons[i].profession)
{
printf(“请输入该学生的成绩：”);
scanf("%f", &(persons[i].sc.score));
}
else
{
printf(“请输入该老师课程：”);
scanf("%s", persons[i].sc.course);
}
fflush(stdin);
}
printf(“nName\t\tNum\tSex\tProfession\tScore/ Course\n”);
for (i = 0; i < 2; i++) {
if (persons[i].profession == ‘s’) { //如果 是学生
printf("%s\t\t%d\t%c\t%c\t\t%f\n", persons[i].name, persons[i].num, persons[i].sex, persons[i].profession, persons[i].sc.score);
}
else { //如果 是老师
printf("%s\t\t%d\t%c\t%c\t\t%s\n", persons[i].name, persons[i].num, persons[i].sex, persons[i].profession, persons[i].sc.course);
}
}
getchar();
getchar();
}




# 十五、文件操作

## 1	基本介绍

文件，对我们并不陌生，文件是数据源(保存数据的地方)的一种，比如大家经常使用的word文档,txt文件,excel文件...都是文件。文件最主要的作用就是保存数据,它既可以保存- -张图片，也可以保持视频,声音..



**文件在程序中以流的形式来操作的**

[外链图片转存中...(img-06MAnqxx-1632406293773)]



**相关函数在stdio.h**





## 2	标准文件

1) C语言把所有的设备都当作文件。所以设备(比如显示器)被处理的方式与文件相同。以下三个文件会在程序
    执行时自动打开，以便访问键盘和屏幕
2) 文件指针是访问文件的方式
3) C语言中的I/O (输入/输出)通常使用printf() 和scanf() 两个函数。scanf() 函数用于从标准输入(键盘)读取并格式化，printf() 函数发送格式化输出到标准输出(屏幕)



## 3	getchar()和putchar函数

-   **int getchar(void)**
    
    函数从屏幕读取下一一个可用的字符，并把它返回为一一个整数。这个函数在同一个时间内一次只能读一个。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。
    
-   **int putchar(int c)**

    函数把字符输出到屏幕上，并返回相同的字符。这个函数在同-一个时间内只会输出一个单- -的字符。您可以在循环内使用这个方法，以便在屏幕上输出多个字符

**代码演示**

```c
#include 

void main() {
	int c;
	printf("Enter a value");
	c = getchar();	// 从键盘上读取一个键，并返回该键的键值

	printf("\nYou entered");
	putchar(c);		// 字符输出在屏幕的当前位置。
	printf("\n");
	getchar();
}

4 gets()&puts函数

  1. char gets(chars) 函数从stdin 读取一行到s所指向的缓冲区，直到一个终止符或EOF。所以它是可以读取多个字符的
  2. **int puts(const char *s)**函数把字符串s和一个尾随的换行符写入到stdout。
#include 

void main() {
	char str[100];
	printf("Enter a value");
	gets(str);

	printf("\nYou entered");
	puts(str);
	getchar();
}

5 文件读写

  1. 讲解了C语言处理的标准输入和输出设备。我们将介绍如何创建、打开、关闭文本文件或二进制文件。
  2. 一个文件,无论它是文本文件还是二进制文件,都是代表了一.系列的字节。C语言不仅提供了访问顶层的函数，
    也提供了底层(OS)调用来处理存储设备.上的文件。

①打开文件

使用fopen( )函数来创建- - 个新的文件或者打开-一个已有的文件，这个调用会初始化类型FILE的-一个对象，
类型FILE包含了所有用来控制流的必要的信息。下面是这个函数调用的原型:
*FILE fopen( const char * filename, const char * mode );

  1. 说明:在这里，filename 是字符串，用来命名文件，访问模式mode的值可以是下列值中的-一个

  2. 如 果处理的是二进制文件(图片，视频.)，则需使用下面的访问模式: “rb”, “wb”, “ab”, “rb+”, “r+b”, “wb+”, “w+b”,
    “ab+”, “a+b” //b :binary二 进制

  3. 函数的说明

    [外链图片转存中…(img-pvFfC5gV-1632406293774)]

②关闭文件

关闭文件，使用fclose() 函数。函数的原型如下:
*int fclose( FILE fp );

  1. 如果成功关闭文件，fclose( )函数返回零，如果关闭文件时发生错误，函数返回EOF。这个函数实际上，会清
    空缓冲区中的数据，关闭文件，并释放用于该文件的所有内存。EOF是一个定义在头文件stdio.h中的常量。
  2. C标准库提供了各种函数来按字符或者以固定长度字符串的形式读写文件。
  3. 使用 完文件后(读，写)，一定要将该文件关闭

③写入文件

下面是把字符写入到流中的函数
*int fputc( intc, FILE fip );
说明:函数fputc()把参数c的字符值写入到fp所指向的输出流中。如果写入成功，它会返回写入的字符，如果发生错误，则会返回EOF。您可以使用下面的函数来把-一个以null 结尾的字符串写入到流中:
int fjputs( const char s, FILE fp );
说明:函数fiputs(把字符串s写入到fp所指向的输出流中。如果写入成功，它会返回一个非负值，如果发生.错误，则会返回EOF。您也可以使用int fprintf(FILE *fp,const char *format, …)**函数来写把一个字符串写入到文件中

代码演示

#include 
// 读取文件

void main() {
	// 1 创建一个文件指针
	FILE* f = NULL;

	// 2 打开文件
	f = fopen("D:\\test.txt", "w+");	// 文件会被清空
	//f = fopen("D:\\test.txt", "w+");	// 追加到原有文件的内容的后面

	// 3 将内容写入到文件中
	fprintf(f, "hello workld2");
	//fputc("helloworld2", f);

	// 4 关闭文件
	fclose(f);
	getchar();
}

④读取文件

下面是从文件读取单个字符的函数
int fgetc( FILE * fp );
说明: fgetc( 函数从fip 所指向的输入文件中读取一个字符。返回值是读取的字符，如果发生错误则返回EOF。

下面的函数从流中读取-一个字符串:
**char *fgets( char buf, int n, FILE fp );

  1. 说明: 函数fgets() 从fp所指向的输入流中读取n- 1个字符。它会把读取的字符串复制到缓冲区buf,并在最后追加一个null字符来终止字符串。如果这个函数在读取最后-一个字符之 前就遇到-一个换行符\n’ 或文件的末尾EOF, 则只会返回读取到的字符，包括换行符。
  2. 也 可以使用**int fscanf(FILE *fp, const char *format, …)**函数来从文件中读取字符串，但是在遇到第一个空格字符
    时，它会停止读取。

代码演示

#include 

void main() {
	// 1 定义一个文件指针
	FILE* f = NULL;
	// 2 定义一个缓冲区
	char buff[1024];
		// 3 打开文件
	f = fopen("d:\\test2.txt", "r");
	// 4 读取文件
	// 方式一 --> 遇到空格就会停止读取
	fscanf(f, "%s", buff);
	printf("%s\n", buff);
	// 方式二 --> 读取整个文件的内容
	while (fgets(buff, 1024, f) != NULL)
	{
		printf("%s", buff);
	}

	// 5 关闭文件
	fclose(f);
	getchar();
}

十六、项目实战

部分资料来自尚硅谷，如有侵权请联系删除

你可能感兴趣的:(C语言学习,c语言,c++)

  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS算法数据结构c++
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • C语言 判断回文数 Y雨何时停T c语言学习
    一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • C语言代码练习（第十九天） 小小框架 C语言C语言重点练习c语言
    今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码） mmz1207 c++csp
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • 20个新手学习c++必会的程序 输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
    示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】 汉子萌萌哒 CCFnoi算法数据结构c++
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南c++数据结构stl
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • c++ opencv4.3 sift匹配 图像处理大大大大大牛啊 图像处理opencv实战代码讲解opencvsiftc++opencv4特征点
    c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南C++修炼全景指南c++list链表stl
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
  • c++ 内存处理函数 heeheeai c++开发语言
    在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
  • 【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】 XWWW668899 C++基本概念c++c语言开发语言青少年编程
    文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • C语言---程序设计练习题目及学习方法1 Wanyu677 C语言c语言学习方法算法
    学习方法要多练习在这些题目中的代码和题目自己动手去敲练习也是在熟悉语法，写代码第一步就是熟悉语法练习是在锻炼编程思维，把实际问题转换为代码的能力学会画图画图去理解内存，理解指针这些比较难懂的知识画图可以更好的理清思路辅助理解，强化理解学会调试借助调试，更好的理解代码和感知代码找出代码中的bug和程序逻辑（1）自增自减运算符inta=5,b,c,i=10;b=a++;c=++b;printf("a=
  • metaRTC5.0 API编程指南(一) metaRTC metaRTCc++c语言webrtc
    概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
  • sublime个人设置 bawangtianzun sublimetext编辑器
    如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
  • 【C语言】- 自定义类型：结构体、枚举、联合 Cavalier_01 C语言
    【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
  • Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗 源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
  • python可以制作大型游戏_python能做游戏吗-python能开发游戏吗 靖dede python可以制作大型游戏
    python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
  • rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
     这是我自己想到的问题，结果去知呼提问，还没等别人回答， 我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
  • java编程思想 -- 数据的初始化 百合不是茶 java数据的初始化
      1.使用构造器确保数据初始化      /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
  • [航天与宇宙]为什么发射和回收航天器有档期 comsci
           地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁...        所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
  • linux下批量替换文件内容 商人shang linux替换
    1、网络上现成的资料 　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串 　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
  • 网页在线天气预报 oloz 天气预报
    网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
  • SpringMVC和Struts2比较 杨白白 springMVC
    1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。 参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
  • refuse copy, lazy girl! 小桔子 copy
           妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！  
  • apache与php整合 aichenglong php apache web
    一  apache web服务器 1 apeche web服务器的安装   1)下载Apache web服务器   2)配置域名(如果需要使用要在DNS上注册)   3)测试安装访问http://localhost/验证是否安装成功 2 apache管理   1)service.msc进行图形化管理   2)命令管理，配
  • Maven常用内置变量 AILIKES maven
    Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
  • java的类和对象 百合不是茶 JAVA面向对象 类 对象
    java中的类：     java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决   java使用 class 类名   来创建类 ，在Java中类名要求和构造方法，Java的文件名是一样的   创建一个A类： class A{ }   java中的类：将某两个事物有联系的属性包装在一个类中，再通
  • JS控制页面输入框为只读 bijian1013 JavaScript
    在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。  
  • AngularJS与服务器交互 bijian1013 JavaScriptAngularJS$http
            对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
  • [Maven学习笔记八]Maven常用插件应用 bit1129 maven
    常用插件及其用法位于：http://maven.apache.org/plugins/   1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin           1. Jetty Pl
  • 【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
    1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括： 文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
  • 杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
    nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
  • UI设计中我们为什么需要设计动效 brotherlamp UIui教程ui视频ui资料ui自学
    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。 但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。 一、加强体验舒适度 嗯，就是让用户更加爽更加爽的用你的产品。
  • Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan javaspring
    参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
  • 数据库连接池的工作原理 chicony 数据库连接池
           随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动 态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查 询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
  • java 关键字 CrazyMizzz java
    关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：    （1）访问修饰符       public,private,protected       p
  • Hive中的排序语法 daizj 排序hiveorder byDISTRIBUTE BYsort by
    Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。 与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
  • 单态设计模式 dcj3sjt126com 设计模式
      单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{    // 保存类实例在此属性中    private static&
  • svn locked dcj3sjt126com Lock
    post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
  • ARM寄存器学习 e200702084 数据结构C++cC#F#
    无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。     ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）     不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
  • 常用编码资料 gengzg 编码
    List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
  • 进程 vs. 线程 hongtoushizi 线程linux进程
    我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。 首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。 如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。 如果用多线程实现
  • Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linuxcrontab
    一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来： 第一段 代表分钟 0—59 第二段 代表小时 0—23 第三段 代表日期 1—31 第四段 代表月份 1—12 第五段 代表星期几，0代表星期日 0—6   如： */1 * * * *   每分钟执行一次。 *
  • KMP算法详解 hm4123660 数据结构C++算法字符串KMP
         字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。       假设主串s="ababcabcacbab",模式串为t="
  • 枚举类型的单例模式 zhb8015 单例模式
    E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
  • Kafka+Storm+HDFS ssydxa219 storm
    cd /myhome/usr/stormbin/storm nimbus &amp;bin/storm supervisor &amp;bin/storm ui &amp;Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
  • Java获取本地服务器的IP 中华好儿孙 javaWeb获取服务器ip地址
    System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他