C++学习笔记

IRUIRUI__

已于 2023-02-16 00:13:10 修改

阅读量170

点赞数

分类专栏： C++ 文章标签： c++ 学习开发语言

于 2023-02-03 10:11:18 首次发布

本文链接：https://blog.csdn.net/weixin_43342667/article/details/128855193

版权

C++ 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Chapt1 常量与变量：

1.1 常量的定义：

	1.宏常量：#define 常量名 常量值

	2.const 数据类型 常量名 = 常量值

1.2 关键字

	（具体有什么慢慢查，蛮多的）

1.3 标识符命名规则

	1.作用:C++规定给标识符（变量、常量)命名时，有一套自己的规则

	2.标识符不能是关键字

	3.标识符只能由字母、数字、下划线组成第一个字符必须为字母或下划线

	4.标识符中字母区分大小写

	（建议:给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读）

Chapt2 数据类型：

【C++ 规定在创建一个变量或者常量时，必须要指定相应的数据类型，否则无法给变量分配内存】

2.1 整数：

	作用：整型变量表示的是整数类型的数据

	【！！数据类型存在的意义！！】：给变量分配合适的内存空间，避免造成资源的浪费

	C++中表示整形的类型主要有以下几种方式（！！区别在于所占空间不同）：

数据类型	占用空间	取值范围
short(短整型)	2字节	（-2^15~215-1）
int（整型）	4字节	（-2^31~231-1）
long（长整型）	Windows为4字节,Linux为4字节(32位),8字节(64位)	（-2^31~231-1）
long long(长长整型)	8字节	（-2^63~263-1）

2.2 sizeof关键字

	作用：利用sizeof关键字可以统计数据类型所占大小

	语法：sizeof（数据类型/变量）

	示例：
		int mian(){
			cout << " short类型所占内存空间为： " << sizeof(short) << endl;
			system(" pause ");
			return 0;

		}

2.3 实型（浮点型）

作用：用于表示小数

浮点型变量分为两种：

	1.单精度：float

	2.双精度：double

	二者的区别在于表示的有效数字范围不同

数据类型	占用空间	有效数字范围
short(短整型)	2字节	7位有效数字
int（整型）	4字节	15~16位有效数字

2.4 字符型（1字节）

	作用：字符型变量用于显示 单个 字符

	语法：char ch = 'a';

	【注意1】：在显示字符型变量时，用单引号将字符括起来，不要用双引号

	【注意2】：单引号内只能有一个字符，不可以是字符串

	C和C++中字符型变量只占用一个字节

	字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放到储存单元

2.5 转义字符

	作用：用于表示一些不能显示出来的ASCII字符

	常用的转义字符：

		换行符：\n
			cout << "hello world \n";
		反斜杠：\\
			cout << "hello world \\" << endl;
		水平制表符：\t
			cout << "aaa\t hello world"

2.6 字符串型

	作用：用于表示一串字符

	两种风格：
		1.C风格字符串

			char 变量名[] = "字符串值"

		2.C++风格字符串

			string 变量名 = "字符串值"

2.7 布尔类型bool（1字节）

	作用：布尔数据类型代表真或假的值

	bool类型只有两个值：

		true-----真（本质是1）

		false----假（本质是0）

Chapt3 运算符

【用于执行代码的运算】

主要内容包括：

运算符类型	作用
算术运算符	用于处理四则运算
赋值运算符	用于将表达式的值赋给变量
比较运算符	用于表达式的比较，并返回一个真值或假值
逻辑运算符	用于根据表达式的值返回真值或假值

3.1 算术运算符：

	取模运算（取余运算）：只能对整型进行操作

	前置递增：a=2;b=++a;	——结果——>	a=3;b=3;    先让变量+1，然后进行表达式运算

	后置递增：a=2;b=a++;	——结果——>	a=3;b=2;	先进行表达式运算，然后让变量+1

	前置递减：a=2;b=--a;	——结果——>	a=1;b=1;

	后置递减：a=2;b=a--;	——结果——>	a=1;b=2;

3.2 赋值运算符：

	1. =

		int a = 10;
		a = 100;
		cout << " a = " << a << endl;

	2. +=

		int a = 10;
		a += 2;
		cout << "a = " << a << endl;

	3. -=

		a = 10;
		a -= 2;		// a = a - 2
		cout << "a=" << a << endl;

	4. *=

		a = 10;
		a *= 2;		// a = a * 2
		cout << "a=" << a << endl;

	5. /=

		a = 10;
		a /= 2;		// a = a / 2
		cout << "a=" << a << endl;

	6. %=

		a = 10;
		a %= 2;		// a = a % 2
		cout << "a=" << a << endl;

3.3 比较运算符

【用于表达式的比较，并返回一个真值或假值】

	1. ==

	2. !=

	3. >

	4. <

	5. >=

	6. <=

3.4 逻辑运算符

【用于根据表达式的值返回真值或假值】
	1.!(非)

		int a = 10;
		//在C++z中除了0都为真
		cout << !a << endl;
		cout << !!a << endl;

	2.&&（与）

	3.||（或）

