C++语句汇总（逐渐补充版）（小白友好型）

已于 2024-02-26 23:53:37 修改
阅读量826 收藏 20
点赞数 9
分类专栏： 速查 C/C++ 文章标签： c++ 开发语言 算法 c语言
于 2024-02-14 10:58:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82949788/article/details/136108920
版权

第一部分 -- 基础知识

一、基本语句

1. 通用体
#include <iostream>
using namespace std;

int main()
{
	cout << "Hello World" << endl;
//	cout << "Hello C++" << endl;
	system("pause");
	
	return 0;
}
2. 输出语句
	cout << "Hello World" << endl;
 	cout << "Hello C++" << endl;
3. 注释语句 -- //、/**/
//	cout << "Hello C++" << endl;



/*
	main是一个程序的入口
	每个程序都必须有这么一个函数
	有且仅有一个 
*/
4. 常量

作用：用于记录程序下不可更改的数据

C++定义常量两种方式：

1.#define  宏常量#define  常量名  常量值
通常在文件上方定义，表示一个常量
2.const修饰的变量                const  数据类型  常量名  =  常量值
通常在变量定义前加关键字const，修饰该变量为常量，不可修改

二、数据类型

数据类型存在意义：给变量分配合适的内存空间

1. 整型

2. sizeof关键字

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

语法： sizeof(数据类型 / 变量)

示例：

#include <iostream>
using namespace std;
 
int main()
{
	
	cout << "short 类型所占内存空间为：" << sizeof(short) << endl;

	cout << "int 类型所占内存空间为：" << sizeof(int) << endl;
	
	cout << "long 类型所占内存空间为：" << sizeof(long) << endl;
		
	cout << "long long 类型所占内存空间为：" << sizeof(long long) << endl;
			
	system("pause");
	
	return 0;
	
}

 

3. 实型（浮点型）

// 编辑器默认使用double类型，	定义float时，数字后面添加"f"
float f1 = 3.14f;

double d1 = 3.14;

// 科学计数法
float f2 = 3e2; // 3 * 10 ^ 2

float f3 = 3e-2; // 3 * 0.1 ^ 2

编辑器默认使用double，定义float时，数字后面添加'f'

默认情况下 输出一个小数，会显示6位有效数字

有效数字包含小数点前面的数字

4. 字符型 -- 1个字节

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

语法：char  ch = 'a'；

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

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

  • C和C++中字符型变量只占用1个字节。
  • 字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元，查看对应字符ASCII码值：(int)ch

常见错误：

常见错误报错
char ch1 = "b";[Error] invalid conversion from 'const char*' to 'char' [-fpermissive]
char ch1 = 'ab';[Warning] multi-character character constant [-Wmultichar]

常记ASCII码值：

a  --  97
A  --  65
5. 转义字符

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

现阶段我们常用的转义字符有： \n  \\  \t

#include <iostream>
using namespace std;

int main()
{
//	C++ 
	cout << "Hello World" << endl;
//	C语言 
	cout << "Hello World\n";
	cout << "显示反斜杠\\" << endl;
//	水平制表符\t 作用对齐输出 
	cout << "水平制表符\t作用：对齐输出" << endl; 
	cout << "aaaa\t水平制表符为\\t\t\\t占8个字节" << endl;
	cout << "aa\t水平制表符为\\t\t\\t占8个字节" << endl;
	cout << "a\t水平制表符为\\t\t\\t占8个字节" << endl;

	system("pause");
	
	return 0;
	
}
6. 字符串型

两种风格

1. C风格字符串： char  变量名[] = "字符串值"

注意：C风格的字符串要用双引号括起来，且变量名后要加[]

单引号为字符

2. C++风格字符串：string  变量名 = "字符串值"

//用C++风格字符串时，要包含以下头文件 
#include <string>

#include <iostream>
using namespace std;
//用C++风格字符串时，要包含以下头文件 
#include <string>

int main()
{
//	C风格
	char str[] = "abcde fgg";
//	C++
	string str1 = "abcde uii"; 
	
	cout << "C风格\t字符串为\t" << str << endl;
	cout << "C++\t字符串为\t" << str1 << endl;

	system("pause");
	
	return 0;
	
}
7. 布尔类型 -- 1个字节

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

bool类型只有两个值：

  • true   --- 真（本质是1）
  • false  --- 假（本质是0）

bool类型占1个字节大小

8. 数据的输入

作用：用于从键盘获取数据

关键字：cin

#include <iostream>
using namespace std;
#include <string>

int main()
{
//	整型输入
	int a = 0;
	cout << "请输入整型变量：" << endl;
	cin >> a;
	cout << a << endl;
	 
//	浮点型输入
	float b = 3.14f;
	cout << "请输入浮点型变量：" << endl;
	cin >> b;
	cout << b << endl;
	
//	字符型输入 
	char ch = 'a';
	cout << "请输入字符型变量：" << endl;
	cin >> ch;
	cout << ch << endl;
	
//	字符串型输入
	char d[] = "abc";
	cout << "请输入字符串型变量：" << endl;
	cin >> d;
	cout << d << endl;
	
	string d1 = "abc";
	cout << "请输入字符串型变量：" << endl;
	cin >> d1;
	cout << d1 << endl;
	
//	布尔类型输入 
	char e = false;
	cout << "请输入布尔型变量：" << endl;
	cin >> e;
	cout << e << endl;

	system("pause");
	
	return 0;
	
}

三、运算符

1. 算术运算符 -- 四则运算

取模运算% -- 求余数 -- 先运算除法，再取余数 -- 两个小数是不可以做取模运算的（报错）

递增递减运算符

#include <iostream>
using namespace std;

