• c++学习从小白到高级工程师实战01：c++的基础入门

    目录：

            一、c++开发环境搭建

            二、入门代码学习

                    2.1、初始c++

                    2.2、数据类型

                    2.3、运算符

                    2.4、程序流程结构

                    2.5、数组

                    2.6、函数

                    2.7、指针

                    2.8、结构体

            三、入门实战：通讯录管理系统

    一、c++开发环境搭建

    搜索Visual Studio软件，在官网选择社区版进行下载安装

     双击安装包，主要勾选c++开发，其他功能模块可以根据实际需求进行勾选

     然后选择好安装的路径，等待安装即可。

    二、入门代码学习

    2.1、初识c++

    1、创建项目

    2、创建文件

    如果右侧没有解决方案资源管理器，可以在视图上点击添加

    右键源文件添加新建项

     

     进入到写代码的界面

     首先写一个模板，后续都可以用这样的模型作为开始代码。

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6. 	system("pause");
    7. 	return 0;
    8. }

    在Debug x86模式下，点击运行

     弹出的界面没有任何内容

     通过cout输出hello world 在弹出窗口

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6. 	cout << "hello world" << endl;
    7. 	system("pause");
    8. 	return 0;
    9. }

     3、注释介绍

    c++中有单行注释和多行注释

    单行注释的快捷键：ctrl+k+c

    多行注释的快捷键：

    取消注释：ctrl+k+u

    有且只有一个main函数，否则会报错

    严重性    代码    说明    项目    文件    行    禁止显示状态
    错误    LNK2005    _main 已经在 02变量的创建和使用.obj 中定义    01c++写HelloWorld    D:\csdn\c++\01c++写HelloWorld\01c++写HelloWorld\01书写helloworld.obj    1    
    严重性    代码    说明    项目    文件    行    禁止显示状态
    错误    LNK1169    找到一个或多个多重定义的符号    01c++写HelloWorld    D:\csdn\c++\01c++写HelloWorld\Debug\01c++写HelloWorld.exe    1    

    这里将main替换成main2就不会报错了 

     4、变量的创建和使用

    变量存在的意义：方便我们管理内存空间。

    一个16进制数地址代表一个内存，内存里面存放着一个数值10。

    这里用变量a来代替这个地址，来管理数值10。即变量a来存储10这个数值。

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6. 	//变量创建的语法：数据类型 变量名 = 变量初始值
    7. 	int a = 10;
    8.  
    9. 	cout << "a = " << a << endl;
    10.  
    11. 	system("pause");
    12. 	return 0;
    13. }

     如果有多个c++代码.cpp文件，优先运行main函数，其他函数没有意义，因此除了要运行的代码为main，其他代码中的主函数修改其他名称，该代码运行后如不再使用，也将main修改成其他名称，如main1。

    5、常量

    常量用于记录程序中不可更改的数据

    c++定义常量的两种方式 1：#define 宏常量  2：const修饰的变量   

    代码如下：

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //常量的定义方式
    5.  
    6. //1、#define 宏常量
    7.  
    8. #define Day 7
    9. int main()
    10. {
    11. 	cout << "一周总共有：" <<Day<<"天" << endl;
    12.  
    13. 	system("pause");
    14. 	return 0;
    15. }

     如果 在后续再定义则会报错，常量不可修改，一旦修改就会报错。

    会提示严重性    代码    说明    项目    文件    行    禁止显示状态
    错误(活动)    E0137    表达式必须是可修改的左值    01c++写HelloWorld    D:\csdn\c++\01c++写HelloWorld\01c++写HelloWorld\03常量.cpp    11    
     

    const常量代码如下:

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //常量的定义方式
    5.  
    6. //1、#define 宏常量
    7.  
    8. #define Day 7
    9. int main()
    10. {
    11. 	//Day = 14;
    12. 	cout << "一周总共有：" <<Day<<"天" << endl;
    13.  
    14. 	const int month = 12;
    15. 	//month = 24;  //错误，const修饰的变量也称为常量
    16.  
    17. 	cout << "一年总共有： " << month << " 个月份" << endl;
    18.  
    19. 	system("pause");
    20. 	return 0;
    21. }

    如果month注释打开则会报错

    严重性    代码    说明    项目    文件    行    禁止显示状态
    错误    C3892    “month”: 不能给常量赋值    01c++写HelloWorld    D:\csdn\c++\01c++写HelloWorld\01c++写HelloWorld\03常量.cpp    15    
     

    6、关键词

    作用是C++中预先保留的单词

     如果用c++关键词命名则会报错

    严重性    代码    说明    项目    文件    行    禁止显示状态
    错误    C2632    “int”后面的“int”非法    01c++写HelloWorld    D:\csdn\c++\01c++写HelloWorld\01c++写HelloWorld\04关键词.cpp    7    

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6. 	//在定义变量或常量时候，不要用关键字
    7. 	//int int =10
    8.  
    9. 	system("pause");
    10. 	return 0;
    11. }

     6、标识符命名规则

    c++规定给标识符（变量、常量）命名时，有一套自己的规则

    标识符不能是关键字

    标识符只能由字母、数字、下划线组成

    第一个字符必须为字母或下划线

    标识符中字母区分大小写

    如果不满足要求则会报错

    严重性    代码    说明    项目    文件    行    禁止显示状态
    错误    C2059    语法错误:“user-defined literal”    01c++写HelloWorld    D:\csdn\c++\01c++写HelloWorld\01c++写HelloWorld\05标识符命名规则.cpp    7    
     

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6. 	//标识符第一个字符只能是字母或下划线
    7. 	int 123abc = 40;
    8. 	int abc = 10;
    9.  
    10. 	system("pause");
    11. 	return 0;
    12. }

    int 123abc = 40;是不行的

    2.2数据类型

    1、整型

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

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	//整型，区别：占用空间不同，取值范围不同
    7. 	//1、短整型 取值范围（-32768~32767）
    8. 	short num1 = 10;
    9. 	//2、整型
    10. 	int num2 = 10;
    11. 	//3、长整型
    12. 	long num3 = 10;
    13. 	//4、长长整型
    14. 	long long num4 = 10;
    15. 	cout << "num1=" << num1 << endl;
    16. 	cout << "num2=" << num2 << endl;
    17. 	cout << "num3=" << num3 << endl;
    18. 	cout << "num4=" << num4 << endl;
    19.  
    20. 	system("pause");
    21.  
    22. 	return 0;
    23. }

     

     2.2、sizeof关键字

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

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//整型:short (2字节) int (4字节) long (4字节) 1ong 1ong (8字节）
    6. 	//可以利用sizeof求出数据类型占用内存大小
    7. 	//语法:sizeof(数据类型 / 变量)
    8.  
    9. 	short num1 = 10;
    10. 	cout << "shaort占用空间为：" << sizeof(short) << endl;
    11. 	int num2 = 10;
    12. 	cout << "int占用空间为：" << sizeof(num2) << endl;
    13.  
    14. 	system("pause");
    15.  
    16. 	return 0;
    17. }

    2.3、浮点型

    作用:用于表示小数。
    浮点型变显分为两种:1.单精度float，2.双精度double。
    两者的区别在于表示的有效数字范围不同。

    1. #include <iostream>;
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//单精度 float
    6. 	//双精度 double
    7.  
    8. 	float f1 = 3.1415926;
    9. 	cout << "F1=" << f1 << endl;
    10.  
    11. 	double d1 = 3.14159263;
    12. 	cout << "d1=" << d1 << endl;
    13.  
    14. 	//统计float和double占用空间
    15. 	cout << "float占用空间为：" << sizeof(float) << endl;//4字节
    16. 	cout << "double占用内存空间为：" << sizeof(double) << endl;//8字节
    17.  
    18. 	//科学技术法
    19. 	float f2 = 3e2;//3 * 10~2;
    20. 	cout << "f2 = " << f2 << endl;
    21.  
    22. 	float f3 = 3e-2;//3 * 0.1~2;
    23. 	cout << "f3 = " << f3 << endl;
    24.  
    25. 	system("pause");
    26.  
    27. 	return 0;
    28. }

    2.4、字符型

    作用:字符型变量用于显示单个字符。
    语法：char ch = 'a'

    注意1:在显示字符型变量时，用单引号将字符括起来，不要用双引号。
    注意2:单引号内只能有—个字符，不可以是字符串。

    C和C++中字符型变品只占用1个字节。
    字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。
    a-97；A-65

     2.5、转义字符

    作用:用于表示一些不能显示出来的ASCII字符。
    现阶段常用转义字符:
    \n

    \\

    \t

    1. #include <iostream>;
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	//换行符  \n
    7. 	cout << "Hello world" << endl;
    8. 	cout << "Hello world\n";//与上面加endl是一样的
    9. 	//输出反斜杠 
    10. 	cout << "\\" << endl;  //输出一个反斜杠
    11. 	//水平制表符  \t
    12. 	cout << "aaa\thelloworld" << endl;
    13. 	cout << "aaaaa\thelloworld" << endl;
    14. 	cout << "aaaa\thelloworld" << endl;
    15.  
    16. 	cout << "aaa  helloworld" << endl;
    17. 	cout << "aaaaa  helloworld" << endl;
    18. 	cout << "aaaa  helloworld" << endl;
    19.  
    20. 	system("pause");
    21.  
    22. 	return 0;
    23. }

     2.6、字符串型

    作用:用于表示—串字符。

    C风格：char 变量名[ ] = “字符串值”

    C++风格：string 变量名 = “字符串值”

    1. //字符串型
    2. #include<iostream>;
    3. using namespace std;
    4. #include<string>//使用C++风格字符串时，要调用头文件。
    5. int main() {
    6.  
    7. 	//C语言字符串
    8. 	char str[] = "Hello world";
    9. 	cout << str << endl;
    10.  
    11. 	//C++字符串
    12. 	string str2 = "hello world";
    13. 	cout << str2 << endl;
    14.  
    15. 	system("pause");
    16.  
    17. 	return 0;
    18. }

     2.7、布尔类型bool

    作用:布尔数据类型代去真或假的值。
    True——真（代表1）
    False——假（代表0）

    1. //布尔型
    2.  
    3. #include<iostream>;
    4. using namespace std;
    5.  
    6. int main() {
    7.  
    8. 	//创建bool数据类型
    9. 	bool flag = true;
    10. 	cout << flag << endl;
    11.  
    12. 	flag = false;
    13. 	cout << flag << endl;
    14.  
    15. 	//查看bool类型所占字节
    16.  
    17. 	cout << "所占字节："<<sizeof(bool) <<endl;
    18.  
    19. 	system("pause");
    20.  
    21. 	return 0;
    22. }

    2.8、数据的输入

    作用:用于从键盘获取数据，输入的数据。
    关键字: cin
    语法:cln >>变量。

    1. #include<iostream>;
    2. using namespace std;
    3. #include<string>
    4. int main() {
    5.  
    6. 	/*
    7. 	//整型
    8. 	int a = 0;
    9. 	cout << "整型变量a赋值：" << endl;
    10. 	cin >> a;//使输入的等于a的整型
    11. 	cout << "整型变量a = " << a <<endl;
    12. 	*/
    13. 	
    14. 	/*
    15. 	//浮点型
    16. 	float f = 3.14f;
    17. 	cout << "浮点型变量f赋值：" << endl;
    18. 	cin >> f;
    19. 	cout << "浮点型变量f = " << f <<endl;
    20.  
    21. 	*/
    22.  
    23. 	//字符型
    24. 	//char ch = 'a';
    25. 	//cout << "字符型变量ch赋值：" << endl;
    26. 	//cin >> ch;
    27. 	//cout << "字符型变量ch = " << ch << endl;
    28.  
    29. 	//字符串型
    30. 	//string str = "hello";
    31. 	//cout << "给str赋值：" << endl;
    32. 	//cin >> str;
    33. 	//cout << "字符串str=" << str << endl;
    34.  
    35. 	//布尔型
    36.  
    37. 	bool flag = true;
    38. 	cout << "给flag赋值：" << endl;
    39. 	cin >> flag;
    40. 	cout << "布尔类型flag=" << flag << endl;
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

     比如bool类型的flag输入非0就是1

     2.3运算符

    3.1、加减乘除与递增递减

    注意：

    1. 被除数不能为0

    2. 除法操作的时候如果为int型会舍弃小数点

    3. 小数不能进行取余运算

    1. #include<iostream>
    2. using namespace std;
    3. int main() {
    4. 	//1.前置递增
    5. 	int a = 10;
    6. 	++a;
    7. 	cout << "a = " << a << endl;
    8.  
    9. 	//1.后置递增
    10. 	int b = 10;
    11. 	b++;
    12. 	cout << "b = " << b << endl;
    13. 	//3.前置递增和后置递增的区别
    14. 	//前置递增 先让变量+1 然后进行表达式运算
    15. 	int a2 = 10;
    16. 	int b2 = ++a2 * 10;
    17. 	cout << "a2 = " << a2 << endl;//11
    18. 	cout << "b2 = " << b2 << endl;//110
    19.  
    20. 	//后置递增 先进行表达式运算，后让变量+1
    21. 	int a3 = 10;
    22. 	int b3 = a3++ * 10;
    23. 	cout << "a3 = " << a3 << endl;//11
    24. 	cout << "b3 = " << b3 << endl;//100
    25. 	system("pause");
    26. 	return 0;
    27. }

     3.2、取模运算

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	//只有整数可以进行取余运算
    7. 	//取模运算本质，就是求余数
    8. 	int a1 = 10;
    9. 	int b1=3;
    10. 	cout << a1 %b1 << endl;
    11.  
    12. 	int a2 = 10;
    13. 	int b2 = 20;
    14. 	cout << a2 % b2 << endl;
    15.  
    16. 	//基于除法运算，所以也做不了取余运算
    17. 	int a3 = 10;
    18. 	int b3 = 0;
    19. 	//cout << a3 % b3 << endl;
    20.  
    21. 	//两个小数是不可以做取余运算的
    22. 	double d1 = 3.14;
    23. 	double d2 = 1.1;
    24. 	//cout << d1 % d2 << endl;
    25. 	return 0;
    26. }

     3.3、赋值运算符

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//赋值运算符
    6.  
    7. 	//	=
    8. 	int a = 10;
    9. 	a = 100;
    10. 	cout << "a=" << a << endl;//100
    11.  
    12. 	//	+=
    13. 	a = 10;
    14. 	a += 2;
    15. 	cout << "a=" << a << endl;//12
    16.  
    17. 	//	-=
    18. 	a = 10;
    19. 	a -=2;
    20. 	cout << "a=" << a << endl;//8
    21.  
    22. 	//	*=
    23. 	a = 10;
    24. 	a *= 2;
    25. 	cout << "a=" << a << endl;//20
    26.  
    27. 	//	/=
    28. 	a = 10;
    29. 	a /= 2;
    30. 	cout << "a=" << a << endl;//5
    31.  
    32. 	//	%=
    33. 	a = 10;
    34. 	a %= 2;
    35. 	cout << "a=" << a << endl;//0
    36.  
    37. 	return 0;
    38. }

     3.4、比较运算符

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//比较运算符
    6.  
    7. 	//	==
    8. 	int a = 10;
    9. 	int b = 20;
    10. 	cout << (a==b) << endl;//0
    11.  
    12. 	//	!=
    13. 	cout << (a != b) << endl;//1
    14.  
    15. 	//	>
    16. 	cout << (a > b) << endl;//0
    17.  
    18. 	//	<
    19. 	cout << (a < b) << endl;//1
    20.  
    21. 	//	>=
    22. 	cout << (a >= b) << endl;//0
    23.  
    24. 	//	<=
    25. 	cout << (a <= b) << endl;//1
    26.  
    27. 	return 0;
    28. }

     

     3.5、逻辑运算符

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	//01	逻辑运算符 非 ！
    7. 	int a =10;
    8. 	// 在C++中 除了0，都为真
    9. 	cout << !a << endl;//0
    10. 	cout << !!a << endl;//1
    11.  
    12. 	//02	逻辑运算符 与 &&  同真为真，其余为假
    13. 	int a1 = 10;
    14. 	int b1 = 10;
    15. 	cout << (a1&&b1)<< endl;//1
    16.  
    17. 	a1 = 0;
    18. 	b1 = 10;
    19. 	cout << (a1&&b1)<< endl;//0
    20.  
    21. 	a1 = 0;
    22. 	b1 = 0;
    23. 	cout << (a1&&b1)<< endl;//0
    24.  
    25. 	//03	逻辑运算符 或 ||  同假为假，其余为真
    26. 	int a2 = 10;
    27. 	int b2 = 10;
    28. 	cout << (a2||b2) << endl;//1
    29.  
    30. 	a2 = 0;
    31. 	b2 = 10;
    32. 	cout << (a2||b2) << endl;//1
    33.  
    34. 	a2 = 0;
    35. 	b2 = 0;
    36. 	cout << (a2||b2) << endl;//0
    37.  
    38. 	return 0;
    39. }

     2.4程序流程结构

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

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

    1.1、选择结构-单行判断

    1. #include<iostream>
    2. using namespace std;
    3. int main() {
    4. 	//选择结构 单行if语句
    5. 	//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
    6. 	int score = 0;
    7. 	cout << "请输入一个分数:" << endl;
    8. 	cin >> score;
    9. 	cout << "您输入的分数为：" << score << endl;
    10. 	if (score >= 600)//这里不要加分号，如果加了分号那么不论条件是否满足，后面的代码都会执行
    11. 	{
    12. 		cout << "考上了一本大学" << endl;
    13. 	}
    14. 	system("pause");
    15. 	return 0;
    16. }

     选择结构-多行判断

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//1、用户输入分数
    6. 	int score = 0;
    7. 	cout << "请输入一个分数:" << endl;
    8. 	cin >> score;
    9.  
    10. 	//2、打印用户输入的分数
    11. 	cout << "您输入的分数为：" << score << endl;
    12.  
    13. 	//3、判断是否大于600，如果大于，那么输出
    14. 	if (score > 600)
    15. 	{
    16. 		cout << "恭喜 您考上了一本大学!";
    17. 	}
    18. 	else
    19. 	{
    20. 		cout << "未考上一本";
    21. 	}
    22. 	return 0;
    23. }

     选择结构-多条件语句

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//1、用户输入分数
    6. 	int score = 0;
    7. 	cout << "请输入一个分数:" << endl;
    8. 	cin >> score;
    9.  
    10. 	//2、打印用户输入的分数
    11. 	cout << "您输入的分数为：" << score << endl;
    12.  
    13. 	//3、分数大于600，视为考上一本大学
    14. 	//大于500，视为考上二本大学，屏幕输出
    15. 	//大于400，视为考上三本大学，屏幕输出
    16. 	//小于等于400，视为未考上本科
    17. 	if (score > 600)
    18. 	{
    19. 		cout << "恭喜 您考上了一本大学!";
    20. 	}
    21. 	else if (score > 500)
    22. 	{
    23. 		cout << "恭喜 您考上了二本大学!";
    24. 	}
    25. 	else if (score > 400)
    26. 	{
    27. 		cout << "恭喜 您考上了二本大学!";
    28. 	}
    29. 	else
    30. 	{
    31. 		cout << "未考上本科";
    32. 	}
    33. 	return 0;
    34. }

     选择结构-嵌套if语句

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a, b, c;
    6. 	cin >> a >> b >> c;
    7. 	cout << "A=" << a << endl;
    8. 	cout << "B=" << b << endl;
    9. 	cout << "C=" << c << endl;
    10. 	if (a>b)// a比b大
    11. 	{
    12. 		if (a>c)//a最大
    13. 		{
    14. 			cout << "A最大" << endl;
    15. 		}
    16. 		else
    17. 		{ 
    18. 			cout << "C最大" << endl;
    19. 		}
    20. 	}
    21. 	else// b比a大
    22. 	{
    23. 		if (b > c)//b最大
    24. 		{
    25. 			cout << "B最大" << endl;
    26. 		}
    27. 		else
    28. 		{
    29. 			cout << "C最大" << endl;
    30. 		}
    31. 	}
    32.  
    33. 	return 0;
    34. }

    判断是否为闰年

    1. #include<iostream>
    2. using namespace std;             //命名空间 
    3.  
    4. int main() {	//主函数
    5. 	int year;
    6. 	cin >> year;
    7. 	if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)//&&优先级更高 
    8. 	{
    9. 		cout << "闰年" << endl;
    10. 	}
    11. 	else
    12. 	{
    13. 		cout << "不是闰年" << endl;
    14. 	}
    15. 	return 0;
    16. }

     三目运算符判断

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

    若表达式1的值为假，则执行表达式3，并返回表达式3的结果

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//三目运算符
    6.  
    7. 	//创建3个变量 a b c
    8. 	// 将a和b做比较，将变量大的值赋值给变量c
    9.  
    10. 	int a = 10;
    11. 	int b = 0;
    12. 	int c;
    13. 	c=(a > b ? a : b);
    14. 	cout << "C=" << c << endl;//10
    15.  
    16. 	//C++中三目运算符返回的是变量，可以继续赋值
    17. 	(a > b ? a : b)=100;
    18. 	cout << "A=" << a << endl;
    19. 	cout << "B=" << b << endl;
    20. 	return 0;
    21. }

    判断一个数是3还是5的倍数

    1. #include<iostream>
    2. using namespace std;             //命名空间 
    3.  
    4. int main() {	//主函数
    5. 	int num;
    6. 	cout << "Please input a number:" << endl;
    7. 	cin >> num;
    8.     
    9.     //法1：
    10. 	(num % 3== 0&&num%5==0) ? 
    11.         cout << "yes" << endl : 
    12.         cout << "no" << endl;
    13.  
    14.     //法2：
    15.     (num % 3 == 0)?
    16. 		((num%5==0) ? cout << "yes" << endl : cout << "no" << endl):
    17. 		cout << "no" << endl;
    18.  
    19. 	return 0;
    20. }

    switch开关

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

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

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5. 	//switch语句
    6. 	//给电影进行打分
    7. 	//10~9 经典
    8. 	//8~7 非常好
    9. 	//6~5 一般
    10. 	//5以下 烂片
    11.  
    12. 	//1、提示用户给电影评分
    13. 	cout << "请给电影评分" << endl;
    14. 	//2、用户开始进行打分
    15. 	int score;
    16. 	cin >> score;
    17. 	cout << "Score=" << score << endl;
    18. 	//3、根据用户输入的分数来提示用户最后的结果
    19. 	switch (score)
    20. 	{
    21. 	case 10:
    22. 			cout << "您认为是经典电影" << endl;
    23. 			break;//退出当前分支
    24. 	case 9:
    25. 		cout << "您认为是经典电影" << endl;
    26. 		break;
    27. 	case 8:
    28. 		cout << "您认为是电影非常好" << endl;
    29. 		break;
    30. 	case 7:
    31. 		cout << "您认为是电影非常好" << endl; 
    32. 		break;
    33. 	case 6:
    34. 		cout << "您认为是电影一般" << endl; 
    35. 		break;
    36. 	case 5:
    37. 		cout << "您认为是电影一般" << endl; 
    38. 		break;
    39. 	default:
    40. 		cout << "您认为是烂片" << endl;
    41. 		break;
    42. 	}
    43. 	//if和switch区别
    44. 	//switch 缺点，判断时候只能是整型或者字符型，不可以是一个区间
    45. 	//switch 有点，结构清晰，执行效率高
    46.  
    47. 	return 0;
    48. }

     while循环猜数字

    1. #include<iostream>
    2. using namespace std;
    3. #include<ctime>
    4.  
    5. int main() {
    6. 	//添加随机数种子 作用利用当前系统时间生成随机数，防止每次随机数都一样
    7. 	srand((unsigned int)time(NULL));
    8.  
    9. 	//1、系统生成随机数
    10. 	int num = rand() % 100 + 1; //生成0~100的随机数
    11. 	cout << num << endl;
    12.  
    13. 	//2、玩家进行猜测
    14.  
    15. 	cout << "请玩家输入猜测的数据：" << endl;
    16. 	int val;	//玩家输入的数据
    17. 	while (1)
    18. 	{
    19. 		cin >> val;
    20. 		//3、判断玩家的猜测
    21. 		if (val > num)
    22. 		{
    23. 			cout << "猜测过大！" << endl;
    24. 		}
    25. 		else if(val < num)
    26. 		{
    27. 			cout << "猜测过小！" << endl;
    28. 		}
    29. 		else
    30. 		{
    31. 			cout << "猜对啦！" << endl;
    32. 			break;	//利用该关键字，退出循环
    33. 		}
    34. 	}
    35.  
    36. 	//猜对 退出游戏
    37. 	//猜错 提示猜的结果，过大或者过小 重新返回第2步
    38. 	return 0;
    39. }

     do...while

    while与do...while的区别：

    do...while无论while中条件是否为真，先执行{}内语句；

    while中条件若为假，则不执行。 

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	int num = 100;
    7. 	do
    8. 	{
    9. 		int a = num % 10;//	个位
    10. 		int b = num / 10 % 10;	//十位
    11. 		int c = num / 100;	//百位
    12. 		if (num == a*a*a+b*b*b+c*c*c)
    13. 		{
    14. 			cout << num << endl;
    15. 		}
    16. 		num++;
    17. 	} while (num<1000);
    18.  
    19. 	return 0;
    20. }

     循环控制

    break：跳出循环

    遇负，则不进行累加，接着加下一个正数

    1. #include <iostream>
    2. using namespace std;
    3. int main()
    4. {
    5. 	int i, n, sum;
    6. 	sum = 0;
    7. 	cout << "input 10 number" << endl;
    8. 	for (i = 1; i <= 10; i++)
    9. 	{
    10. 		cout << i << ":";
    11. 		cin >> n;
    12. 		if (n < 0) 	//判断输入是否为负数,是负数就停止累加 
    13. 			break;
    14. 		sum += n; 	//对输入的数进行累加
    15. 	}
    16. 	cout << "The Result :" << sum << endl;
    17. 	return 0;
    18. }

     continue：跳出本次循环，继续下一次循环

    1. #include <iostream>
    2. using namespace std;
    3. int main()
    4. {
    5. 	int i, n, sum;
    6. 	sum = 0;
    7. 	cout << "input 10 number" << endl;
    8. 	for (i = 1; i <= 10; i++)
    9. 	{
    10. 		cout << i << ":";
    11. 		cin >> n;
    12. 		if (n < 0)	//判断输入是否为负数
    13. 			continue;
    14. 		sum += n;	//对输入的数进行累加
    15. 	}
    16. 	cout << "The Result :" << sum << endl;
    17. 	return 0;
    18. }

     goto：跳转到label，接着往下走

    跳转

    累加1到10

    1. #include <iostream>
    2. using namespace std;
    3. int main()
    4. {
    5. 	int ivar = 0;			//定义一个整型变量，初始化为0
    6. 	int num = 0;			//定义一个整型变量，初始化为0
    7. label:  					//定义一个标签
    8. 	ivar++;					//ivar自加1
    9. 	num += ivar;			//累加求和
    10. 	if (ivar < 10)			//判断ivar是否小于100
    11. 	{
    12. 		goto label;			//转向标签
    13. 	}
    14. 	cout << ivar << num << endl;
    15. 	return 0;
    16. }

      注意点：goto语句不能越过复合语句之外的变量定义的语句，例如，下面是非法的

    1. 	goto label;
    2. 	int i 10;
    3. label:
    4. 	cout << "goto" << endl;

    正确的：

    1. 	goto label;
    2. 	{
    3. 	int i 10; 
    4. 	}
    5. label:
    6. 	cout << "goto" << endl;

    嵌套循环打印三角

    1. #include<iostream>
    2. using namespace std;             //命名空间 
    3.  
    4. int main() {	//主函数
    5. 	int i, j, k;
    6. 	for (i = 1; i <= 5; i++)					//控制行数
    7. 	{
    8. 		for (j = 1; j <= 5 - i; j++)				//控制空格数
    9. 			cout << " ";
    10. 		for (k = 1; k <= 2 * i - 1; k++)			//控制打印*号的数量
    11. 			cout << "*";
    12. 		cout << endl;
    13. 	}
    14. 	return 0;
    15. }

     嵌套循环输出乘法口诀

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	for (int i = 1; i < 10; i++)
    7. 	{
    8. 		for (int j = 1; j <= i; j++) {
    9. 			cout << j << "*" << i << "=" << i * j << "\t";
    10. 		}
    11. 		cout << endl;
    12. 	}
    13.  
    14. 	return 0;
    15. }

     2.5数组

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

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

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

    1.1、一维数组

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

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

    注意：数组名是常量，不可以赋值

    总结1：直接打印数组名，可以查看数组所占内存的首地址

    总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小

    冒泡排序

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

    1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
    3. 重复以上的步骤，每次比较次数-1，直到不需要比较
    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	int arr[9] = { 4,2,8,0,5,7,1,3,9 };
    7.  
    8. 	for (int i = 0; i < 9 - 1; i++)
    9. 	{
    10. 		for (int j = 0; j < 9 - 1 - i; j++)
    11. 		{
    12. 			if (arr[j] > arr[j + 1])
    13. 			{
    14. 				int temp = arr[j];
    15. 				arr[j] = arr[j + 1];
    16. 				arr[j + 1] = temp;
    17. 			}
    18. 		}
    19. 	}
    20.  
    21. 	for (int i = 0; i < 9; i++)
    22. 	{
    23. 		cout << arr[i] << endl;
    24. 	}
    25.  
    26. 	system("pause");
    27.  
    28. 	return 0;
    29. }

     二维数组

    二维数组就是在一维数组上，多加一个维度。

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

    数据类型 数组名[ 行数 ][ 列数 ];
    数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
    数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
    数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
    建议：以上4种定义方式，利用第二种更加直观，提高代码的可读性

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

     总结：在定义二维数组时，如果初始化了数据，可以省略行数

    二维数组数组名

    • 查看二维数组所占内存空间
    • 获取二维数组首地址
    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	//二维数组数组名
    7. 	int arr[2][3] =
    8. 	{
    9. 		{1,2,3},
    10. 		{4,5,6}
    11. 	};
    12.  
    13. 	cout << "二维数组大小： " << sizeof(arr) << endl;
    14. 	cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
    15. 	cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;
    16.  
    17. 	cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
    18. 	cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
    19.  
    20. 	//地址
    21. 	cout << "二维数组首地址：" << arr << endl;
    22. 	cout << "二维数组第一行地址：" << arr[0] << endl;
    23. 	cout << "二维数组第二行地址：" << arr[1] << endl;
    24.  
    25. 	cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
    26. 	cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;
    27.  
    28. 	system("pause");
    29.  
    30. 	return 0;
    31. }

     总结1：二维数组名就是这个数组的首地址

    总结2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

    二维数组应用案例

    考试成绩统计：

    有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩

    1. #include<iostream>
    2. using namespace std;
    3.  
    4.  
    5. int main() {
    6.  
    7. 	int scores[3][3] =
    8. 	{
    9. 		{100,100,100},
    10. 		{90,50,100},
    11. 		{60,70,80},
    12. 	};
    13.  
    14. 	string names[3] = { "张三","李四","王五" };
    15.  
    16. 	for (int i = 0; i < 3; i++)
    17. 	{
    18. 		int sum = 0;
    19. 		for (int j = 0; j < 3; j++)
    20. 		{
    21. 			sum += scores[i][j];
    22. 		}
    23. 		cout << names[i] << "同学总成绩为： " << sum << endl;
    24. 	}
    25.  
    26. 	system("pause");
    27.  
    28. 	return 0;
    29. }

    2.6函数

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

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

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

    1、返回值类型

    2、函数名

    3、参数表列

    4、函数体语句

    5、return 表达式

     函数的调用

    功能：使用定义好的函数

    语法：函数名（参数）

    1. #include<iostream>
    2. using namespace std;
    3.  
    4.  
    5. //函数定义
    6. int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
    7. {
    8. 	int sum = num1 + num2;
    9. 	return sum;
    10. }
    11.  
    12. int main() {
    13.  
    14. 	int a = 10;
    15. 	int b = 10;
    16. 	//调用add函数
    17. 	int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
    18. 	cout << "sum = " << sum << endl;
    19.  
    20. 	a = 100;
    21. 	b = 100;
    22.  
    23. 	sum = add(a, b);
    24. 	cout << "sum = " << sum << endl;
    25.  
    26. 	system("pause");
    27.  
    28. 	return 0;
    29. }

     值传递

    • 所谓值传递，就是函数调用时实参将数值传入给形参
    • 值传递时，如果形参发生改变，并不会影响实参
    1. #include<iostream>
    2. using namespace std;
    3.  
    4. void swap(int num1, int num2)
    5. {
    6. 	cout << "交换前：" << endl;
    7. 	cout << "num1 = " << num1 << endl;
    8. 	cout << "num2 = " << num2 << endl;
    9. 	// 10
    10. 	// 20
    11.  
    12. 	int temp = num1;
    13. 	num1 = num2;
    14. 	num2 = temp;
    15.  
    16. 	cout << "交换后：" << endl;
    17. 	cout << "num1 = " << num1 << endl;
    18. 	cout << "num2 = " << num2 << endl;
    19. 	// 20
    20. 	// 10
    21.  
    22. 	//return ; 当函数声明时候，不需要返回值，可以不写return
    23. }
    24.  
    25. int main() {
    26.  
    27. 	int a = 10;
    28. 	int b = 20;
    29.  
    30. 	swap(a, b);
    31.  
    32. 	cout << "main中的 a = " << a << endl;
    33. 	cout << "main中的 b = " << b << endl;
    34. 	// 10
    35. 	// 20
    36.  
    37. 	system("pause");
    38.  
    39. 	return 0;
    40. }

     总结： 值传递时，形参是修饰不了实参的

    6.5 函数的常见样式

    常见的函数样式有4种

    1. 无参无返
    2. 有参无返
    3. 无参有返
    4. 有参有返
    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. }

    函数的声明

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

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

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

    函数的分文件编写

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

    函数分文件编写一般有4个步骤

    1. 创建后缀名为.h的头文件
    2. 创建后缀名为.cpp的源文件
    3. 在头文件中写函数的声明
    4. 在源文件中写函数的定义
    1. //swap.h文件
    2. #include<iostream>
    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. }

    2.7指针

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

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

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

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	//1、指针的定义
    7. 	int a = 10; //定义整型变量a
    8.  
    9. 	//指针定义语法： 数据类型 * 变量名 ;
    10. 	int* p;
    11.  
    12. 	//指针变量赋值
    13. 	p = &a; //指针指向变量a的地址
    14. 	cout << &a << endl; //打印数据a的地址
    15. 	cout << p << endl;  //打印指针变量p
    16. 	//0073F8BC
    17. 	//0073F8BC
    18.  
    19. 	//2、指针的使用
    20. 	//通过*操作指针变量指向的内存
    21. 	cout << "*p = " << *p << endl;
    22. 	// *p = 10
    23.  
    24. 	system("pause");
    25.  
    26. 	return 0;
    27. }

     指针变量和普通变量的区别

    • 普通变量存放的是数据,指针变量存放的是地址
    • 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

    总结1： 我们可以通过 & 符号 获取变量的地址

    总结2：利用指针可以记录地址

    总结3：对指针变量解引用，可以操作指针指向的内存

    指针所占内存空间

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	int a = 10;
    7.  
    8. 	int * p;
    9. 	p = &a; //指针指向数据a的地址
    10.  
    11. 	cout << *p << endl; //* 解引用
    12. 	cout << sizeof(p) << endl;
    13. 	cout << sizeof(char *) << endl;
    14. 	cout << sizeof(float *) << endl;
    15. 	cout << sizeof(double *) << endl;
    16.  
    17. 	system("pause");
    18.  
    19. 	return 0;
    20. }

    总结：所有指针类型在32位操作系统下是4个字节

    空指针和野指针

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

    用途：初始化指针变量

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

    空指针:

    1. int main() {
    2.  
    3. 	//指针变量p指向内存地址编号为0的空间
    4. 	int * p = NULL;
    5.  
    6. 	//访问空指针报错 
    7. 	//内存编号0 ~255为系统占用内存，不允许用户访问
    8. 	cout << *p << endl;
    9.  
    10. 	system("pause");
    11.  
    12. 	return 0;
    13. }

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

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	//指针变量p指向内存地址编号为0x1100的空间
    7. 	int* p = (int*)0x1100;
    8.  
    9. 	//访问野指针报错 
    10. 	cout << *p << endl;
    11.  
    12. 	system("pause");
    13.  
    14. 	return 0;
    15. }

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

    const修饰指针

    const修饰指针有三种情况

    1. const修饰指针 — 常量指针
    2. const修饰常量 — 指针常量
    3. const既修饰指针，又修饰常量
    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	int a = 10;
    7. 	int b = 10;
    8.  
    9. 	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
    10. 	const int* p1 = &a;
    11. 	p1 = &b; //正确
    12. 	//*p1 = 100;  报错
    13.  
    14.  
    15. 	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    16. 	int* const p2 = &a;
    17. 	//p2 = &b; //错误
    18. 	*p2 = 100; //正确
    19.  
    20. 	//const既修饰指针又修饰常量
    21. 	const int* const p3 = &a;
    22. 	//p3 = &b; //错误
    23. 	//*p3 = 100; //错误
    24.  
    25. 	system("pause");
    26.  
    27. 	return 0;
    28. }

     指针和数组

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. int main() {
    5.  
    6. 	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    7.  
    8. 	int* p = arr;  //指向数组的指针
    9.  
    10. 	cout << "第一个元素： " << arr[0] << endl;
    11. 	cout << "指针访问第一个元素： " << *p << endl;
    12.  
    13. 	for (int i = 0; i < 10; i++)
    14. 	{
    15. 		//利用指针遍历数组
    16. 		cout << *p << endl;
    17. 		p++;
    18. 	}
    19.  
    20. 	system("pause");
    21.  
    22. 	return 0;
    23. }

    指针和函数

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

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //值传递
    5. void swap1(int a, int b)
    6. {
    7. 	int temp = a;
    8. 	a = b;
    9. 	b = temp;
    10. }
    11. //地址传递
    12. void swap2(int* p1, int* p2)
    13. {
    14. 	int temp = *p1;
    15. 	*p1 = *p2;
    16. 	*p2 = temp;
    17. }
    18.  
    19. int main() {
    20.  
    21. 	int a = 10;
    22. 	int b = 20;
    23. 	swap1(a, b); // 值传递不会改变实参
    24.  
    25. 	swap2(&a, &b); //地址传递会改变实参
    26.  
    27. 	cout << "a = " << a << endl;
    28.  
    29. 	cout << "b = " << b << endl;
    30.  
    31. 	system("pause");
    32.  
    33. 	return 0;
    34. }

     指针、数组、函数案例

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

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

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //冒泡排序函数
    5. void bubbleSort(int* arr, int len)  //int * arr 也可以写为int arr[]
    6. {
    7. 	for (int i = 0; i < len - 1; i++)
    8. 	{
    9. 		for (int j = 0; j < len - 1 - i; j++)
    10. 		{
    11. 			if (arr[j] > arr[j + 1])
    12. 			{
    13. 				int temp = arr[j];
    14. 				arr[j] = arr[j + 1];
    15. 				arr[j + 1] = temp;
    16. 			}
    17. 		}
    18. 	}
    19. }
    20.  
    21. //打印数组函数
    22. void printArray(int arr[], int len)
    23. {
    24. 	for (int i = 0; i < len; i++)
    25. 	{
    26. 		cout << arr[i] << endl;
    27. 	}
    28. }
    29.  
    30. int main() {
    31.  
    32. 	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
    33. 	int len = sizeof(arr) / sizeof(int);
    34.  
    35. 	bubbleSort(arr, len);
    36.  
    37. 	printArray(arr, len);
    38.  
    39. 	system("pause");
    40.  
    41. 	return 0;
    42. }

     总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

    结构体

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

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

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

    • struct 结构体名 变量名
    • struct 结构体名 变量名 = { 成员1值 ， 成员2值…}
    • 定义结构体时顺便创建变量
    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //结构体定义
    5. struct student
    6. {
    7. 	//成员列表
    8. 	string name;  //姓名
    9. 	int age;      //年龄
    10. 	int score;    //分数
    11. }stu3; //结构体变量创建方式3 
    12.  
    13.  
    14. int main() {
    15.  
    16. 	//结构体变量创建方式1
    17. 	struct student stu1; //struct 关键字可以省略
    18.  
    19. 	stu1.name = "张三";
    20. 	stu1.age = 18;
    21. 	stu1.score = 100;
    22.  
    23. 	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age << " 分数：" << stu1.score << endl;
    24.  
    25. 	//结构体变量创建方式2
    26. 	struct student stu2 = { "李四",19,60 };
    27.  
    28. 	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age << " 分数：" << stu2.score << endl;
    29.  
    30.  
    31. 	stu3.name = "王五";
    32. 	stu3.age = 18;
    33. 	stu3.score = 80;
    34.  
    35.  
    36. 	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age << " 分数：" << stu3.score << endl;
    37.  
    38. 	system("pause");
    39.  
    40. 	return 0;
    41. }

    总结1：定义结构体时的关键字是struct，不可省略 

    总结2：创建结构体变量时，关键字struct可以省略

    总结3：结构体变量利用操作符 ‘’.’’ 访问成员

    结构体数组 

    作用：将自定义的结构体放入到数组中方便维护

    语法：struct 结构体名 数组名[元素个数] = { {} , {} , ... {} }

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //结构体定义
    5. struct student
    6. {
    7. 	//成员列表
    8. 	string name;  //姓名
    9. 	int age;      //年龄
    10. 	int score;    //分数
    11. };
    12.  
    13. int main() {
    14.  
    15. 	//结构体数组
    16. 	struct student arr[3] =
    17. 	{
    18. 		{"张三",18,80 },
    19. 		{"李四",19,60 },
    20. 		{"王五",20,70 }
    21. 	};
    22.  
    23. 	for (int i = 0; i < 3; i++)
    24. 	{
    25. 		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
    26. 	}
    27.  
    28. 	system("pause");
    29.  
    30. 	return 0;
    31. }

     结构体指针

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

    • 利用操作符 ->可以通过结构体指针访问结构体属性
    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //结构体定义
    5. struct student
    6. {
    7. 	//成员列表
    8. 	string name;  //姓名
    9. 	int age;      //年龄
    10. 	int score;    //分数
    11. };
    12.  
    13.  
    14. int main() {
    15.  
    16. 	struct student stu = { "张三",18,100, };
    17.  
    18. 	struct student* p = &stu;
    19.  
    20. 	p->score = 80; //指针通过 -> 操作符可以访问成员
    21.  
    22. 	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
    23.  
    24. 	system("pause");
    25.  
    26. 	return 0;
    27. }

     结构体嵌套结构体

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

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

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //学生结构体定义
    5. struct student
    6. {
    7. 	//成员列表
    8. 	string name;  //姓名
    9. 	int age;      //年龄
    10. 	int score;    //分数
    11. };
    12.  
    13. //教师结构体定义
    14. struct teacher
    15. {
    16. 	//成员列表
    17. 	int id; //职工编号
    18. 	string name;  //教师姓名
    19. 	int age;   //教师年龄
    20. 	struct student stu; //子结构体 学生
    21. };
    22.  
    23.  
    24. int main() {
    25.  
    26. 	struct teacher t1;
    27. 	t1.id = 10000;
    28. 	t1.name = "老王";
    29. 	t1.age = 40;
    30.  
    31. 	t1.stu.name = "张三";
    32. 	t1.stu.age = 18;
    33. 	t1.stu.score = 100;
    34.  
    35. 	cout << "教师 职工编号： " << t1.id << " 姓名： " << t1.name << " 年龄： " << t1.age << endl;
    36.  
    37. 	cout << "辅导学员 姓名： " << t1.stu.name << " 年龄：" << t1.stu.age << " 考试分数： " << t1.stu.score << endl;
    38.  
    39. 	system("pause");
    40.  
    41. 	return 0;
    42. }

     总结：在结构体中可以定义另一个结构体作为成员，用来解决实际问题

    结构体做函数参数

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

    传递方式有两种：

    • 值传递
    • 地址传递
    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //学生结构体定义
    5. struct student
    6. {
    7. 	//成员列表
    8. 	string name;  //姓名
    9. 	int age;      //年龄
    10. 	int score;    //分数
    11. };
    12.  
    13. //值传递
    14. void printStudent(student stu)
    15. {
    16. 	stu.age = 28;
    17. 	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;
    18. }
    19.  
    20. //地址传递
    21. void printStudent2(student* stu)
    22. {
    23. 	stu->age = 28;
    24. 	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age << " 分数：" << stu->score << endl;
    25. }
    26.  
    27. int main() {
    28.  
    29. 	student stu = { "张三",18,100 };
    30. 	//值传递
    31. 	printStudent(stu);
    32. 	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;
    33.  
    34. 	cout << endl;
    35.  
    36. 	//地址传递
    37. 	printStudent2(&stu);
    38. 	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;
    39.  
    40. 	system("pause");
    41.  
    42. 	return 0;
    43. }

     总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

    结构体中 const使用场景

    作用：用const来防止误操

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //学生结构体定义
    5. struct student
    6. {
    7. 	//成员列表
    8. 	string name;  //姓名
    9. 	int age;      //年龄
    10. 	int score;    //分数
    11. };
    12.  
    13. //const使用场景
    14. void printStudent(const student* stu) //加const防止函数体中的误操作
    15. {
    16. 	//stu->age = 100; //操作失败，因为加了const修饰
    17. 	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;
    18.  
    19. }
    20.  
    21. int main() {
    22.  
    23. 	student stu = { "张三",18,100 };
    24.  
    25. 	printStudent(&stu);
    26.  
    27. 	system("pause");
    28.  
    29. 	return 0;
    30. }

     通讯录管理系统

    通讯录是一个可以记录亲人、好友信息的工具
    本教程主要利用C++来实现一个通讯录管理系统
    系统中需要实现的功能如下：

    • 添加联系人：向通讯录中添加新人，信息包括（姓名、性别、年龄、联系电话、家庭住址）最多1000人
    • 显示联系人：显示通讯录中所有联系人信息
    • 删除联系人：按照姓名进行删除指定联系人
    • 查找联系人：按照姓名查看指定联系人信息
    • 修改联系人：按照姓名重新修改指定联系人信息
    • 清空联系人：清空通讯录中所有信息
    • 退出通讯录：退出当前使用的通讯录
    1. #include <iostream>
    2. #include <string>
    3.  
    4. using namespace std;
    5.  
    6. //1. 菜单
    7. void showMenu()
    8. {
    9.     cout << "*************************" << endl;
    10.     cout << "***** 1、添加联系人 *****" << endl;
    11.     cout << "***** 2、显示联系人 *****" << endl;
    12.     cout << "***** 3、删除联系人 *****" << endl;
    13.     cout << "***** 4、查找联系人 *****" << endl;
    14.     cout << "***** 5、修改联系人 *****" << endl;
    15.     cout << "***** 6、清空联系人 *****" << endl;
    16.     cout << "***** 7、退出通讯录 *****" << endl;
    17.     cout << "*************************" << endl;
    18. }
    19.  
    20. //设计联系人结构体
    21. struct Person
    22. {
    23.     string m_Name;
    24.     int m_Sex;
    25.     int m_Age;
    26.     string m_Phone;
    27.     string m_Addr;
    28. };
    29.  
    30. //设计通讯录结构体
    31.  
    32. //#define MAX  1000  //最大人数
    33. const int MAX = 1000;
    34.  
    35. struct Addressbooks
    36. {
    37.  
    38.     struct Person personArray[MAX];
    39.     int m_Size = NULL;
    40. };
    41.  
    42. //添加联系人
    43. void addPerson(Addressbooks* abs)
    44. {
    45.     //判断通讯录是否已满，如果满了就不再添加
    46.     if (abs->m_Size == MAX)
    47.     {
    48.         cout << "通讯录已满，无法添加！" << endl;
    49.         return;
    50.     }
    51.     else
    52.     {
    53.         //添加具体联系人
    54.  
    55.         //姓名
    56.         string name;
    57.         cout << "请输入姓名： " << endl;
    58.         cin >> name;
    59.         abs->personArray[abs->m_Size].m_Name = name;
    60.  
    61.         //性别
    62.         int sex;
    63.         cout << "请输入性别： " << endl;
    64.         cout << "1 --- 男" << endl;
    65.         cout << "2 --- 女" << endl;
    66.         while (true)
    67.         {
    68.             // 判断输入性别是否符合要求，否则一直循环输入
    69.             cin >> sex;
    70.             if (sex == 1 || sex == 2)
    71.             {
    72.                 abs->personArray[abs->m_Size].m_Sex = sex;
    73.                 break;
    74.             }
    75.             else
    76.             {
    77.                 cout << "性别输入有误，请重新输入！" << endl;
    78.             }
    79.         }
    80.  
    81.         //年龄
    82.         cout << "请输入年龄： " << endl;
    83.         int age;
    84.         cin >> age;
    85.         abs->personArray[abs->m_Size].m_Age = age;
    86.  
    87.         //电话
    88.         cout << "请输入联系电话： " << endl;
    89.         string phone;
    90.         cin >> phone;
    91.         abs->personArray[abs->m_Size].m_Phone = phone;
    92.  
    93.         //地址
    94.         cout << "请输入地址： " << endl;
    95.         string address;
    96.         cin >> address;
    97.         abs->personArray[abs->m_Size].m_Addr = address;
    98.  
    99.         //更新通讯录人数
    100.         abs->m_Size++;
    101.  
    102.         cout << "添加成功！" << endl;
    103.     }
    104.     system("pause"); //请按任意键继续
    105.     system("cls"); //清屏操作
    106. }
    107.  
    108. //显示所有联系人
    109. void showPerson(Addressbooks* abs)
    110. {
    111.     if (abs->m_Size == 0)
    112.     {
    113.         cout << "通讯录为空！" << endl;
    114.     }
    115.     else
    116.     {
    117.         for (int i = 0; i < abs->m_Size; i++)
    118.         {
    119.             cout << "姓名： " << abs->personArray[i].m_Name << "\t";
    120.             cout << "性别： " << (abs->personArray[i].m_Sex == 1 ? "男" : "女") << "\t";
    121.             cout << "年龄： " << abs->personArray[i].m_Age << "\t";
    122.             cout << "电话： " << abs->personArray[i].m_Phone << "\t";
    123.             cout << "住址： " << abs->personArray[i].m_Addr << endl;
    124.         }
    125.     }
    126.     system("pause");
    127.     system("cls");
    128.  
    129. }
    130.  
    131. //检测联系人是否存在，如果存在，返回联系人所在数组中的具体位置，不存在返回-1
    132. //参数1 通讯录 参数2 对比姓名
    133. int isExist(Addressbooks* abs, string name)
    134. {
    135.     for (int i = 0; i < abs->m_Size; i++)
    136.     {
    137.         if (abs->personArray[i].m_Name == name)
    138.         {
    139.             return i;
    140.         }
    141.     }
    142.     return -1; //如果遍历结束都没有找到，则返回-1;
    143. }
    144.  
    145. //删除指定的联系人
    146. void deletePerson(Addressbooks* abs)
    147. {
    148.     cout << "请输入要删除的联系人姓名" << endl;
    149.     string name;
    150.     cin >> name;
    151.     int ret = isExist(abs, name);
    152.  
    153.     if (ret != -1)
    154.     {
    155.         //查找到人，要进行删除操作
    156.         for (int i = ret; i < abs->m_Size; i++)
    157.         {
    158.             //数据前移覆盖
    159.             abs->personArray[i] = abs->personArray[i + 1];
    160.         }
    161.         abs->m_Size--; //更新通讯录中的人员数
    162.         cout << "删除成功" << endl;
    163.     }
    164.     else
    165.     {
    166.         cout << "查无此人" << endl;
    167.     }
    168.     system("pause");
    169.     system("cls");
    170. }
    171.  
    172. //查找联系人
    173. void findPerson(Addressbooks* abs)
    174. {
    175.     cout << "请输入您要查找的联系人" << endl;
    176.     string name;
    177.     cin >> name;
    178.  
    179.     //判断指定的联系人是否存在通讯录中
    180.     int ret = isExist(abs, name);
    181.  
    182.     if (ret != -1)
    183.     {
    184.         cout << "姓名：" << abs->personArray[ret].m_Name << "\t";
    185.         cout << "性别：" << abs->personArray[ret].m_Sex << "\t";
    186.         cout << "年龄：" << abs->personArray[ret].m_Age << "\t";
    187.         cout << "电话：" << abs->personArray[ret].m_Phone << "\t";
    188.         cout << "地址：" << abs->personArray[ret].m_Addr << endl;
    189.     }
    190.     else
    191.     {
    192.         cout << "查无此人" << endl;
    193.     }
    194.     system("pause");
    195.     system("cls");
    196. }
    197.  
    198. //修改指定联系人信息
    199. void modifyPerson(Addressbooks* abs)
    200. {
    201.     cout << "请输入要修改的联系人姓名" << endl;
    202.     string name;
    203.     cin >> name;
    204.     int ret = isExist(abs, name);
    205.  
    206.     if (ret != -1)
    207.     {
    208.         //姓名
    209.         string name;
    210.         cout << "请输入姓名： " << endl;
    211.         cin >> name;
    212.         abs->personArray[ret].m_Name = name;
    213.         //性别
    214.         int sex;
    215.         cout << "请输入性别： " << endl;
    216.         cout << "1 --- 男 " << endl;
    217.         cout << "2 --- 女 " << endl;
    218.         while (true) {
    219.             cin >> sex;
    220.             if (sex == 1 || sex == 2)
    221.             {
    222.                 abs->personArray[ret].m_Sex = sex;
    223.                 break;
    224.             }
    225.             cout << "输入有无，请重新输入" << endl;
    226.         }
    227.  
    228.         //年龄
    229.         cout << "请输入年龄：" << endl;
    230.         int age;
    231.         cin >> age;
    232.         abs->personArray[ret].m_Age = age;
    233.  
    234.         //电话
    235.         cout << "请输入联系电话：" << endl;
    236.         int phone;
    237.         cin >> phone;
    238.         abs->personArray[ret].m_Phone = phone;
    239.  
    240.         //地址
    241.         cout << "请输入地址：" << endl;
    242.         string address;
    243.         cin >> address;
    244.         abs->personArray[ret].m_Addr = address;
    245.  
    246.         cout << "修改成功！" << endl;
    247.     }
    248.     else
    249.     {
    250.         cout << "查无此人" << endl;
    251.     }
    252.     system("pause");
    253.     system("cls");
    254. }
    255.  
    256. //清空联系人
    257. void cleanPerson(Addressbooks* abs)
    258. {
    259.     abs->m_Size = 0;
    260.     cout << "通讯录已清空" << endl;
    261.     system("pause");
    262.     system("cls");
    263. }
    264.  
    265.  
    266. int main()
    267. {
    268.     //创建通讯录结构体变量
    269.     Addressbooks abs;
    270.     //初始化通讯录中当前人员个数
    271.     abs.m_Size = 0;
    272.  
    273.     //创建用户选择输入的变量
    274.     int select = 0;
    275.  
    276.     //使程序一直循环
    277.     while (true)
    278.     {
    279.         //菜单调用
    280.         showMenu();
    281.  
    282.         //接收键盘输入的值
    283.         cin >> select;
    284.  
    285.         //根据输入的值，做出相应的操作
    286.         switch (select)
    287.         {
    288.         case 1:
    289.             addPerson(&abs); // 利用地址传递可以修改实参
    290.             break;
    291.         case 2:
    292.             showPerson(&abs); //显示联系人
    293.             break;
    294.         case 3:
    295.             deletePerson(&abs);
    296.             break;
    297.         case 4:
    298.             findPerson(&abs);
    299.             break;
    300.         case 5:
    301.             modifyPerson(&abs);
    302.             break;
    303.         case 6:
    304.             cleanPerson(&abs);
    305.             break;
    306.         case 0:
    307.             cout << "欢迎下次使用" << endl;
    308.             system("pause");
    309.             return 0;
    310.             break;
    311.         default:
    312.             break;
    313.         }
    314.  
    315.     }
    316.     system("pause");
    317.     return 0;
    318.  
    319. }

  • 相关阅读:
    网络安全人才缺口超百万，如今的就业情况怎样？
    Jackson中处理双向关系的最佳方法
    稀疏表存储和查询
    RabbitMQ 安装 示例 全面了解有这一篇就够了
    云计算概论 --云安全机制
    Unreal Engine（虚幻引擎）渲染 – 正确使用方法
    计数类dp，完全背包，900. 整数划分
    【Web安全】pikachu靶场做题过程
    LeetCode 题目 65：有效数字（Valid Number）【python】
    kafka可视化工具Kafka Tool安装使用
  • 原文地址：https://blog.csdn.net/qq_34904125/article/details/125420060