• C++学习笔记(2)--程序流程结构、数组、函数

    目录

    一、选择结构：

    1、if语句：

    2、三目运算符：

     3、switch语句：

    二、循环结构：

    1、while循环语句

    2、do...while循环语句

    3、for循环语句

     三、数组：

    1、一维数组：

    2、冒泡排序：

    2、 二维数组：

    四、函数：

    1、函数的定义：

    2、 函数的调用

    3、值传递与地址传递：

    5、函数的声明

    6、分文件书写函数：

    一、选择结构：

    1、if语句：

    作用：执行满足条件的语句。分为下面三种形式：

    • 单行格式if语句

    • 多行格式if语句

    • 多条件的if语句

    1. int main() {
    2.  
    3. 	//选择结构-单行if语句
    4. 	int score = 200;
    5.  
    6. 	//if语句
    7. 	//注意事项，在if判断语句后面，不要加分号
    8. 	if (score > 600)
    9. 	{
    10. 		cout << "我考上了一本大学！！！" << endl;
    11. 	}
    12.     
    13.     //多行格式if语句
    14. 	if (score > 600)
    15. 	{
    16. 		cout << "我考上了一本大学" << endl;
    17. 	}
    18. 	else
    19. 	{
    20. 		cout << "我未考上一本大学" << endl;
    21. 	}
    22.  
    23.     //多条件if语句：
    24.     if (score > 600)
    25. 	{
    26. 		cout << "我考上了一本大学" << endl;
    27. 	}
    28. 	else if (score > 500)
    29. 	{
    30. 		cout << "我考上了二本大学" << endl;
    31. 	}
    32. 	else if (score > 400)
    33. 	{
    34. 		cout << "我考上了三本大学" << endl;
    35. 	}
    36. 	else
    37. 	{
    38. 		cout << "我未考上本科" << endl;
    39. 	}
    40.  
    41. 	system("pause");
    42.  
    43. 	return 0;
    44. }

    同时C++也支持空if体，但是要加分号；

    1. int main()
    2. {
    3. 	if (1 > 0);
    4.  
    5. 	system("pause");
    6. 	return 0;
    7. }

    2、三目运算符：

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

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

    1. int main() {
    2.  
    3. 	int a = 10;
    4. 	int b = 20;
    5. 	int c = 0;
    6.  
    7. 	c = a > b ? a : b;
    8. 	cout << "c = " << c << endl;  //20
    9.  
    10. 	//C++中三目运算符返回的是变量,可以继续赋值
    11.  
    12. 	(a > b ? a : b) = 100;
    13.  
    14. 	cout << "a = " << a << endl; //10
    15. 	cout << "b = " << b << endl; //100
    16. 	cout << "c = " << c << endl; //20
    17.  
    18. 	system("pause");
    19.  
    20. 	return 0;
    21. }

     3、switch语句：

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

    语法：

    1. switch(表达式)
    2.  
    3. {
    4.  
    5. 	case 结果1：执行语句;break;
    6.  
    7. 	case 结果2：执行语句;break;
    8.  
    9. 	...
    10.  
    11. 	default:执行语句;break;
    12.  
    13. }

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

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

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

    1. nt main() {
    2.  
    3. 	//请给电影评分 
    4. 	//10 ~ 9   经典   
    5. 	// 8 ~ 7   非常好
    6. 	// 6 ~ 5   一般
    7. 	// 5分以下 烂片
    8.  
    9. 	int score = 0;
    10. 	cout << "请给电影打分" << endl;
    11. 	cin >> score;
    12.  
    13. 	switch (score)
    14. 	{
    15. 	case 10:
    16. 	case 9:
    17. 		cout << "经典" << endl;
    18. 		break;
    19. 	case 8:
    20. 		cout << "非常好" << endl;
    21. 		break;
    22. 	case 7:
    23. 	case 6:
    24. 		cout << "一般" << endl;
    25. 		break;
    26. 	default:
    27. 		cout << "烂片" << endl;
    28. 		break;
    29. 	}
    30.  
    31. 	system("pause");
    32.  
    33. 	return 0;
    34. }

    二、循环结构：

    1、while循环语句

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

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

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

    1. int main() {
    2.  
    3. 	int num = 0;
    4. 	while (num < 10)
    5. 	{
    6. 		cout << "num = " << num << endl;
    7. 		num++;
    8. 	}
    9. 	
    10. 	system("pause");
    11.  
    12. 	return 0;
    13. }

    2、do...while循环语句

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

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

    注意：与while的区别在于，do...while会先执行一次do内的语句，然后再去判断循环体条件是否满足，然后再次决定是否进入循环体，do语句只会被执行一次。

    1. int main() {
    2.  
    3. 	int num = 0;
    4.  
    5. 	do
    6. 	{
    7. 		cout << num << endl;
    8. 		num++;
    9.  
    10. 	} while (num < 10);
    11. 	
    12. 	
    13. 	system("pause");
    14.  
    15. 	return 0;
    16. }

    3、for循环语句

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

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

    注意：for循环中的表达式，要用分号进行分隔  

    1. int main() {
    2.  
    3. 	for (int i = 0; i < 10; i++)
    4. 	{
    5. 		cout << i << endl;
    6. 	}
    7. 	
    8. 	system("pause");
    9.  
    10. 	return 0;
    11. }

     三、数组：

    所谓数组，就是一个集合，里面存放了相同类型的数据元素

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

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

    1、一维数组：

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

    1. 数据类型 数组名[ 数组长度 ];

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

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

    1. int main() {
    2.  
    3. 	//定义方式1
    4. 	//数据类型 数组名[元素个数];
    5. 	int score[10];
    6.  
    7. 	//利用下标赋值
    8. 	score[0] = 100;
    9. 	score[1] = 99;
    10. 	score[2] = 85;
    11.  
    12. 	//利用下标输出
    13. 	cout << score[0] << endl;
    14. 	cout << score[1] << endl;
    15. 	cout << score[2] << endl;
    16.  
    17.  
    18. 	//第二种定义方式
    19. 	//数据类型 数组名[元素个数] =  {值1，值2 ，值3 ...};
    20. 	//如果{}内不足10个数据，剩余数据用0补全
    21. 	int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
    22. 	
    23. 	//逐个输出
    24. 	//cout << score2[0] << endl;
    25. 	//cout << score2[1] << endl;
    26.  
    27. 	//一个一个输出太麻烦，因此可以利用循环进行输出
    28. 	for (int i = 0; i < 10; i++)
    29. 	{
    30. 		cout << score2[i] << endl;
    31. 	}
    32.  
    33. 	//定义方式3
    34. 	//数据类型 数组名[] =  {值1，值2 ，值3 ...};
    35. 	int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
    36.  
    37. 	for (int i = 0; i < 10; i++)
    38. 	{
    39. 		cout << score3[i] << endl;
    40. 	}
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

    一维数组名称的用途：

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

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

    3. 数组名是常量，不可以赋值

    4. 直接打印数组名，可以查看数组所占内存的首地址

    5. 对数组名进行sizeof，可以获取整个数组占内存空间的大小

    1. int main() {
    2.  
    3. 	//数组名用途
    4. 	//1、可以获取整个数组占用内存空间大小
    5. 	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    6.  
    7. 	cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
    8. 	cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
    9. 	cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;
    10.  
    11. 	//2、可以通过数组名获取到数组首地址
    12. 	cout << "数组首地址为： " << (int)arr << endl; //也就是arr[0]的地址
    13. 	cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
    14. 	cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;
    15.  
    16. 	//arr = 100; 错误，数组名是常量，因此不可以赋值
    17.  
    18.  
    19. 	system("pause");
    20.  
    21. 	return 0;
    22. }

    2、冒泡排序：

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

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

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

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

    1. int main() {
    2.  
    3. 	int arr[9] = { 4,2,8,0,5,7,1,3,9 };
    4. 	int len = sizeof(arr) / sizeof(arr[0]);
    5.  
    6. 	for (int i = 0; i < len - 1; i++)
    7. 	{
    8. 		for (int j = 0; j < len - 1 - i; j++)
    9. 		{
    10. 			if (arr[j] > arr[j + 1])
    11. 			{
    12. 				int temp = arr[j];
    13. 				arr[j] = arr[j + 1];
    14. 				arr[j + 1] = temp;
    15. 			}
    16. 		}
    17. 	}
    18.  
    19. //打印数据
    20. 	for (int i = 0; i < 9; i++)
    21. 	{
    22. 		cout << arr[i] << endl;
    23. 	}
    24.  
    25. 	system("pause");
    26.  
    27. 	return 0;
    28. }

    2、 二维数组：

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

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

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

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

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

    定义二维数组时，如果初始化了数据，可以省略行数，无论哪种定义方式都必须写清列

    1. int main() {
    2.  
    3. 	//方式1  
    4. 	//数组类型 数组名 [行数][列数]
    5. 	int arr[2][3];
    6. 	arr[0][0] = 1;
    7. 	arr[0][1] = 2;
    8. 	arr[0][2] = 3;
    9. 	arr[1][0] = 4;
    10. 	arr[1][1] = 5;
    11. 	arr[1][2] = 6;
    12.  
    13. 	for (int i = 0; i < 2; i++)
    14. 	{
    15. 		for (int j = 0; j < 3; j++)
    16. 		{
    17. 			cout << arr[i][j] << " ";
    18. 		}
    19. 		cout << endl;
    20. 	}
    21.  
    22. 	//方式2 
    23. 	//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
    24. 	int arr2[2][3] =
    25. 	{
    26. 		{1,2,3},
    27. 		{4,5,6}
    28. 	};
    29.  
    30. 	//方式3
    31. 	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4  };
    32. 	int arr3[2][3] = { 1,2,3,4,5,6 }; 
    33.  
    34. 	//方式4 
    35. 	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4  };
    36. 	int arr4[][3] = { 1,2,3,4,5,6 };
    37. 	
    38. 	system("pause");
    39.  
    40. 	return 0;
    41. }

    二维数组数组名

    • 查看二维数组所占内存空间

    • 获取二维数组首地址

    1. int main() {
    2.  
    3. 	//二维数组数组名
    4. 	int arr[2][3] =
    5. 	{
    6. 		{1,2,3},
    7. 		{4,5,6}
    8. 	};
    9.  
    10. 	cout << "二维数组大小： " << sizeof(arr) << endl;
    11. 	cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
    12. 	cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;
    13.  
    14. 	cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
    15. 	cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
    16.  
    17. 	//地址
    18. 	cout << "二维数组首地址：" << arr << endl;
    19. 	cout << "二维数组第一行地址：" << arr[0] << endl;
    20. 	cout << "二维数组第二行地址：" << arr[1] << endl;
    21.  
    22. 	cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
    23. 	cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;
    24.  
    25. 	system("pause");
    26.  
    27. 	return 0;
    28. }

    四、函数：

    1、函数的定义：

    1、返回值类型：一个函数可以返回一个值。在函数定义中

    2、函数名：给函数起个名称

    3、参数表列：使用该函数时，传入的数据

    4、函数体语句：花括号内的代码，函数内需要执行的语句

    5、return 表达式： 和返回值类型挂钩，函数执行完后，返回相应的数据

    语法：

    1. 返回值类型 函数名 （参数列表）
    2. {
    3.        函数体语句
    4.        return表达式
    5.  
    6. }
    7. //函数定义
    8. int add(int num1, int num2)
    9. {
    10. 	int sum = num1 + num2;
    11. 	return sum;
    12. }

    2、 函数的调用

    功能：使用定义好的函数

    语法：函数名（参数）

    示例：

    1. //函数定义
    2. int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
    3. {
    4. 	int sum = num1 + num2;
    5. 	return sum;
    6. }
    7.  
    8. int main() {
    9.  
    10. 	int a = 10;
    11. 	int b = 10;
    12. 	//调用add函数
    13. 	int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
    14. 	cout << "sum = " << sum << endl;
    15.  
    16. 	system("pause");
    17.  
    18. 	return 0;
    19. }

      3、值传递与地址传递：

    1、值传递：

    • 所谓值传递，就是函数调用时实参将数值传入给形参

    • 值传递时，如果形参发生，并不会影响实参

    2、地址传递：

    • 所谓地址传递，就是函数调用时实参将实参地址传入给形参

    • 地址传递时，如果形参发生，实参也跟着变化

    1. #include
    2. using namespace std;
    3. #pragma warning(disable:4996)
    4. void swap(int num1, int num2)
    5. {
    6. 	num1 = 20;
    7. 	num2 = 10;
    8. }
    9. void swap_address(int &num1, int &num2) {
    10. 	num1 = 20;
    11. 	num2 = 10;
    12. }
    13. int main() {
    14.  
    15. 	int a = 10;
    16. 	int b = 20;
    17.  
    18. 	swap(a, b);
    19.  
    20. 	cout << "mian中的 a = " << a << endl; //10
    21. 	cout << "mian中的 b = " << b << endl; //20
    22.  
    23. 	swap_address(a, b);
    24.  
    25. 	cout << "mian中的 a = " << a << endl; //20
    26. 	cout << "mian中的 b = " << b << endl; //10
    27.  
    28. 	system("pause");
    29.  
    30. 	return 0;
    31. }

    4、函数的常见样式

    1、无参无返  2、有参无返

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

    1. //函数常见样式
    2. //1、 无参无返
    3. void test01()
    4. {
    5. 	//void a = 10; //无类型不可以创建变量,原因无法分配内存
    6. 	cout << "this is test01" << endl;
    7. 	//test01(); 函数调用
    8. }
    9.  
    10. //2、 有参无返
    11. void test02(int a)
    12. {
    13. 	cout << "this is test02" << endl;
    14. 	cout << "a = " << a << endl;
    15. }
    16.  
    17. //3、无参有返
    18. int test03()
    19. {
    20. 	cout << "this is test03 " << endl;
    21. 	return 10;
    22. }
    23.  
    24. //4、有参有返
    25. int test04(int a, int b)
    26. {
    27. 	cout << "this is test04 " << endl;
    28. 	int sum = a + b;
    29. 	return sum;
    30. }

    5、函数的声明

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

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

    示例：

    1. //声明可以多次，定义只能一次
    2. //声明
    3. int max(int a, int b);
    4. int max(int a, int b);
    5. //定义
    6. int max(int a, int b)
    7. {
    8. 	return a > b ? a : b;
    9. }
    10.  
    11. int main() {
    12.  
    13. 	int a = 100;
    14. 	int b = 200;
    15.  
    16. 	cout << max(a, b) << endl;
    17.  
    18. 	system("pause");
    19.  
    20. 	return 0;
    21. }

    6、分文件书写函数：

    作用：让代码结构更加清晰，编写一般有4个步骤：

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

    2. 创建后缀名为.cpp的源文件

    3. 在头文件中写函数的声明

    4. 在源文件中写函数的定义

    三个文件，第一个 .h 文件用于声明函数。第二个 .cpp 文件用于定义函数体。 第三个main函数文件用于使用。

    示例：

    1. //swap.h文件
    2. #include
    3. using namespace std;
    4.  
    5. //实现两个数字交换的函数声明
    6. void swap(int a, int b);
    1. //swap.cpp文件
    2. #include "swap.h"
    3.  
    4. void swap(int a, int b)
    5. {
    6. 	int temp = a;
    7. 	a = b;
    8. 	b = temp;
    9.  
    10. 	cout << "a = " << a << endl;
    11. 	cout << "b = " << b << endl;
    12. }
    1. //main函数文件
    2. #include "swap.h"
    3. int main() {
    4.  
    5. 	int a = 100;
    6. 	int b = 200;
    7. 	swap(a, b);
    8.  
    9. 	system("pause");
    10.  
    11. 	return 0;
    12. }
  • 相关阅读:
    mysql按照周统计数据
    Spring - ApplicationContextAwareProcessor扩展接口
    输电线路巡视无人机故障坠落防护装置：守护飞行安全的防线
    分享107个小清新ppt模板，总有一款适合您
    【老生谈算法】matlab实现聚类分析源码——聚类分析
    [附源码]java毕业设计西柚网购物系统
    《Go 语言核心 36 讲》学习笔记
    xss-labs靶场1-5关
    Java 泛型类型简单了解
    【Linux】《Linux命令行与shell脚本编程大全 (第4版) 》笔记-Chapter20-正则表达式
  • 原文地址：https://blog.csdn.net/weixin_60414376/article/details/126823191