int main()
{
	
//	前置递增 
	int a = 10;
	++a;  // 让变量进行+1的操作 
	cout << "a = " << a << endl;

//	后置递增
	int b = 10;
	b++;
	cout << "b = " << b << endl;;
	
//	前置和后置的区别 
	// 前置递增  先让变量+1  然后进行表达式运算
	int a2 = 10;
	int b2 = ++a2 * 10;
	cout << "a2 = " << a2 << endl;
	cout << "b2 = " << b2 << endl;	
	
	// 后置递增  先进行表达式运算，后让变量+1 
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << "a3 = " << a3 << endl;
	cout << "b3 = " << b3 << endl;
	
	system("pause");
	
	return 0;
	
}
2. 赋值运算符 -- 将表达式的值赋给变量

3. 比较运算符 -- 比较表达式，返回bool

 4. 逻辑运算符 -- 返回bool

非(!)     -- 真变假，假变真

与(&&) -- 同真为真，其余为假

或(||)    -- 同假为假，其余为真

四、程序流程结构

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

  • 顺序结构：程序按顺序执行，不发生跳转
  • 选择结构：依据条件是否满足，有选择地执行相应功能
  • 循环结构：依据条件是否满足，循环多次执行某段代码
1. 选择结构
1) if语句

作用：执行满足条件的语句

IF语句的三种形式：

  • 单行格式if语句
  • 多行格式if语句
  • 多条件的if语句

1. 单行格式if语句： if(条件){ 条件满足执行的语句 }

注意事项：if条件后面不要加分号

 2. 多行格式if语句： if(条件) { 条件满足执行的语句 }else{ 条件不满足执行的语句 }

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

嵌套if语句：在if语句中，可以使用嵌套if语句，达到更精确的条件判断

2) 三目运算符

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

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

解释：

如果表达式1的值为真，执行表达式2，并返回表达式2的结果;

如果表达式2的值为假，执行表达式3，并返回表达式3的结果。

#include <iostream>
using namespace std;

int main()
{
	int a = 10; 
	int b = 20; 
	int c = 0;
	
	c = a > b ? a : b;
	cout << "c = " << c << endl;
	
	// 三目运算符返回的是变量，可以继续赋值
	
	(a > b ? a : b) = 100;
	
	cout << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	return 0;
	
}

三目运算符返回的是变量，可以继续赋值

3) switch语句

作用：执行多条件分支语句

语法：

switch(表达式) 
{
	case 结果1: 执行语句; break; 
	
	case 结果2: 执行语句; break; 
	
	...
	 
	defalut: 执行语句; break; 
}

break退出当前分支 

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

switch和if区别：

switch缺点：判断时候只能是整型或字符型，不可以是一个区间

switch优点：结构清晰，执行效率高

2. 循环结构
1) while循环语句

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

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

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

 注意事项：在执行循环语句时，程序必须提供跳出循环的出口，否则会出现死循环 

2) do...while循环语句

作用：满需循环条件，执行循环语句

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

注意：与while的区别在于do...while会先执行一次循环语句，再判断循环条件

3) for循环语句

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

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

3. 跳转结构
1) break语句

作用：用于跳出选择结构或者循环结构

break使用的时机：

  • 出现在switch条件语句中，作用是终止case并跳出switch
  • 出现在循环语句中，作用是跳出当前的循环语句
  • 出现在嵌套循环中，跳出最近的内层循环语句
2) continue语句

作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

continue可以筛选条件，程序执行到continue处，不再向下执行，直接执行下一次循环

break和continue区别：

break会直接退出循环；

continue是跳过本次循环，进入下一次循环。

3) goto语句 -- 很少使用，认识即可

作用：可以无条件跳转语句

语法： goto 标记;

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

示例

#include <iostream>
using namespace std;
#include <cstdlib>
//time系统时间头文件包含 
#include <ctime> 

int main()
{
	cout << "1" << endl;
	
	goto FLAG;
	
	cout << "2" << endl;
	cout << "3" << endl;
	cout << "4" << endl;
	
	FLAG:
	
	cout << "5" << endl;
	return 0;
	
}

五、数组

特点1：数组中的每个数据元素都是相同的数据类型

特点2：数组是由连续的内存位置组成的

1. 一维数组
1）一维数组定义方式

一维数组定义的三种方式：

  •  数据类型  数组名[ 数组长度 ];
  •  数据类型  数组名[ 数组长度 ] = { 值1, 值2 ... };
  •  数据类型  数组名[ ] = { 值1, 值2 ... };
#include <iostream>
using namespace std;
#include <cstdlib>
//time系统时间头文件包含 
#include <ctime> 

int main()
{
	//定义方式
	//1. 数据类型 数组名[数组长度]
	int arr[5];
	
	//利用下标赋值
	//数组元素下标从0开始 
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;
	
	//访问数组元素 
	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;
	
	cout << "-------" << endl;
	
	//2. 数据类型  数组名[ 数组长度 ] = { 值1, 值2 ... };
//	int arr2 = { 50, 40, 30, 20, 10 }; //错误，[Error] scalar object 'arr2' requires one element in initializer
	int arr2[5] = { 50, 40, 30, 20, 10 };
	//如果在初始化时没有全部填写完，会用0来填补 数据 
	int arr21[5] = { 50, 40, 30 }; //正确，空缺值arr2[3]、arr2[4]均用0补齐 
	
	//访问数据元素 利用循环 输出数组中的元素 
	for(int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}
	
	cout << "\narr21[5] = { 50, 40, 30 };结果:" << endl;  
	for(int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}
	
	cout << "-------" << endl;
	
	//3. 数据类型  数组名[ ] = { 值1, 值2 ... }; 
	//定义数组的时候，必须有初始长度 
	int arr3[ ] = { 70, 80, 90, 100, 110, 130 };
	for(int i = 0; i < 6; i++)
	{
		cout << arr3[i] << endl;
	} 
	 
	return 0;
	
}