Chapt4 程序流程结构

4.1 顺序结构：

	程序顺序执行不发生跳转

4.2 选择结构：

	1. if语句【执行满足条件的语句】

		1.1 单行格式if语句

			if(条件){
				满足条件时执行的语句
			}

		1.2 多行格式if语句

			if(条件){
				满足条件时执行的语句
			}else{
				不满足条件是执行的语句
			}

		1.3 多条件的if语句

			if(条件1){
				满足条件1时执行的语句
			}else if(条件2){
				满足条件2时执行的语句
			}else if(条件3){
				.......
			}......
			............
			else{
				都不满足时执行的语句
			}

		1.4 嵌套if语句【if语句执行语句内部再嵌套if语句】

	2. 三目运算符【作用：通过三目运算符实现简单的判断】

		语法：表达式1 ? 表达式2 : 表达式3

		【解释】：

			如果表达式1为真，执行表达式2，并返回表达式2的结果；
			
			如果表达式1为假，执行表达式3，并返回表达式3的结果；

			example：
				int a = 10;
				int b = 20;
				int c = 0;
				c = (a > b ? a : b);//先在括号内比较a和b的大小，如果a大于b，返回a，即让c = a，否则返回b，c = b
				cout << " c = " << c << endl;
				(a < b ? a : b) = 100;		//在C++中三目运算符返回的是变量，可以继续赋值
				cout << " a = " << a << endl;
				cout << " b = " << b << endl;

	3. switch：【执行多条件分支语句】

		【语法】：
			
			switch(表达式){
				case 结果1: 执行语句; break;  //case的结果是指switch括号中的表达式的结果
				case 结果2: 执行语句; break;
				case 结果3: 执行语句; break;
				. . . . . .
				default: 执行语句; break;
			}

		【缺点】：只能判断整型和字符型，不能是一个区间

		【优点】：结构清晰，执行效率高(比if高)

		【！！注意！！】：

			1. switch语句中表达式类型只能是整型或者字符型

			2. case里如果没有break，那么程序会一直向下执行下去

		【总结】：与if语句相比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

4.3 循环结构：

	1.while循环语句【满足循环条件，执行循环语句】

		【语法】：while(循环条件){循环语句}

		【解释】：只要循环条件的结果为真，就执行循环语句

		【example】：

			//循环打印0~9
			int num = 0;
			while(num<10){
				cout << num <<endl;
				num++;
			}
		【注意】：在写循环时一定要避免死循环
			
	2. do...while循环语句

		【作用】：满足循环条件，执行循环语句

		【语法】do{循环语句}while(循环条件);

		【注意】与while的区别在于do...while会限制性一次循环语句，在判断循环条件

	3. for循环语句
		
		【作用：满足循环条件，执行循环语句】

		【语法】：for(起始表达式;条件表达式;末尾循环体){循环语句;}

	4. 嵌套循环

4.4 跳转语句

	1. break语句【用于选择结构或循环结构】

		【break的使用时机】：

			1.1 出现在switch条件语句中，作用是终止case并跳出switch

			1.2 出现在循环语句中，作用是跳出当前循环语句

			1.3 出现在嵌套循环中，跳出最近的内层循环语句

	2. continue语句【在循环语句中，跳过本次剩余未执行的语句，继续执行下一次循环】

	3. goto语句【可以无条件跳转语句】

		【语法】：goto标记;

		【解释】：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置

Chapt5 数组：

1. 一维数组的定义方式

	1.1 数据类型 数组名[数组长度];

	1.2 数据类型 数组名[数组长度] = {值1,值2......};

	1.3 数据类型 数组名[] = {值1,值2......};

【数组的特点】：
	
	放在一块连续的内存空间

	数组中每个元素都是相同的数据类型

	数组元素的下标是从0开始索引的

	如果在初始化数据时没有全部填写完，那么会用0来填补完整

2. 一维数组数组名

	一维数组名称的用途：

		1. 可以统计整个数组在内存中的长度

		2. 可以获取数组在内存中的首地址【内存中的地址编号】

3. 冒泡排序

	3.1 比较相邻的元素，如果前一个比后一个大就交换二者的位置

	3.2 对每一对相邻元素执行同样的操作，执行完毕后，找到第一个最大值

	3.2 重复3.1、3.2的操作，每次比较次数-1，直到不再比较

4. 二维数组

	4.1 二维数组的定义方式：

		（1）数据类型 数组名[ 行数 ][ 列数 ];

		（2）数据类型 数组名[ 行数 ][ 列数 ] = {{数据1，数据2}，{数据3，数据4}}; //最佳：直观，可读性高

		（3）数据类型 数组名[ 行数 ][ 列数 ] = {数据1，数据2，数据3，数据4};

		（4）数据类型 数组名[ ][ 列数 ] = {数据1，数据2，数据3，数据4};

	4.2 二维数组数组名：

		4.2.1 查看二维数组所占空间 

		4.2.2 获取二维数组首地址