常见错误类型：

int arr2 = { 50, 40, 30, 20, 10 };

错误：[Error] scalar object 'arr2' requires one element in initializer

原因：数组名后没加数组长度，加上数组长度即可

修正：int arr2[ 5 ] = { 50, 40, 30, 20, 10 };

总结1：数组名的命名规范与变量名命名规范一致，不要和变量重名

总结2：数组中下标是从0开始索引

2）一维数组数组名

一维数组名称的用途：

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

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

#include <iostream>
using namespace std;
#include <cstdlib>
//time系统时间头文件包含 
#include <ctime> 

int main()
{
	//数组名用途
	//1. 可以统计整个数组在内存中的长度
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	cout << "整个数组占用内存空间为:" << sizeof(arr) << endl; 
	cout << "每个元素占用内存空间为:" << sizeof(arr[0]) << endl; 
	cout << "数组中元素个数长度为:" << sizeof(arr)/sizeof(arr[0]) << endl; 
	
	
	//2. 可以获取数组在内存中的首地址 
	//(int)arr:将16进制地址转换为10进制，但是此处会出现精确度错误问题，故将其改为(long long)arr; 后同 
	cout << "数组在内存中的首地址为：" << (long long)arr << endl;
	cout << "数组中第一个元素地址为：" << (long long)&arr[0] << endl;
	cout << "数组中第二个元素地址为：" << (long long)&arr[1] << endl;
	
	//数组名是一个常量，不可以进行赋值操作 
//	arr = 100; //错误，[Error] incompatible types in assignment of 'int' to 'int [10]' 
	return 0;
	
}

数组名是一个常量，不可以进行赋值操作

3）一维数组应用：冒泡排序

详见算法--冒泡排序

4）一维数组删除元素原理

原理：用待删除后面的元素依次覆盖前一位元素

//删除操作 
for(int i = idx; i < abs->m_Size; i++)
{
    //数据前移
	abs->personArray[i] = abs->personArray[i+1]; 
}
2. 二维数组
1）二维数组的定义方式

二维数组定义的四种方式：

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

2. 数据类型  数组名[ 行数 ][ 列数 ] = { { 数据1, 数据2 }, {数据3, 数据4} };

3. 数据类型  数组名[ 行数 ][ 列数 ]= { 数据1, 数据2, 数据3, 数据4 };

4. 数据类型  数组名[  ][ 列数 ]= { 数据1, 数据2, 数据3, 数据4 };

建议：以上4中定义方式，利用第二种更加直观，提高代码的可读性。

示例

#include <iostream>
using namespace std;
#include <cstdlib>
//time系统时间头文件包含 
#include <ctime> 

int main()
{
	//二维数组定义方式
	/* 
		1. 数据类型 数组名[ 行数 ][ 列数 ];
		
		2. 数据类型 数组名[ 行数 ][ 列数 ] = { { 数据1, 数据2 }, {数据3, 数据4} };
		
		3. 数据类型 数组名[ 行数 ][ 列数 ]= { 数据1, 数据2, 数据3, 数据4 };
		
		4. 数据类型 数组名[ ][ 列数 ]= { 数据1, 数据2, 数据3, 数据4};
	*/	
	
	//1. 数据类型 数组名[ 行数 ][ 列数 ];
	int arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;
	//外层循环打印行数，内层循环打印列数 
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << endl;
		}
	}
	
	cout << "第二种定义方式" << endl;
	//2. 数据类型 数组名[ 行数 ][ 列数 ] = { { 数据1, 数据2 }, {数据3, 数据4} };
	int arr2[2][3] = 
	{
		{1,2,3},
		{4,5,6}
	};
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 3; j++)
		{
			cout << arr2[i][j] << "  ";
		}
		cout << endl;
	}
	
	cout << "第三种定义方式" << endl;
	//3. 数据类型 数组名[ 行数 ][ 列数 ]= { 数据1, 数据2, 数据3, 数据4 };
	int arr3[2][3] = { 1,2,3,4,5,6 };
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 3; j++)
		{
			cout << arr3[i][j] << "  ";
		}
		cout << endl;
	}
	
	cout << "第四种定义方式" << endl;
	//4. 数据类型 数组名[ ][ 列数 ]= { 数据1, 数据2, 数据3, 数据4};
	int arr4[][3] = { 1,2,3,4,5,6 };
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 3; j++)
		{
			cout << arr4[i][j] << "  ";
		}
		cout << endl;
	}
	return 0;
	
}
2）二维数组数组名
  • 查看二维数组所占内存空间
  • 获取二维数组首地址
#include <iostream>
using namespace std;
#include <cstdlib>
//time系统时间头文件包含 
#include <ctime> 

int main()
{
	int arr[2][3] = 
	{
		{1,2,3},
		{4,5,6}
	};
	
	//1.可以查看占用内存空间大小
	cout << "二维数组占用内存空间为：" << sizeof(arr) << endl;
	cout << "二维数组一行占用内存为：" << sizeof(arr[0]) << endl;
	cout << "二维数组第一个元素占用内存为：" << sizeof(arr[0][0]) << endl;
	
	cout << "二维数组行数为：" << sizeof(arr) / sizeof(arr[0]) << endl; 
	cout << "二维数组列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl; 
	
	//2.可以查看二维数组的首地址 
	cout << "二维数组首地址：" << (long long)arr << endl; 
	cout << "二维数组第一行首地址：" << (long long)&arr[0] << endl; 
	cout << "二维数组第二行首地址：" << (long long)&arr[1] << endl; 
	cout << "二维数组第一个元素首地址：" << (long long)&arr[0][0] << endl; 
	
	return 0;
	
}

六、 函数

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

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能

1. 函数的定义

函数的定义一般主要有5个步骤：

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法：

返回值类型 函数名 (参数列表)
{
    函数体语句

    return 表达式
}
2. 函数的常见样式

常见的函数样式有4种

1. 无参无返

2. 有参无返

3. 无参有返

4. 有参有返

void a = 20; //错误

无类型不可以定义变量，原因是无法分配内存

3. 函数的声明

作用：告诉编辑器函数名称以及如何调用函数。函数的实际主体可以单独定义。

意义：提前告诉编辑器函数的存在 

程序读取文件时，从一行开始读取，找到main函数，然后开始执行，如果函数定义放置在main函数下方，在顺序执行main函数时会找不到自定义的函数，报错。

所以，可以利用函数声明，在main函数之前声明自定义函数，然后将定义的函数主体（代码段）放置在main函数的下方        

  • 函数的声明可以多次，但是函数的定义只能有一次

示例

#include <iostream>
using namespace std;
#include <cstdlib>
//time系统时间头文件包含 
#include <ctime> 

//函数的声明可以多次，定义只有一次
//声明,提前告诉编辑器函数的存在 
int max(int a, int b); 
int max(int a, int b); 


int main()
{
	int a = 10;
	int b = 20;
	cout << max(a,b) << endl;
	return 0;
}

//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

七、指针

1. 指针的基本概念

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

  • 内存编号是从0开始记录的，一般用十六进制数字表示
  • 可以利用指针变量保存地址

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

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

示例

#include <iostream>
using namespace std;

int main()
{

	//1、定义指针
	int a = 10;
	//指针定义的语法：数据类型 * 指针变量名;
	int * p;
	//让指针记录变量a的地址，指针记录的是地址 
	p = &a;
	cout << "a的地址为：" << (long long)&a << endl; 
	cout << "指针p为：" << (long long)p << endl; 
	
	//2、使用指针
	//可以通过 解引用的方式来找到指针指向的内存
	//指针前加一个 * 代表解引用，找到指针指向的内存中的数据 
	*p = 1000;
	cout << "a的值为：" << a << endl;
	cout << "p的值为：" << *p << endl;

	return 0;
}
3. 指针所占内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？

#include <iostream>
using namespace std;

int main()
{
	//指针所占内存空间
	int a = 10;
	
	int * p = &a; //指针指向数据a的地址
	
	//在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
	//在64位操作系统下，指针是占8个字节空间大小，不管是什么数据类型 
	cout << *p << endl;
	cout << sizeof(p) << endl;
	cout << sizeof(int *) << endl;
	cout << sizeof(char *) << endl;
	cout << sizeof(float *) << endl;
	cout << sizeof(double *) << endl; 
	
	return 0;
}

在32位操作系统下，不管是什么类型的指针，都占4个字节空间大小

在64位操作系统下，不管是什么类型的指针，都占8个字节空间大小

4. 空指针和野指针

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

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

示例1：空指针

#include <iostream>
using namespace std;

int main()
{
	//空指针和野指针
	//空指针
	//1、空指针用于给指针变量进行初始化 
	//指针变量p指向内存地址编号为0的空间
	int * p = NULL;
	
	//2、空指针是不可以进行访问的 
	//内存编号0 ~ 255为系统占用内存，不允许用户访问
	cout << *p << endl;
	 
	
	return 0;
}

野指针：指针变量指向非法的内存空间

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

5. const修饰指针

const修饰指针有三种情况：

1、const修饰指针  ---  常量指针

2、const修饰常量  ---  指针常量

3、const即修饰指针，又修饰常量

示例

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int b = 10;
	
	//常量指针 
	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a;
	p1 = &b; //正确
	//*p1 = 100;  报错
	
	//指针常量 
	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; 错误 
	
	//const既修饰指针，又修饰常量
	//指针的指向和指针指向的值都不可以改
	const int * const p3 = &a;
	//指针的指向 和指针指向的值 都不可以改
	//*p3 = 100； 错误
	//p3 = &b;  错误 
	
	return 0;
}
6. 指针和数组

作用：利用指针访问数组中元素

#include <iostream>
using namespace std;

int main()
{
	//指针和数组
	//利用指针访问数组中的元素
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	
	cout << "第一个元素为：" << arr[0] << endl;
	
	int * p = arr; //arr就是数组首地址
	 
	cout << "利用指针访问第一个元素：" << *p << endl; 
	
	p++;//让指针向后移动4个字节 
	
	cout << "利用指针访问第二个元素：" << *p << endl;
	 
	//利用指针遍历数组
	int * p2 = arr;
	for(int i = 0; i < 10; i++)
	{
//		cout << arr[i] << endl;
		cout << *p2 << endl;
		p2++;
	}
	
	return 0;
}
7. 指针和函数

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

 
#include <iostream>
using namespace std;

//实现两个数字交换
void swap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;	
	
	cout << "swap01 a = " << a << endl;
	cout << "swap01 b = " << b << endl;
} 

void swap02(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;	
}

int main()
{
	//指针和函数
	//1、值传递
	int num1 = 10;
	int num2 = 20;
	swap01(num1, num2);
	
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
	
	//2、地址传递 
	swap02(&num1, &num2);
	
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
	
	return 0;
}
8. 指针、数组、函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

#include <iostream>
using namespace std;