Chapt6 函数

1. 概述：

	作用：将一段经常使用的代码封装起来，减少重复代码

2. 函数的定义（步骤）

	2.1 返回值类型

	2.2 函数名

	2.3 参数列表

	2.4 函数体语句

	2.5 return表达式
		
	语法:
	返回值类型 函数名 参数列表
	{
		函数体语句
		return 表达式
	}

	int add(int num,int num2)
	{
		int sum = num + num2;
		return sum;
	}

3. 函数的调用

	语法：函数名（参数）

4. 函数的常见样式

	 无参无返、有参无返、无参有返、有参有返

5. 函数的声明

	作用： 告诉编译器函数名称以及如何调用函数，函数的实际主体可以单独定义【当函数的定义在主函数后面进行时

如果没有函数的声明编译器可能会因为找不到函数而出现报错】

	【！！函数的声明可以多次，但函数的定义只能有一次】

6. 函数的分文件编写

	作用： 让代码的结构更清晰

	步骤：  1. 创建后缀名为.h的头文件

			2. 创建后缀名为.cpp的源文件
	
			3. 在头文件中写函数声明
	
			4. 在源文件中写函数的定义

Chapt7 指针

1. 指针的基本概念

	指针的作用：可以通过指针直接访问内存

		【内存编号是从0开始记录的，一般用十六进制数字表示】

		【可以利用指针变量保存地址】

2. 指针变量的定义和使用

	指针变量定义语法：数据类型 * 变量名

3. 指针所占内存空间

	在32位系统下，所有类型的指针都是4个字节的空间。在64位系统下，所有类型的指针都是8个字节

4. 空指针和野指针

	4.1 空指针：指针变量指向内存中编号为0的空间

		用途：初始化指针变量

		注意：空指针指向的变量的不可以访问的

	4.2 野指针（创建一个指针变量然后直接指向一个未知的地址）：指针变量指向非法的内存空间

【没有申请的未知内存空间，无操作权限】

		注意：在程序中，尽量避免出现野指针

		例子：
			
			int * p = (int *)0x1100;

	【总结】：空指针和野指针都不是我们申请的空间，因此不要访问

5. const修饰指针

	const修饰指针的三种情况：

		1. const修饰指针 ——常量指针    const int* p = &a;   
			
			【常量指针（值不能变但地址可以变，但是可以通过修改地址间接变化其指向的值//应该吧，是根据测

试结果得到的结论，不一定准）

特点：指针的指向可以修改，但是指针指向的值不可以修改（即指针修改指向的地址但是地址内含的值不
能变）,经过测试，其实只是只能表示 p = &其他变量，不能使用 * p = 巴拉巴拉，会报错】

		2. const修饰常量 ——指针常量	int* const d = &c;

			【指针常量（值能变但地址不变，无论内部的值怎么变化，指向的地址始终不变//应该吧，是根据测试

结果得到的结论，不一定准）

			特点：指针的指向不可改，指针指向的值可以改（只能表示* d = 其他变量，而d = &balabala会报错）】

		3. const既修饰指针，又修饰常量		const int * const p =&a;

			【特点：指针的指向和指针的值】

6. 指针和数组

	作用：利用指针访问数组元素
	
	int arr[5] = { 1,6,9,12,15 };
	int* p = arr;
	cout << "第一个元素为：" << *p << endl;
	p++;//让指针向后偏移四个字节（即后移一位）
	cout << "第二个元素为：" << *p << endl;
	//也可以使用*(p+1)，测试结果显示，也是指向下一位的指针[！思考：p++和*(p+1)的关系]
	cout << "第三个元素为：" << *(p+1) << endl;
	//回到上一位使用p--

7. 指针和函数

	作用：利用指针作函数参数，可以修改实参的值

	//实现两个数字进行交换
	void swap01(int a,int b) {
		int temp = a;
		a = b;
		b = temp;	//值传递
	}
	void swap02(int *p, int *p2) {
		int temp = *p;
		*p = *p2;
		*p2 = temp;	//地址传递
	}
	int main() {
		//值传递【不改变实参】
		int a = 10;
		int b = 20;
		swap01(a, b);
		//2. 地址传递【会改变实参】
		swap02(&a, &b);

		system("pause");
	}

8. 指针、数组、函数

	案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序要求
			  例如数组：int arr[10] = {4,3,6,9,1,2,10,8,7,5};

IRUIRUI__

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++学习笔记

1.宏常量：#define 常量名常量值2.const 数据类型常量名 = 常量值1.1 数据类型数组名[数组长度];1.2 数据类型数组名[数组长度] = {值1,值2......};1.3 数据类型数组名[] = {值1,值2......};【数组的特点】：放在一块连续的内存空间数组中每个元素都是相同的数据类型数组元素的下标是从0开始索引的如果在初始化数据时没有全部填写完，那么会用0来填补完整作用：将一段经常使用的代码封装起来，减少重复代码2.1 返回值类型2.2 函数名。
复制链接

扫一扫