//冒泡排序函数  参数1  数组的首地址   参数2  数组长度 
void bubbleSort(int * arr, int len)
{
	for(int i = 0; i < len; i++)
	{
		for(int j = 0; j < len - i - 1; j ++) 
		{
			//如果 j > j+1 的值  交换数组 
			if(arr[j] > arr[j+1])
			{
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
} 

//打印数组
void printArray(int * arr, int len)
{
	for(int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
} 

int main()
{
	//1、先创建数组 
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	
	//2、创建函数、实现冒泡排序
	int len = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr, len);
	
	//3、打印排序后的数组 
	printArray(arr, len); 
	
	return 0;
}

指针相当于直接在原地址上进行修改，减少赋值操作

八、结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

1. 结构体定义和使用

语法： struct 结构体名 { 结构体成员列表 };

通过结构体创建变量的方式有三种：

  • struct 结构体名 变量名
  • struct 结构体名 变量名 = { 成员1值，成员2值... }
  • 定义结构体时顺便创建变量
#include <iostream>
using namespace std;
#include <string> 

//结构体自定义
//1、创建学生数据类型：学生包括（姓名，年龄，分数） 
//自定义数据类型，一些类型集合组成的一个类型
//语法  struct  类型名称  { 成员列表 }
struct Student
{
	//成员列表
	string name; //姓名
	int age;     //年龄 
	int score;   //分数
}; 

//2.3、定义结构体时可以创建变量（基本不用） 
struct Student2
{
	//成员列表
	string name; //姓名
	int age;     //年龄 
	int score;   //分数
}s3; 



int main()
{
	//结构体使用 
	//2、 通过学生类型创建具体学生
	//2.1 struct Student s1 
	//struct 关键字可以省略 
	Student s1;
//	struct Student s1;
	//给s1属性赋值, 通过.访问结构体 变量中的属性 
	s1.name = "张三";
	s1.	age = 20;
	s1.score = 30; 
	
	cout << "姓名： " << s1.name << "   年龄： " << s1.age << "   分数： " << s1.score << endl;
	
	//2.2 struct Student s2 { ... }
	struct Student s2 = { "李四", 30, 100 };
	cout << "姓名： " << s2.name << "   年龄： " << s2.age << "   分数： " << s2.score << endl;
	
	//2.3 在定义结构体时顺便创建结构体变量 
	s3.name = "王五";
	s3.age = 18;
	s3.score = 38;
	cout << "姓名： " << s3.name << "   年龄： " << s3.age << "   分数： " << s3.score << endl;
	
	return 0;
}
2. 结构体数组
#include <iostream>
using namespace std;
#include <string> 

//结构体数组 
//1\定义结构体
struct Student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数	
}; 


int main()
{
	//2、创建结构体数组
	struct Student arr[3] = 
	{
		{"张三", 18, 80},
		{"李四", 20, 30},
		{"王五", 30, 90}
	}; 
	
	//3、给结构体数组中的元素赋值
	 arr[2].name = "赵六"; 
	 arr[2].age = 29; 
	
	for(int i = 0; i < 3; i++)
	{
		cout << "姓名： " << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;	
	} 
	
	return 0;
}
3. 结构体指针

作用：通过指针访问结构体中的成员

  • 利用操作符->可以通过结构体指针访问结构体属性
#include <iostream>
using namespace std;
#include <string> 

//结构体指针 
//1、定义结构体
struct Student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数	
}; 


int main()
{
	//2、创建结构体变量 
	struct Student s1 = {"张三", 18, 80}; 
	
	//3、通过指针指向结构体变量
	struct Student * p = &s1;
	//Student * p = &s1;    //也可以使用这种方式 
	
	//4、通过指针访问结构体变量中的数据 
	cout << "姓名： " << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;	
	 
    //无法通过指针直接修改数据？？？？ 
	p->name = "刘启";
	cout << "姓名： " << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;	
	
	return 0;
}

 通过指针修改值，新增结构体变量 

4. 结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

#include <iostream>
using namespace std;
#include <string> 

//结构体嵌套 
//1、学生结构体定义 
struct Student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数	
}; 

//教师结构体定义 
struct Teacher
{
	//成员列表
	int id; //职工编号
	string name; //教师姓名
	int age; //教师年龄
	struct Student stu; //子结构体：学生 
};


int main()
{
	//结构体嵌套结构体
	Student s1 = {"王三", 16, 12}; 
	//创建老师
	Teacher t1 = { 001, "刘老师", 78, s1};
	
	Teacher t2;
	t2.id = 200;
	t2.name = "王老师";
	t2.stu.name = "张同学";
	t2.stu.age = 16;
	t2.stu.score = 57;
	
	cout << "老师姓名：" << t2.name << " " << "老师辅导的学生姓名：" << t2.stu.name << endl;
	
	return 0;
}
5. 结构体做函数参数

作用：将结构体作为参数向函数中传递

传递方式有两种：

  • 值传递
  • 地址传递
#include <iostream>
using namespace std;
#include <string> 

//结构体做函数参数 
//1、学生结构体定义 
struct Student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数	
}; 

//1、值传递 
void printStudent1(Student stu)
{
	stu.age = 100;
	cout << "子函数1中  姓名：" << stu.name << " " << "年龄: " << stu.age << "分数：" << stu.score << endl;	
} 


//2、地址传递
void printStudent2(Student * stu)
{
	stu->score = 20;
	cout << "子函数2中  姓名：" << stu->name << " " << "年龄: " << stu->age << "分数：" << stu->score << endl;	
}  

int main()
{
	//结构体做函数参数
	//将学生传入到一个参数中，打印学生身上的所有信息
	
	//创建结构体变量
	Student s1;
	s1.name = "张三";
	s1.age = 28;
	s1.score = 89; 
	
	printStudent1(s1); 
	cout << "main函数中  姓名：" << s1.name << " " << "年龄: " << s1.age << "分数：" << s1.score << endl;	
	printStudent2(&s1);
	cout << "main函数中  姓名：" << s1.name << " " << "年龄: " << s1.age << "分数：" << s1.score << endl;	
	
	return 0;
}

 值传递原数据的数值不变，指针传递原数据的值会变

6. 结构体中 const 使用场景

作用：用const来防止误操作

#include <iostream>
using namespace std;
#include <string> 

//结构体中const的使用场景 
//1、学生结构体定义 
struct Student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数	
};  

//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来 
void printStudent(const Student *s)
{
	//加入const之后，一旦有修改的操作就会报错，可以防止误操作 
	//s->age = 96; 
	cout << "main函数中  姓名：" << s->name << " " << "年龄: " << s->age << "分数：" << s->score << endl;	
}  

int main()
{

	//创建结构体变量
	Student s1;
	s1.name = "张三";
	s1.age = 15;
	s1.score = 89; 
	
	//通过函数打印结构体变量信息 
	printStudent(&s1); 
	cout << "main函数中  姓名：" << s1.name << " " << "年龄: " << s1.age << "分数：" << s1.score << endl;	
	
	return 0;
}
7. 结构体案例

学生正在做毕设项目，每名老师带领5名学生，总共有3名老师，需求如下

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员

学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值

最终打印出老师数据以及老师所带的学生数据。

#include <iostream>
using namespace std;
#include <string> 
#include <ctime>
#include <stdlib.h>


//1、学生结构体定义 
struct Student
{
	//成员列表
	string sName;  //姓名
	int score;    //分数	
}; 

struct Teacher
{
	//成员列表
	string tName;  //姓名
	Student sArray[5];	
};   

//给老师和学生赋值的函数 
void allocateSpace(Teacher tArray[], int len)
{
	string nameSeed = "ABCDE";
	//给老师开始赋值
	for(int i = 0; i < len; i++)
	{
		tArray[i].tName	= "Teacher_";
		tArray[i].tName += nameSeed[i];
		
		//通过循环给每名老师所带的学生赋值
		for(int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].sName = "Student_";	 
			tArray[i].sArray[j].sName += nameSeed[j];	 
			
			int random = rand() % 61 + 40; //40 ~ 100
			tArray[i].sArray[j].score = random;
		} 
	} 
}

//打印所有信息 
void printInfo(Teacher tArray[], int len)
{
	for(int i = 0; i < len; i++)
	{
		cout << "老师姓名：" << tArray[i].tName << endl;
		for(int j = 0; j < 5; j++)
		{
			cout << "\t学生姓名：" << tArray[i].sArray[j].sName << " " << "学生分数：" << tArray[i].sArray[j].score << endl;
		}
		
	}
}  

int main()
{
	//随机数种子
	srand((unsigned int)time(NULL));

	//1、创建3名老师的数组
	Teacher tArray[3];
	
	//2、通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
	int len = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray, len);
	
	//3、打印所有老师及所带的学生信息
	printInfo(tArray, len);	
	
	return 0;
}

因为数组的复制将导致连续的内存读与内存写，其时间开销取决于数组长度，有可能会变得非常大。

为了避免复制数组的开销，在数组作为函数形参时，传递的实际上是数组的首地址，即用指针代替数组。因此C语言使得当数组作为实参传递给函数的时候，将退化为同类型的指针，再传递指针的值。

九、部分语法汇总

1. 清屏
system("cls");
2. printf、scanf 与 cout、cin区别
printf、scanfC语言中输出、输入语法
cout、cinC++中输出、输入语法

第二部分 -- 面向对象

一、内存分区模型

C++程序在执行时，将内存大方向划分为4个区域（根据数据的生命周期来划分）

  • 代码区：存放函数体的二进制代码，由操作系统进行管理的
  • 全局区：存放全局变量和静态变量以及常量
  • 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
  • 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

1.1 程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域

代码区：

        存放CPU执行的机器指令

        代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可

        代码区是只读的，使其只读的原意是防止程序意外地修改了它的指令

全局区：

        全局变量和静态变量存放在此

        全局区还包含了常量区，字符串常量和其他常量（const 修饰的变量）也存放在此

        该区域地数据在程序结束后由操作系统释放

#include <iostream>
using namespace std;

//全局变量
int g_a = 10;
int g_b = 10;

//const修饰的全局变量, 全局常量 
const int c_g_a = 10; 
const int c_g_b = 10; 
 
int main()
{
	//全局区

	//全局变量、静态变量、常量
	

	//创建普通局部变量
	int a = 10;
	int b = 10;
	
	cout << "局部变量a的地址为：" << (long long)&a << endl; 
	cout << "局部变量b的地址为：" << (long long)&b << endl;\
	
	cout << "全局变量a的地址为：" << (long long)&g_a << endl; 
	cout << "全局变量b的地址为：" << (long long)&g_b << endl;
	
	//静态变量  在普通变量前加static  属于静态变量’
	static int s_a = 10;
	static int s_b = 10;
	
	cout << "静态变量s_a的地址为：" << (long long)&s_a << endl; 
	cout << "静态变量s_b的地址为：" << (long long)&s_b << endl;
	
	
	//常量
	//字符串常量(""引起来的)
	cout << "字符串常量的地址为：" << (long long)&"hello world" << endl;
	
	//const修饰的变量 
	//const 修饰的全局变量
	cout << "全局常量c_g_a的地址为：" << (long long)&c_g_a << endl;
	cout << "全局常量c_g_b的地址为：" << (long long)&c_g_b << endl;
	
	//const 修饰的局部变量 
	const int c_l_a = 10;     //l-local
	const int c_l_b = 10;
	cout << "局部常量c_l_a的地址为：" << (long long)&c_l_a << endl;
	cout << "局部常量c_l_b的地址为：" << (long long)&c_l_b << endl;
	 
	return 0; 
}

总结：

  • C++中在程序运行前分为全局区和代码区
  • 代码区特点是共享和只读
  • 全局区中存放全局变量、静态变量、常量
  • 常量区中存放const修饰的全局变量 和 字符串常量

1.2 程序运行后

        栈区：

                由编译器自动分配释放，存放函数的参数值，局部变量等

                注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

#include <iostream>
using namespace std;

//栈区数据注意事项  --  不要返回局部变量的地址
//栈区的数据由编译器管理开辟和释放

int* func(int b) //形参数据也会放在栈区 
{
	b = 100;
	int a = 10; //局部变量   存放在栈区，栈区的数据在函数执行完后自动释放 
	return &a; //返回局部变量的地址 
}
 
int main()
{
	//接受func函数的返回值
	int * p = func(1);
	
	cout << *p << endl;  //第一次可以打印正确的数字，是因为编译器做了保留 
	cout << *p << endl;  //第二次这个数据就不再保留了 
	 
	return 0; 
}

  堆区：

                由程序员分配释放，若程序员不释放，程序结束时有操作系统回收

                在C++中主要利用new在堆区开辟内存

#include <iostream>
using namespace std;

int * func()
{
	//利用new关键字  可以将数据开辟到堆区 
	//指针  本质也是局部变量，放在栈上，指针保存的数据是放在堆上 
	int * p = new int(10);
	return p;
}
int main()
{

	//在堆区开辟数据
	int *p = func();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	 
	return 0; 
}

总结：

堆区数据由程序员管理开辟和释放

堆区数据利用new关键字进行开辟内存

 1.3 new操作符

C++中利用new操作符在堆区开辟数据

堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete

语法： new 数据类型

利用new创建的数据，会返回该数据对应的类型的指针

#include <iostream>
using namespace std;

//1、new的基本语法
int * func()
{
	//在堆区创建整形数据 
	//new返回是 该数据类型的指针 
	int * p = new int(10); 
	return p;
}

void test01()
{
	int * p = func();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	//堆区数据 由程序员管理开辟，程序员管理释放 
	//如果想 释放堆区的数据，使用关键里 delete
	delete p;
	
//	cout << *p << endl; //数据已经被释放，再次访问是非法操作 会报错 
	
} 

//2、在堆区利用new开辟数据
void test02()
{
	//创建10整型数据的数组，在堆区
	int * arr = new int[10];  //10代表数组由10个元素
	
	for(int i = 0; i < 10; i++)
	{
		arr[i] = i + 100; //给10个元素赋值 100~109 
	}
	
	for(int i = 0; i< 10; i++)
	{
		cout << arr[i] << endl; 
	} 
	//释放堆区数组
	//释放数组的时候  要加[]才可以 
	delete[] arr;
	  
}
int main()
{

	
	
	test01();
	test02();

	 
	return 0; 
}

零、算法

1. 冒泡算法 -- 一维数组

作用：最常用的排序算法，对数组内元素进行排序

1. 比较相邻的元素，如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。

3. 重复以上的步骤，每次比较次数-1，直到不需要比较

排序的总轮数 = 元素个数 - 1

每轮对比次数 = 元素个数 - 排序轮数 - 1

示例：将数组{ 4,2,8,0,5,7,1,3,9 }进行升序排序

#include <iostream>
using namespace std;
#include <cstdlib>
//time系统时间头文件包含 
#include <ctime> 

int main()
{
	int arr[9] = { 4, 2, 8, 0, 5, 7, 1, 3, 9 };
	
	cout << "冒泡排序前的结果为："  << endl;
	for(int i = 0; i < 9; i++)
	{
		cout << arr[i] << "  ";
	} 
	cout << endl;
		
	//开始冒泡排序 
	//总共排序的轮数为 元素个数 - 1 
	for(int i = 0; i < 9 - 1; i++)
	{
		//内层循环对比
		for(int j = 0; j < 9 - i - 1; j++)
		{
			//如果第一个数字，比第二个数字大，交换两个数字 
			if(arr[j] > arr[ j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[ j + 1];
				arr[ j + 1 ] = temp; 
			}
		} 
	}
	
	cout << "\n冒泡排序后的结果为："  << endl;
	for(int i = 0; i < 9; i++)
	{
		cout << arr[i] << "  ";
	} 
	
	return 0;
	
}

注意事项：

  • 一个程序/项目中有且仅有一个main()
山楂橙子
关注
  • 9
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++教程之基本语句
QStack的博客
03-24 446
这篇文章主要介绍了C++中的基本语句，更多文章可以关注公众号QStack。
C++常见语法汇总
qq_34310307的博客
04-26 4887
C++常见知识点汇总
原文地址：C++ 语法大全。作者：Capacity
我的
12-11 810
原文地址：语法大全。" href="http://blog.sina.com.cn/s/blog_7c336a8301014dtu.html" target="_blank">C++ 语法大全。作者：Capacity 1. I/O流的常用控制符 dec 置基数为10 hex 置基数为16 oct 置基数为8 setfill(c) 设填充字符为C setprecision(n)
【C/C++超级基本功】语句
eunicorn的博客
05-06 448
C++的语句大致可分为简单语句、条件语句、迭代语句、跳转语句、try语句块和异常处理
6种类型的C++语句
hua_hengixn的博客
10-18 1452
最近会总结一下C++ 的基本知识点。 1、声明语句：定义函数种使用的变量的名称和类型。 2、赋值语句：使用赋值运算符（=）给变量赋值，貌似还有equal等关键字。 3、消息语句：将消息发送给对象，激发某种行为。 4、函数调用：执行函数，被调用的函数被执行完毕后，程序返回到函数调用语句后面的语句。 5、函数原型：声明函数的返回类型、函数接受的参数数量和类型。 6、返回语句：将一个值从被调用的函数那里...
Pascal C C++语句对比（补充版）.doc
03-14
【Pascal、C、C++语句对比】 在编程领域，Pascal、C和C++是三种具有影响力的编程语言，它们各自拥有独特的语法结构。本文将对比这些语言的基本语句和特性。 一、Hello world程序 1. Pascal的Hello world程序使用`...
C++语句和程序结构（英文）
最新发布
09-01
C++语句和程序结构 C++语句是构成C++程序的基本单元。了解C++语句的类型和结构是编写有效C++程序的基础。本章节将对C++语句和程序结构进行简介，旨在帮助读者理解基本的C++程序是如何构建的。 语句的定义 在...
小白初学c++之for循环语句敲桌子
03-27
小白初学c++之for循环语句敲桌子
C++语句编程代码合集
03-30
在C++编程语言中，语句是程序的基本执行单元，它们指示计算机进行特定的操作。这份"C++语句编程代码合集"显然包含了多个C++源文件（cpp文件），每个文件可能对应一个或多个编程概念的实例。从提供的文件名来看，它们...
小白初学c++之while语句的猜数小游戏
03-26
小白人群，分享
【C++基础】第5章：语句
qq_60225495的博客
10-22 504
语句1. 语句基础1.1 语句的常见类别1.1.1 表达式语句：表达式后加分号，对表达式求值后丢弃，可能产生副作用1.1.2 空语句：仅包含一个分号的语句，可能与循环一起工作1.1.3 复合语句（语句体）：由大括号组成，无需在结尾加分号，形成独立的域（语句域）1.2 顺序语句与非顺序语句1.2.1 顺序语句1.2.2 非顺序语句1.2.2.1 最基本的非顺序语句： goto1.2.2.2 goto 本质上对应了汇编语言中的跳转指令2. 分支语句2.1 分支语句—— if2.1.1 语法： https://z
C++ 语法概括总结
vuscity的博客
05-25 1321
文章目录1 输入输出1.1 注意事项1.2 输入（c / c++）1.2 scanf / printf 1 输入输出 1.1 注意事项 一个.cpp文件，最好不要 printf 和 cout 交杂，要么全用C，要么全用C++ 除了string的输入用cin外，其余任何都用scanf、printf 涉及浮点数，都用double 1.2 输入（c / c++） C 输入 停止符（不能读） 可读 输出 举例 scanf 空格、/n 当读入%c，可读空白（空格、/n、/t） printf
刚入C++编程新手必须要会的一些简单语句
following_down的博客
09-18 755
主要讲述cout,if,else if,while,for语句的使用方法
C++语法基础
m0_55534317的博客
10-12 1917
本文主要讲解了本人在学习C++的一些基础语法时的记录，后续持续记录面向对象及其高阶应用
c++基础之语句
Masimaro的专栏
03-01 336
上一次总结了一下c++中表达式的相关内容，这篇博文主要总结语句的基础内容 简单语句 c++ 中语句主要是以分号作为结束符的，最简单的语句是一个空语句，空语句主要用于，语法上需要某个地方，但是逻辑上不需要；最常见的就是循环里面 复合语句是用大括号括起来的语句块叫做复合语句，复合语句也叫做块。一个块就是一个作用域，在块中引入的名字只能在块内部以及嵌套在块里面的子块中访问。通常名字在有限的区域内可见，该区域从名字定义开始，到名字所在块的结尾为止。语法上需要一条语句，但是逻辑上需要多条语句的，应该使用语句块，例如
C++语法汇总
using namespace 数学工具构造器;
12-06 444
文章目录C++ 常用头文件和宏定义CLion模板输入输出 C++ 常用头文件和宏定义 一了百了 #include <bits/stdc++.h> 大军来袭 #include<cstdio> #include<cstring> #include<algorithm> #include<iostream> #include<string> #include<vector> #include<stack> #
C++中的基本语句
weixin_48797919的博客
11-27 1521
C++ 程序由很多明确表达的语句组成。其中常见的语句包含声明语句、赋值语句、消息语句、函数调用、函数原型和返回语句。其中声明语句和赋值语句中的核心就是变量，变量的声明语句（也称为定义）使用一个简单的标识符来描述计算机存储空间中一定位置的存储单元，并通过指定数据的类型特征来确定该数据单元的大小，这样才会保证C++ 编译器可以查找指定存储单元，并正确读取和写入特定类型的数据。赋值语句就是将指定变量的存储区域写入指定数据的操作语句。 函数原型、返回语句和调用语句都是与函数的定义和...
C++表达式和语句实用经验
sinat_39061823的博客
06-04 573
文章内容整理自    刘光《C++程序员不可不知的101条实用经验》1.运算符引发的混乱①粗心导致的混乱，如将“==”写成了“=”，这种情况在if语句中能够编译通过②优先级导致的混乱，如 cout &lt;&lt; a ? “1” : “2”，程序本意是若a为真则输出“1”，否则输出“2”，但&lt;&lt;运算符的优先级比条件表达式的优先级高，应改正为cout &lt;&lt; (a ? “1”...
C++学习笔记：if语句（if if-else if的嵌套）
C++
04-20 7220
回看C++学习之路，早已过if这座山，顶峰风光无限好啊！ if可以说是C++用途很广的语句了，次于循环结构。 下面是if语句的一些笔记。 if 语句的3种形式 1. if(表达式）语句　(单分支if语句) 2 if(表达式）语句1 else 语句2 (双分支if语句) 3 if(表达式1）语句1 else if (表达式2）语句2 else if （表达式3) 语句3 else ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

山楂橙子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值