Visual Studio 2022版本 B站黑马程序员C++自学分享－第一阶段（主要包括：自己敲的代码、通过注释来备注上自己对代码的理解）
前言
黑马的课程里面分为了三大阶段
一、第一阶段 C++基础语法入门 对C++有初步了解，能够有基础编程能力
二、第二阶段 C++核心编程 介绍C++面向对象编程，为大型项目做铺垫
三、第三阶段 C++提高编程 介绍C++泛型编程思想，以及STL的基本使用
※※※我会一个阶段发一个文章，一共发布三个文章来把学习的代码还有自己在代码旁边标注的对于这些代码的理解和心得体会一起分享给大家！！！
该文章的目的：
1.把本人跟着黑马敲的代码都发布在文章内，供大家复制粘贴和参考等等
2.就当作存储代码的一个云空间了，放在电脑里还占内存
3.在学习的时候，对于代码的理解我都在旁边进行了注释，望大家能够快速消化吸收
因为本人还有好多代码是没有深究的，到了后来我记得有一个地方要在类内成员函数后面要加const的这个（2022版本要敲，但是黑马那个2015的就不用），类似的等等，没有特别研究，是看弹幕大佬这么说的我就这么去敲的，所以如果大家能够对这篇文章所有的代码有疑问的话请积极在评论区留言，大家一块讨论。
一、第一阶段 C++基础语法入门 对C++有初步了解，能够有基础编程能力
附：图片：ASCII码表、C++常用标识符（关键字）、算术运算符
1.Hello World
#include <iostream> //包含基本的库
using namespace std;//不写这段代码的话，下面每一行前面都要加上“std::”
int main()
{
cout<<"Hello world"<<endl;
cout<<""你好世界"<<endl;
system("pause");
return 0;
}
2.基础入门
2.1注释
/*
注释
作用：在代码中加一些说明和解释，方便自己或其他程序员阅读代码
两种格式：
1.单行注释： //描述信息
通常放在一行代码上方，或者一条语句的末尾，对该行代码进行说明
2.多行注释： /*描述信息*/
/*
通常放在一段代码的上方，对该段代码做整体说明
提示：编译器在编译代码时，会忽略注释的内容
*/
/*
main是一个程序的入口，每个程序都必须有这么一个函数，有且只有一个
如果源文件里“注释.cpp”有了main（）函数的话“书写Hello World”里面的main函数就要改一下，比如改成main1（）
*/
#include <iostream>
using namespace std;
int main1()
{
cout << "hello world" << endl;
return 0;
}
2.2变量
#include <iostream>
using namespace std;
//变量存在的意义：方便我们管理内存空间
//变量创建的语法： 数据类型 变量名 = 变量初始值
//例： int a = 10
int main2()
{
int a = 0;
cout << a << endl;
system("pause");
return 0;
}
2.3常量
//作用：用于记录程序中不可更改的数据
/*
C++定义常量两种方式
1.#define 宏常量： #define 常量名 常量值
通常在文件(main函数）上方定义，表示一个常量
2.const修饰的变量： const 数据类型 常量名 = 常量值
通常在变量定义前加关键字const，修饰该变量为常量，不可修改
*/
#include <iostream>
using namespace std;
//1.#define 宏常量
#define Day 7
int main3()
{
//1.宏常量
//Day=14; 宏常量不能修改，否则报错
cout << "一周有" << Day << "天" << endl;
//2.const修饰的变量
const int month = 12;
//month = 24; 错误，const修饰的变量也成为常量
cout << "一年有" << month << "个月" << endl;
system("pause");
return 0;
}
2.4关键字（标识符）
//作用：关键字是C++中预先保留的单词（标识符）
//在定义变量或者常量时候，不要用关键字，否则会产生歧义
#include <iostream>
using namespace std;
int main4()
{
//int int = 10; 错误，第二个int是关键字，不可以作为变量的名称
system("pause");
return 0;
}
2.5标识符命名规则
//作用：C++规定给标识符（变量、常量）命名时，有一套自己的规则
/*
规定：
标识符不能是关键字
标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符中字母区分大小写
*/
#include <iostream>
using namespace std;
int main5()
{
//1.标识符不可以是关键字
//int int = 1;
//2.标识符是由字母、数字。下划线构成
int abc = 11;
int _abc = 1;
int _123abc = 13;
//3.标识符第一个字符只能是字母或下划线
//int 123abc = 23;报错
//4.标识符区分大小写
int aaa = 13;
cout << aaa << endl;
//cout << AAA << endl;报错，aaa和AAA不是同一个名称
system("pause");
return 0;
}
3.数据类型
3.1整型
作用：整型变量表示的是整数类型的数据
C++中能够表示整型的类型有以下几种方式，区别在于所占内存空间不同：
3.2sizeof关键字
//sizeof 关键字
//作用：利用sizeof关键字可以统计数据类型所占内存大小
//语法：sizeof(数据类型/变量)
#include <iostream>
using namespace std;
int main2()
{
//整型(占的字节)：short（2），int(4),long(4),long long(8)
//可利用sizeof求出数据类型占用内存大小
short num1 = 10;
cout << "short占用内存空间为：" << sizeof(short) << endl;
cout << "short占用内存空间为：" << sizeof(num1) << endl;
int num2 = 10;
cout << "int占用内存空间为：" << sizeof(int) << endl;
cout << "int占用内存空间为：" << sizeof(num2) << endl;
long num3 = 10;
cout << "long占用内存空间为：" << sizeof(long) << endl;
cout << "long占用内存空间为：" << sizeof(num3) << endl;
long long num4 = 10;
cout << "long long占用内存空间为：" << sizeof(long long) << endl;
cout << "long long占用内存空间为：" << sizeof(num4) << endl;
double num5 = 10.0;
cout << "double占用内存空间为：" << sizeof(double) << endl;
cout << "double占用内存空间为：" << sizeof(num5) << endl;
float num6 = 10.0;
cout << "float占用内存空间为：" << sizeof(float) <<endl;
cout << "float占用内存空间为：" << sizeof(num6) << endl;
system("pause");
return 0;
}
3.3实型（浮点型）
//作用：用于表示小数
//浮点型变量分为两种：1.单精度float 2.双精度double
//两者区别在于表示的有效数字范围不同：
//float占4个字节，表示7位有效数字
//double占8个字节，表示15-16位有效数字
#include <iostream>
using namespace std;
int main3()
{
//1、单精度float
float f1 = 3.1415926f;//后面不敲f的话，系统默认小数是双精度；敲f的话直接标明了就是单精度
cout << "f1 = " << f1 << endl;
//2、双精度
double d1 = 3.1415926;
cout << "d1 = " << d1 << endl;
//默认情况下，编译调试后都只能输出一个小数的6位有效数字
//科学计数法
float f2 = 3e2;//3*10^2=300
cout << "f2 = " << f2 << endl;
float f3 = 3e-2;//3*0.1^2=0.03
cout << "f3 = " << f3 << endl;
system("pause");
return 0;
}
3.4字符型
/*
一、作用：字符型变量用于显示单个字符
二、语法： char ch = 'a'
三、注意：1.在显示字符型变量时，用单引号将字符包括起来，不要用双引号
2.单引号内只能有一个字符，不可以是字符串
四、C和C++中字符型变量只占用1个字节
五、字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元
*/
#include <iostream>
using namespace std;
int main4()
{
//1、字符型变量创建方式
char ch = 'a';
cout << ch << endl;
//2、字符型变量所占内存大小
cout << "char字符型变量所占内存" << sizeof(char) << endl;
//3、字符型变量常见错误
// char ch2 = "b";创建字符型变量时，要用单引号
// char ch3 = 'abcdef';创建字符型变量时，单引号内只能有一个字符
//4、字符型变量对应ASCII编码
cout << (int)ch << endl;//a=97,b=98......z=122
//A=65，B=66......Z=90
system("pause");
return 0;
}
//ASCII码大致由以下两部分组成：
//1、ASCII非打印控制字符：ASCII表上的数字0-31分配给了控制字符，用于控制像打印机等一些外围设备
//2、ASCII打印字符：数字32-126分配给了能在键盘上找到的字符，当查看或打印文档时就会出现
3.5转义字符
/*
作用：用于表示一些不能显示出来的ASCII字符
现阶段我们常用的转义字符有： \n（换行）、 \t（水平制表）、
\\ （代表一个反斜线字符\)
*/
#include <iostream>
using namespace std;
int main5()
{
//转义字符
// 换行符\n
cout << "hello world";
cout << "hello world\n";
// 反斜杠\\
cout << "\\" << endl;
// 水平制表符\t 作用是可以整齐地输出数据，使前八位变整齐
cout << "a\thelloworld" << endl;//a+7个空格
cout << "aa\thelloworld" << endl;//aa+6个空格
cout << "aaa\thelloworld" << endl;//aaa+5个空格
cout << "aaaa\thelloworld" << endl;//aaaa+4个空格
system("pause");
return 0;
}
3.6字符串型
//作用：用于表示一串字符
#include <iostream>
using namespace std;
#include<string> //用C++风格字符串的时候，要包含该头文件
int main6()
{
//C风格字符串
//语法： char 字符串名 []=""(要用双引号)
char str[] = "hello world";
cout << str << endl;
//C++风格字符串
//包含一个头文件 #include<string>
string str2 = "hello world";
cout << str2 << endl;
system("pause");
return 0;
}
3.7布尔类型bool
/*
一、作用：布尔数据类型代表真或假的值
二、bool类型只有两个值：
true - 真（本质是1）
false - 假（本质是0）
三、布尔类型占1个字节大小
*/
#include <iostream>
using namespace std;
int main7()
{
//1、创建bool数据类型
bool flag = true;//true代表真
cout << flag << endl;
flag = false;//false代表假
cout << flag << endl;
//2、查看bool类型所占内存空间
cout << "bool类型所占内存空间： " << sizeof(bool) << endl;
return 0;
}
3.8数据的输入
#include <iostream>
using namespace std;
#include <string>
int main8()
{
//1、整型
int a = 0;
cout << "请给整型变量a赋值： " << endl;
cin >> a;
cout << "整型变量a = " << a << endl;
//2、浮点型
float f = 3.1;
double d = 2.4;
cout << "请给浮点型变量f和d赋值" << endl;
cin >> f >> d;
cout << "单精度浮点型变量f = " << f << "双精度浮点型变量 d = " << d<<endl;
//3、字符型
char ch = 'a';
cout << "请给字符型变量ch赋值" << endl;
cin >> ch;
cout << "字符型变量ch = " << ch << endl;
//4、字符串型
string str = "hello";
cout << "请给字符串str赋值" << endl;
cin >> str;
cout << "字符串str = " << str << endl;
//5、布尔类型
bool flag = false;
cout << "请给bool类型的flag赋值" << endl;
cin >> flag;//bool类型 只要是非0的值都代表真
cout << "布尔类型flag = " << flag << endl;
system("pause");
return 0;
}
4.运算符
4.1算术运算符
#include <iostream>
using namespace std;
int main1()
{
//1、加减乘除、取余数
int a = 2; int b = 3;
cout << "a + b = "<< a + b << endl;
cout << "a - b = "<< a - b << endl;
cout << "a * b = "<< a * b << endl;
cout << "a / b = "<< a / b << endl;//两个整数相除，结果依然是整数，将小数部分去除
cout << "a % b = "<< a % b << endl;// %取余数（取模）
cout << "b % a = "<< b % a << endl;
int c = 3; int d = 0;
//cout << c / d << endl;//相除时，避免除数为0
//cout << c % d << endl;//取余时，避免除数为0
//两个小数相除
double d1 = 9.44;
double d2 = 2.31;
cout << "d1 / d2 = "<< d1 / d2 << endl;
cout << "d2 / d1 = "<< d2 / d1 << endl;
//cout << d1 % d2 << endl;会报错
//cout << d2 % d1 << endl;会报错
//2、前置后置递增、前置后置递减
int m = 1; int n = 2;
//前置递增
++m;//让变量+1
cout << "m = " << m <<endl;
//后置递增
n++;
cout << "n = " << n << endl;
//前置和后置的区别
int p = 4; int q = 7;
//前置递增：先让变量+1，然后进行表达式运算
int v = ++p * 10;
cout << "p = " << p << endl;
cout << "v = ++p * 10，v = " << v << endl;
//后置递增：先进行表达式运算，然后让变量+1
int g = q++ * 10;
cout << "q = " << q << endl;
cout << "g = q++ * 10, g = " << g << endl;
system("pause");
return 0;
}
4.2赋值运算符
//作用：用于将表达式的值赋予变量
#include <iostream>
using namespace std;
int main2()
{
//赋值运算符
// =
int a;
a = 10;
cout << "a = " << a << endl;
// +=
a = 10;
a += 2;//a = a + 2
cout << "a += 2,a = " << a << endl;
// -=
a = 10;
a -= 2;//a = a - 2
cout << "a -= 2,a = " << a << endl;
// *=
a = 10;
a *= 2;//a = a * 2
cout << "a *= 2,a = " << a << endl;
// /=
a = 10;
a /= 2;//a = a / 2
cout << "a /= 2,a = " << a << endl;
// %=
a = 10;
a %= 2;//a = a % 2
cout << "a %= 2,a = " << a << endl;
system("pause");
return 0;
}
4.3比较运算符
//作用：用于表达式的比较，并返回一个真值或假值
#include <iostream>
using namespace std;
int main3()
{
//比较运算符
//==
int a=10, b = 10;
cout << (a == b) << endl;
//！=
cout << (a != b) << endl;
// >
cout << (a > b) << endl;
// <
cout << (a < b) << endl;
// >=
cout << (a >= b) << endl;
// <=
cout << (a <= b) << endl;
system("pause");
return 0;
}
4.4逻辑运算符
//作用：用于根据表达式的值返回真值或假值
#include <iostream>
using namespace std;
int main4()
{
//逻辑运算符
// 非 ！
int a = 10,b = 0,c = -88;
cout << "!a 为" << !a << endl;
cout << "!b 为" << !b << endl;
cout << "!c 为" << !c << endl<<endl;
// 或 ||
int d = 0;
cout << "a||b 为" << (a || b) << endl;
cout << "a||c 为" << (a || c) << endl;
cout << "b||c 为" << (b || c) << endl;
cout << "b||d 为" << (b || d) << endl<<endl;
// 与 &&
cout << "a&&b 为" << (a && b) << endl;
cout << "a&&c 为" << (a && c) << endl;
cout << "b&&c 为" << (b && c) << endl;
system("pause");
return 0;
}
5.程序流程结构
5.1选择结构
5.1.1(1)选择结构-单行if语句
#include <iostream>
using namespace std;
int main1()
{
//选择结构 单行if语句
//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
//1、用户输入分数
int score = 0;
cout << "请输入一个分数" << endl;
cin >> score;
//2、打印用户输入的分数
cout << "您输入的分数为： " << score << endl;
//3、判断分数是否大于600，如果大于，那么输出
//注意：if条件后面不要加分号，加分号的话大括号里面的代码都会执行，if语句白写了
if (score > 600)
{
cout << "恭喜您考上了一本大学" << endl;
}
system("pause");
return 0;
}
5.1.1(2)选择结构-多行if语句
#include <iostream>
using namespace std;
int main2()
{
//选择结构 - 多行if语句
//用户输入考试分数，如果分数大于600视为考上一本大学，在屏幕上输出
//如果没考上一本大型，打印未考上一本大学
//1、输入考试分数
int score = 0;
cout << "请输入考试分数: " << endl;
cin >> score;
//2、提示用户输入的分数
cout << "您输入的分数为： " << score << endl;
//3、判断 如果大于600，打印考上一本，否则打印未考上一本
if (score > 600)//大于600分执行下面大括号中的内容
{
cout << "恭喜您考上一本大学" << endl;
}
else//不大于600分，执行else后大括号中的内容
{
cout << "未考上一本大学" << endl;
}
system("pause");
return 0;
}
5.1.1(3)选择结构-多条件if语句
#include <iostream>
using namespace std;
int main3()
{
//选择结构 多条件if语句
//输入一个考试分数，如果大于600分视为考上一本大学，在屏幕输出
//大于500，视为考上二本大学，在屏幕输出
//大于400，视为考上三本大学
//小于等于400分，视为未考上本科，屏幕上输出
//1、用户输入分数
int score = 0;
cout << "请输入考试分数： " << endl;
cin >> score;
//2、提示用户输入的分数
cout << "您输入的考试分数为： " << score << endl;
//3、判断
//如果大于600，考上一本
//如果大于500，考上二本
//如果大于400，考上三本
//前三个都没有满足，未考上本科
if (score > 600)
{
cout << "恭喜您考上了一本大学" << endl;
}
else if (score > 500)
{
cout << "恭喜您考上了二本大学" << endl;
}
else if (score > 400)
{
cout << "恭喜您考上了三本大学" << endl;
}
else
{
cout << "未考上本科大学，请再接再厉" << endl;
}
system("pause");
return 0;
}
5.1.1(4)选择结构-嵌套if语句
#include <iostream>
using namespace std;
int main4()
{
/*
提示用户输入一个高考考试分数，根据分数做如下判断：
分数如果大于600分视为考上一本，大于500分考上二本，大于400分考上三本，其余视为未考上本科
在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600分考入人大
*/
//1、提示输入高考分数
int score = 0;
cout << "请输入高考考试分数： " << endl;
cin >> score;
//2、显示高考分数
cout << "您输入的考试分数为： " << score << endl;
//3、判断
//如果大于600 一本
//大于700 北大
//大于650 清华
//其余 人大
//如果大于500 二本
//如果大于400 三本
//其余情况，未考上本科
if (score > 600)
{
cout << "恭喜您考入一本大学" << endl;
if (score > 700)
{
cout << "您能考入北京大学" << endl;
}
else if (score > 650)
{
cout << "您能考入清华大学" << endl;
}
else
{
cout << "您能考入人民大学" << endl;
}
}
else if (score > 500)
{
cout << "恭喜您考入二本大学" << endl;
}
else if (score > 400)
{
cout << "恭喜您考入三本大学" << endl;
}
else
{
cout << "未考上本科，请再接再厉" << endl;
}
system("pause");
return 0;
}
5.1.1(5)选择结构if语句案例-三只小猪称体重
#include <iostream>
using namespace std;
int main5()
{
double a, b, c;
cout << "请输入三只小猪a,b,c的体重" << endl;
cin >> a >> b >> c;
if (a > b)
{
if (a < c)
{
cout << "小猪c最重,小猪a第二重，小猪b最轻" << endl;
}
else if(a>c)
{
if (b > c)
{
cout << "小猪a最重,小猪b第二重，小猪c最轻" << endl;
}
else if(b<c)
{
cout << "小猪a最重，小猪c第二重，小猪b最轻" << endl;
}
else
{
cout << "小猪a最重，小猪c和b一样重而且比小猪a轻" << endl;
}
}
else
{
cout << "小猪a和c一样重,且比小猪b重" << endl;
}
}
else if(a<b)
{
if (b > c)
{
if(a>c)
{
cout << "小猪b最重,小猪a第二重，小猪c最轻" << endl;
}
else if(c>a)
{
cout << "小猪b最重,小猪c第二重，小猪a最轻" << endl;
}
else
{
cout << "小猪b最重，小猪a和c一样重且比小猪b轻" << endl;
}
}
else if(b<c)
{
cout << "小猪c最重，小猪b第二重，小猪a最轻" << endl;
}
else
{
cout << "小猪b和c一样重,且比小猪a重" << endl;
}
}
else
{
if (b > c)
{
cout << "小猪a和b同样重，且比小猪c重" << endl;
}
else if(b<c)
{
cout << "小猪a和b同样重，且比小猪c轻" << endl;
}
else
{
cout << "小猪a和b和c同样重" << endl;
}
}
system("pause");
return 0;
}
5.1.2选择结构-三目运算符
#include <iostream>
using namespace std;
int main6()
{
//三目运算符
//创建三个变量a，b，c
//将a和b做一个比较，将变量大的值赋值给变量c
int a = 10, b = 20, c = 0;
c = (a > b ? a: b);
cout <<"c最终等于： "<< c << endl;
//在C++中三目运算符返回的是变量，可以继续赋值
(a > b ? a : b) = 100;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
int d = 10, e = 20, f = 0;
(d< e? d: e) = 100;
cout << "d = " << d<< endl;
cout << "e = " << e<< endl;
system("pause");
return 0;
}
5.1.3选择结构-switch语句
#include <iostream>
using namespace std;
//if和switch的区别
//switch缺点：判断时候只能是整型或者字符型，不可以是一个区间
//switch优点：结构清晰，执行效率高
int main7()
{
//switch语句
//给电影打分
//10~9 经典
//8~7 非常好
//6~5 一般
//5以下 烂片
//1、提示用户给电影评分
cout << "请给电影进行打分： " << endl;
//2、用户开始进行打分
int score = 0;
cin >> score;
cout << "您输入的分数是： " << score << "分" << endl;
//3、根据用户输入的分数来提示用户最后的结果
switch (score)
{
case 10:
cout << "您认为是经典电影" << endl;
break; //退出当前分支，不要放往下执行代码了
case 9:
cout << "您认为是经典电影" << endl;
break;
case 8:
case 7:
cout << "您认为电影非常好" << endl;
break;
case 6:
cout << "您认为电影一般" << endl;
break;
case 5:
cout << "您认为电影一般" << endl;
break;
default:
cout << "您认为这是个烂片" << endl;
break;
}
system("pause");
return 0;
}
5.2while循环语句
5.2.1(1)while循环语句
#include <iostream>
using namespace std;
int main8()
{
//while循环
//在屏幕中打印0~9这十个数字
int num = 0;
//while后的括号里填入循环条件
//注意事项：在写循环时，一定要避免死循环的出现
//while的括号里填1的话，则会无限循环，因为判断的结果一直为真
while (num < 10)
{
cout << num << endl;
num++;
}
system("pause");
return 0;
}
5.2.1(2)while循环案例-猜数字
#include <iostream>
using namespace std;
#include <ctime>//time系统时间头文件包含
int main9()
{
//添加随机数种子 作用：利用当前系统时间生成随机数，防止每次随机数都一样
srand((unsigned int)time(NULL));
//1、系统生成随机数
int num = rand() % 100 + 1; //rand()%100+1 生成 0 + 1 ~ 99 + 1 之间的随机数
//2、玩家进行猜测
int val = 0;
while (1)
{
cin >> val;
//3、判断玩家的猜测
if (val > num)
{
cout << "猜测过大" << endl;
}
else if (val < num)
{
cout << "猜测过小" << endl;
}
else
{
cout << "恭喜您猜对了" << endl;
break;//可以利用break关键字来退出当前的（死）循环
}
}
//猜对 退出游戏
//猜错 显示猜的结果 过大或者过小 重新返回第2步
system("pause");
return 0;
}
5.2.2(1)do while循环语句
#include <iostream>
using namespace std;
int main10()
{
//do...while语句
//在屏幕中输出0到9这10个数字
int num = 0;
do
{
cout << num << endl;
num++;
}
while (num < 10);
//do...while和while循环区别在于do...while会先执行一次循环语句
system("pause");
return 0;
}
5.2.2(2)do while循环案例-水仙花数
#include <iostream>
using namespace std;
int main11()
{
//1、将所有的三位数进行输出（100~999）
int num = 100;
do
{
int a = 0, b = 0, c = 0;//a是个位，b是十位，c是百位
//2、获取个位、十位、百位
a = num % 10;
b = (num / 10) % 10;
c = num / 100;
if ((a*a*a + b*b*b + c*c*c) == num)//3、判断 个位的三次方+十位的三次方+百位的三次方=该数
{
cout << num << endl;
}
num++;
}
while (num < 1000);
system("pause");
return 0;
}
5.2.3(1)for循环语句
#include <iostream>
using namespace std;
int main12()
{
//作用：满足循环条件，执行循环语句
//语法for(起始表达式;条件表达式;末尾循环体){循环语句;}
//从数字0打印到数字9
for (int i = 0; i < 10; i++)
{
cout << i << endl;
}
//对for循环的解析
int i = 0;//起始表达式
for (;;)
{
if (i >= 10)//条件表达式
{
break;//退出当前循环
}
cout << i << endl;
i++;//末尾循环体
}
system("pause");
return 0;
}
5.2.3(2)for循环案例-敲桌子
#include <iostream>
using namespace std;
int main13()
{
//1、先输入1到100这些数字
for (int i = 1; i <= 100; i++)
{
if (((i%7)==0)||((i%10)==7)||(((i/10)%10)==7))//3、特殊数字：7的倍数、个位有7、十位有7
{
cout << "敲桌子" << endl;//2、从这100个数字中找到特殊数字，改为“敲桌子”
}
else
{
cout << i << endl;//不是特殊数字，则说出数字
}
}
system("pause");
return 0;
}
5.2.4(1)嵌套循环
#include <iostream>
using namespace std;
int main14()
{
//利用嵌套循环实现星图
//打印一行星图
for (int i = 0; i < 10; i++)//外层执行一次
{
for (int j = 0; j < 10; j++)//内层执行一周
{
cout << "* ";
}
cout << endl;
}
system("pause");
return 0;
}
5.2.4(2)嵌套循环案例-乘法口诀表
#include <iostream>
using namespace std;
int main15()
{
int num;
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
cout <<i<<"*"<< j<<"="<<i*j<<"\t";
}
cout << endl;
}
system("pause");
return 0;
}
5.3跳转语句
5.3.1跳转语句-break语句
#include <iostream>
using namespace std;
int main16()
{
//break的使用时机
//1、出现在switch语句中
cout << "请选择副本难度(输入1、2、3）" << endl;
cout << "1、普通" << endl << "2、中等" << endl << "3、困难" << endl;
int select;//创建选择结果的变量
cin >> select;//等待用户输入
switch (select)
{
case 1:
cout << "您选择的是普通难度" << endl;
break;
case 2:
cout << "您选择的是中等难度" << endl;
break;
case 3:
cout << "您选择的是困难难度" << endl;
break;
default:
cout << "输入有误" << endl;
break;
}
//2、出现在循环语句中
for (int i = 0; i < 10; i++)
{
//如果i等于5，退出循环，不再打印
if (i == 5)
{
break;//退出循环
}
cout << i << endl;
}
//3、出现在嵌套循环语句中
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
if (j == 5)
{
break;//退出内层的循环
}
cout << "* ";
}
cout << endl;
}
system("pause");
return 0;
}
5.3.2跳转语句-continue语句
#include <iostream>
using namespace std;
int main17()
{
//作用:在循环语句中，跳过本次循环中余下（continue语句下面）还没有执行的语句，然后继续执行下一次循环（可以当作一种筛选的方法）
for (int i = 1; i <= 100; i++)
{
//如果是奇数就输出，偶数则不输出
if (i % 2 == 0)
{
continue;
}
cout << i << endl;
}
system("pause");
return 0;
}
5.3.3跳转语句-goto语句
#include <iostream>
using namespace std;
int main18()
{
//作用:如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
cout << "1、xxxx" << endl;
cout << "2、xxxx" << endl;
cout << "3、xxxx" << endl;
goto FLAG;//语法： goto 标记;
cout << "4、xxxx" << endl;
cout << "5、xxxx" << endl;
cout << "6、xxxx" << endl;
FLAG:
cout << "7、xxxx" << endl;
system("pause");
return 0;
}
6.数组
6.1概述
/*
所谓数组，就是一个集合，里面存放了相同类型的数据元素
特点：1、数组中的每个数据元素都是相同的数据类型
2、数组是由连续的内存位置组成的
*/
6.2一维数组
6.2.1一维数组定义方式
#include <iostream>
using namespace std;
int main1()
{
//一维数组定义的三种方式：
//1、数据类型 数组名[数组长度];
int arr[5];//数组元素的下标是从0开始索引的，这里是0~4
arr[1] = 1; arr[2] = 2; arr[3] = 3;//给数组中的元素进行赋值
cout << arr[0] << endl << arr[1] << endl << arr[2] << endl << arr[3] << endl << arr[4] << endl;//访问数据元素
//2、数据类型 数组名[数组长度] = {值1, 值2, ...};
int arr2[5] = { 0,1,2,3 };//如果在初始化数据的时候，没有全部填写完会用0来填补
for (int i = 0; i < 5; i++)
{
cout << arr2[i] << endl;
}
//3、数据类型 数组名[] = { 值1,值2,... };
int arr3[] = { 0,1,2,3,4 };
for (int i = 0; i < 5; i++)
{
cout << arr3[i] << endl;
}
//注意：数组名和变量名不要重名
// 数组名是常量，不可以进行赋值操作
system("pause");
return 0;
}
6.2.2一维数组数组名
#include <iostream>
using namespace std;
//用途：
//1、可以统计整个数组在内存中的长度,所占的内存空间
//2、可以获取数组在内存中的首地址，即内存编号
int main2()
{
int arr[5] = { 1,2,3,4,5 };
//统计整个数组以及数组中的数据元素在内存中所占用的长度或内存空间
cout << "整个数组占用的空间内存为： " << sizeof(arr) << endl;
cout << "每个元素所占用的空间内存为： " << sizeof(arr[0]) << endl;
cout << "数组中元素个数为： " << sizeof(arr) / sizeof(arr[4]) << endl;
//通过数组名查看数组首地址
cout << "数组首地址（十六进制的）为： " << arr << " ，十六进制转为十进制则为： " << int(arr) << endl;
cout << "数组中第一个元素地址为： " << &arr[0] << " ，十六进制转为十进制则为： " << int(&arr[0]) << endl;
cout << "数组中第二个元素地址为： " << &arr[1] << " ，十六进制转为十进制则为： " << int(&arr[1]) << endl;
cout << "数组中第五个元素地址为： " << &arr[4] << " ，十六进制转为十进制则为： " << int(&arr[4]) << endl;
system("pause");
return 0;
}
6.2.3(1)一维数组案例-五只小猪称体重
#include <iostream>
using namespace std;
int main3()
{
int arr[5] = { 300, 350, 200, 400, 250 };
int max = 0;
//从数组中找到最大值
for (int i = 0; i < 4; i++)
{
if (arr[i] > arr[i + 1])
{
max = arr[i];
}
else
{
max = arr[i + 1];
}
}
cout << "最重的小猪为： " << max << endl;
//1.2另一种方法
for (int i = 0; i < 5; i++)
{
if (max < arr[i])
{
max = arr[i];
}
}
cout << "最重的小猪为： " << max << endl;
system("pause");
return 0;
}
6.2.3(2)一维数组案例-数组元素逆置
#include <iostream>
using namespace std;
int main4()
{
//1、创建数组
int arr[] = { 32,53,52,15,64,36,23,54.452 };
cout << "元素数组逆置前： " << endl;
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
cout << arr[i] << endl;
}
//2、实现逆置
//2.1、记录起始下标位置
//2.2、记录结束下标位置
//2.3、起始下标与结束下标元素的互换
//2.4、起始位置++ 结束位置--
//2.5、循环执行2.1操作，直到起始位置>=结束位置
int start = 0, end = sizeof(arr) / sizeof(arr[0]) - 1;//起始下标和结束下标
while (start < end)
{
//实现元素互换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
//下标更新
start++;
end--;
}
cout << "元素数组逆置后： " << endl;
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}
6.2.4冒泡排序
#include <iostream>
using namespace std;
//冒泡排序：比较相邻的元素，如果第一个比第二个大，就交换它们两个。
// 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值
// 重复以上的步骤，每次比较次数-1，直到不需要比较
int main5()
{
int arr[] = { 23,64,25,12,564,46,124,346,1151,643,1,244,15,16,34,64,31,464 };
int num = sizeof(arr) / sizeof(arr[0]);//元素个数
cout<< "排序前： " << endl;
for (int i = 0; i < num; i++)
{
cout << arr[i] << " ";
}
cout << endl;
//排序总轮数：元素个数-1
//每轮对比次数：元素个数-当前的排序轮数-1
for (int i = 0; i < num - 1; i++)
{
for (int j = 0; j < num - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
cout << "排序后： " << endl;
for (int i = 0; i < num; i++)
{
cout << arr[i] << " ";
}
cout << endl;
system("pause");
return 0;
}
6.3二维数组
6.3.1二维数组定义方式
#include <iostream>
using namespace std;
int main6()
{
//二维数组的定义方式（第二个是最直观的）
//1、数据类型 数组名[行数][列数];
int arr[2][3];
//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;
}
//3、数据类型 数组名[行数][列数]={数据1，数据2，数据3.数据4};
int arr3[2][3] = { 1,2,3,4,5,6 };
//4、数据类型 数组名[][列数]={数据1，数据2，数据3，数据4};
int arr4[][3] = { 1,2,3,4,5,6 };
system("pause");
return 0;
}
6.3.2二维数组名称用途
#include <iostream>
using namespace std;
int main7()
{
//1、可以查看占用内存空间大小
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << "二维数组占用内存空间为： " << sizeof(arr) << endl;//4*6=24
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 << "二维数组首地址为： " << arr << " 十六进制转为十进制为： " << int(arr) << endl;
cout << "二维数组第一行首地址为： " << arr[0] << " 十六进制转为十进制为： " << int(arr[0]) << endl;
cout << "二维数组第二行首地址为： " << arr[1] << " 十六进制转为十进制为： " << int(arr[1]) << endl;
cout << "二维数组第一个元素的首地址为： " << &arr[0][0] << " 十六进制转为十进制为： " << int(&arr[0][0]) << endl;
cout << "二维数组第二个元素的首地址为： " << &arr[0][1] << " 十六进制转为十进制为： " << int(&arr[0][1]) << endl;
system("pause");
return 0;
}
6.3.3二维数组应用案例
#include <iostream>
using namespace std;
#include <string>
int main8()
{
//输出张三、李四、王五的语文、数学、英语的成绩的表格
//1、创建二维数组
int scores[3][3] =
{
{100,100,100},
{90,50,100},
{60,70,80}
};
string name[] = {"张三","李四","王五"};
//2、统计每个人的总分数
int sum = 0;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
sum += scores[i][j];
}
cout << name[i] << "的总分为： " << sum << endl;
}
system("pause");
return 0;
}
7.函数
7.1概述
/*
作用：将一段经常使用的代码封装起来，减少重复代码
一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能
*/
7.2函数的定义
#include <iostream>
using namespace std;
//实现一个加法函数，功能：传入两个整形数据，计算数据相加的结果，并且返回
/*
语法：
1、返回值 int
2、函数名 add
3、参数列表(int num1,int num2)
4、函数体语句 int sum = num1 + num2
5、return表达式 return sum（因为定义的的函数是整型的函数，所以要返回的是整型的变量）
*/
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
int main1()
{
system("pause");
return 0;
}
7.3函数的调用
#include <iostream>
using namespace std;
//实现一个加法函数，功能：传入两个整形数据，计算数据相加的结果，并且返回
int add1(int num1, int num2)//函数定义的时候，num1和num2并没有真实数据，它们只是形式上的参数（形参）
{
int sum = num1 + num2;
return sum;
}
int main2()
{
int a = 10, b = 20;
//调用add函数语法：函数名称(参数）
//a和b成为实际参数（实参）
//当调用函数的时候，实参的值会传递给形参
int s = add1(a, b);
cout << s << endl;
a = 3432, b = 32153;
s = add1(a, b);
cout << s << endl;
system("pause");
return 0;
}
7.4值传递
#include <iostream>
using namespace std;
//定义函数，实现两个数字进行交换的函数
//如果函数不需要返回值，声明的时候可以写void
void swap(int num1, int num2)
{
cout << "交换前： " << endl;
cout << "num1 = " << num1 << endl;
cout << "num2 = " << num2 << endl;
int temp = num1;
num1 = num2;
num2 = temp;
cout << "交换后： " << endl;
cout << "num1 = " << num1 << endl;
cout << "num2 = " << num2 << endl;
}
int main3()
{
int a = 10, b = 20;
cout << "调用函数前： " << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
swap(a, b);
//当我们做值传递的时候，函数的形参发生改变，并不会影响实参
cout << "调用函数后： " << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
7.5函数的常见样式
#include <iostream>
using namespace std;
//1、无参无返
void test01()
{
cout << "this is test01" << endl;
}
//2、有参无返
void test02(int a)
{
cout << "this is test02 a = " << a << endl;
}
//3、无参有返
int test03()
{
int b = 10;
cout << "this is test03" << endl;
return b;
}
//4、有参有返
int test04(int c)
{
int m = c;
cout << "this is test04 " << endl;
return m;
}
int main4()
{
//1、无参无返调用
test01();
//2、有参无返调用
int a = 100;
test02(a);
//3、无参有返调用
int b = test03();
cout << "b = " << b << endl;
//4、有参有返调用
int n = 10;
int c = test04(n);
cout << "c = " << c << endl;
system("pause");
return 0;
}
7.6函数的声明
#include <iostream>
using namespace std;
//函数的声明
//提前告诉编译器函数的存在，可以利用函数的声明
int max(int a, int b);//函数的声明
//声明可以写多次，但是定义只能有一次
int max(int a, int b);
int max(int a, int b);
int max(int a, int b);
//int max(int a, int b)
//{
// return a > b ? a : b;
//}
//int max(int a, int b)
//{
// return a > b ? a : b;
//}
//int max(int a, int b)
//{
// return a > b ? a : b;
//}
int main5()
{
int a = 10, b = 20;
int c = max(a, b);
cout << "max = " << c << endl;
system("pause");
return 0;
}
//定义
//比较函数，实现两个整型数字进行比较，返回最大值
int max(int a, int b)
{
return a > b ? a : b;
}
7.7函数的分文件编写
//作用：让代码结构更加清晰
//函数分文件编写一般有4个步骤
//1、创建后缀名为.h的头文件
//2、创建后缀名为cpp.的源文件
//3、在头文件中写函数的声明
//4、在源文件中写函数的定义
#include "swap1.h"
int main6()
{
int a = 32,b = 234;
swap1(a, b);
system("pause");
return 0;
}
7.8交换函数
swap1.h
#include <iostream>
using namespace std;
//函数的声明
void swap1(int num1, int num2);
swap1.cpp
#include "swap1.h"
//函数的定义
//实现两个数字进行交换的函数
void swap1(int num1, int num2)
{
cout << "交换前： " << endl;
cout << "num1 = " << num1 << endl;
cout << "num2 = " << num2 << endl;
int temp = num1;
num1 = num2;
num2 = temp;
cout << "交换后： " << endl;
cout << "num1 = " << num1 << endl;
cout << "num2 = " << num2 << endl;
}
8.指针
8.1指针的基本概念
/*
指针的作用：可以通过指针间接访问内存
内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址
*/
8.2指针变量的定义和使用
#include <iostream>
using namespace std;
int main1()
{
int a = 10;
//1、指针变量定义语法： 数据类型 * 变量名;
int* p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址为： " << &a << endl;
cout << "指针p为： " << p << endl;
//2、使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存中的数据
*p = 1000;
cout << "a = " << a << endl;
cout << "*p = " << *p << endl;
system("pause");
return 0;
}
8.3指针所占的内存空间
#include <iostream>
using namespace std;
int main2()
{
//指针所占内存空间
int a = 10;
int* p = &a;
//在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
//在64位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
cout << "sizeof (int *) = " << sizeof(p) << endl;
cout << "sizeof (int *) = " << sizeof(int*) << endl;
cout << "sizeof (float *) = " << sizeof(float*) << endl;
cout << "sizeof (double *) = " << sizeof(double*) << endl;
cout << "sizeof (char *) = " << sizeof(char*) << endl;
system("pause");
return 0;
}
8.4空指针和野指针
#include <iostream>
using namespace std;
int main3()
{
//一、空指针
//1、空指针用于给指针变量进行初始化
int* p = NULL;
//2、空指针是不可以进行访问的
//0~255之间的内存编号是系统占用的，因此不可以访问
//*p = 100;
//二、野指针
//地址编号位0x1100
//在程序中，尽量避免出现野指针
int* p1 = (int*)0x1100;
//cout << *p << endl; **会报错
system("pause");
return 0;
}
8.5const修饰指针
#include <iostream>
using namespace std;
int main4()
{
//1、const修饰指针 常量指针
int a = 10, b = 10;
const int* p1 = &a;
//指针指向的值不可以改，指针的指向可以改
// *p = 29;//错误
p1 = &b;//正确
//2、const修饰常量 指针常量
//指针的指向不可以改，指针指向的值可以改
int* const p2 = &a;
*p2 = 100;//正确的
//p2 = &b;//错误，指针的指向不可以改
//3、const修饰指针和常量
const int* const p3 = &a;
//指针的指向和指针指向的值都不可以改
//*p3=100;//错误
//p3=&b;//错误
system("pause");
return 0;
}
8.6指针和数组
#include <iostream>
using namespace std;
int main5()
{
//指针和数组
//利用指针访问数组中的元素
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "第一个元素为： " << arr[0] << endl;
int* p0 = arr;//arr就是数组首地址
cout << "利用指针访问第一个元素： " << *p0 << endl;
p0++;//让指针向后偏移4个字节
cout << "利用指针访问第二个元素： " << *p0 << endl;
int* p2 = arr;
cout << "利用指针来遍历数组" << endl;
for (int i = 0; i < 10; i++)
{
cout << *p2 << endl;
p2++;
}
system("pause");
return 0;
}
8.7指针和函数
#include <iostream>
using namespace std;
//实现两个数字进行交换
void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
void swap02(int *p1, int *p2)
{
int temp =*p1 ;
*p1 = *p2;
*p2 = temp;
cout << "p1 = " << *p1 << endl;
cout << "p2 = " << *p2 << endl;
}
int main6()
{
//指针和函数
//1、值传递 传的是形参
int a = 10, b = 20;
//swap01(a, b);
//cout << "a = " << a << endl;
//cout << "b = " << b << endl;
//2、地址传递 传的是实参
swap02(&a, &b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
8.8指针、数组、函数-案例练习
#include <iostream>
using namespace std;
//案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
//冒泡排序函数 参数1：数组的首地址 参数2：数组长度
void bubblesort(int * arr,int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
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)
{
int* p = arr;
for (int i = 0; i < len; i++)
{
cout << *p << endl;
p++;
}
}
int main7()
{
//1、先创建数组
int arr[] = { 4,3,6,9,1,2,10,8,7,5 };
//数组长度
int len = sizeof(arr) / sizeof(arr[0]);
//2、创建函数，实现冒泡排序
bubblesort(arr, len);//把arr数组的地址传进去了，数组名就是数组的首地址
//3、打印排序后的数组
printArray(arr, len);
system("pause");
return 0;
}
9.结构体
9.1结构体基本概念
//结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
9.2结构体定义和使用
#include <iostream>
using namespace std;
#include <string>
//1、创建学生类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型集合组成的一个类型
//语法 struct 类型名称{成员列表}
//总结：1、定义结构体时的关键字struct不可以省略
// 2、创建结构体变量时，关键字struct可以省略
// 3、结构体变量利用操作符“.”来访问成员
struct Student
{
//成员列表
//姓名
string name;
//年龄
int age;
//分数
int score;
}s3;//顺便创建结构体变量
int main1()
{
//2、通过学生类型创建具体学生
//2.1 struct Student s1
struct Student s1;
//给s1属性赋值，通过“.”来访问结构体变量中的属性
s1.name = "张三";
s1.age = 18;
s1.score = 82;
cout << "姓名： " << s1.name << " 年龄： " << s1.age << " 分数： " << s1.score << endl;
//2.2 struct Student s2={...}
Student s2 = { "李四",19,83 };//struct可以省略
cout << "姓名： " << s2.name << " 年龄： " << s2.age << " 分数： " << s2.score << endl;
//2.3 在定义结构体时顺便创建结构体变量
s3.name = "王五";
s3.age = 23;
s3.score = 93;
cout << "姓名： " << s3.name << " 年龄： " << s3.age << " 分数： " << s3.score << endl;
system("pause");
return 0;
}
9.3结构体数组
#include <iostream>
using namespace std;
#include <string>
//作用：将自定义的结构体放入到数组中方便维护
//结构体数组
//1、定义结构体
struct Student
{
//姓名
string name;
//年龄
int age;
//分数
int score;
};
int main2()
{
//2、创建结构体数组
struct Student stuArray[3] =
{
{"张三",18,100},
{"李四",28,99},
{"王五",39,95}
};
//3、给结构体数组中的元素赋值
stuArray[2].name = "赵六";
stuArray[2].age = 80;
stuArray[2].score = 64;
//4、遍历结构体数组
for (int i = 0; i < 3; i++)
{
cout << "姓名： " << stuArray[i].name << " 年龄： " << stuArray[i].age << " 分数： " << stuArray[i].score << endl;
}
system("pause");
return 0;
}
9.4结构体指针
//作用：通过指针访问结构体中的成员
#include <iostream>
using namespace std;
#include <string>
//结构体指针
struct student
{
string name;//姓名
int age;//年龄
int score;//分数
};
int main3()
{
//1、创建学生结构体变量
student s1 = { "张三",19,88 };
//2、通过指针指向结构体变量
student* p = &s1;
//3、通过指针访问结构体变量中的数据
//通过结构体指针 访问结构体中的属性，需要利用“->”来访问
cout << "姓名； " << p->name << " 年龄： " << p->age << " 分数： " << p->score << endl;
system("pause");
return 0;
}
9.5结构体嵌套结构体
//作用：结构体中的成员可以是另一个结构体
#include <iostream>
using namespace std;
#include <string>
//定义学生结构体
struct student
{
string name;//学生姓名
int age;//学生年龄
int score;//考试分数
};
//定义老师结构体
struct teacher
{
int id;//教师编号
string name;//教师姓名
int age;//年龄
student stu;//辅导的学生
};
int main4()
{
//结构体嵌套结构体
teacher t;
t.id = 19999;
t.name = "老王";
t.age = 50;
t.stu.name = "小王";
t.stu.age = 19;
t.stu.score = 92;
cout << "老师姓名： " << t.name << " 老师编号： " << t.id << " 老师年龄： " << t.age << " 老师辅导的学生： " << t.stu.name << " 学生的姓名； " << t.stu.name
<< " 学生的年龄： "<< t.stu.age << " 学生的考试分数： " << t.stu.score << endl;
system("pause");
return 0;
}
9.6结构体做函数参数
//作用：将结构体作为参数向函数中传递
#include <iostream>
using namespace std;
#include <string>
//定义学生结构体
struct student
{
string name;//姓名
int age;//年龄
int score;//分数
};
//打印学生信息函数
//1、值传递
void printStudent1(struct student s1)
{
s1.name = "三坝"; s1.age = 100; s1.score = 167;
cout << "值传递的子函数中打印 姓名： " << s1.name << " 年龄： " << s1.age << " 分数： " << s1.score << endl;
}
//2、地址传递
void printStudent2(struct student * p)
{
p->name = "司仪"; p->age = 63; p->score = 234;
cout << "地址传递的子函数中打印 姓名： " << p->name << " 年龄： " << p->age << " 分数： " << p->score << endl;
}
int main5()
{
//结构体做函数参数
//将学生传入到一个参数中，打印学生身上的所有信息
//创建结构体变量
student s1;
s1.name = "张三";
s1.age = 19;
s1.score = 92;
cout << "main函数中打印 姓名： " << s1.name << " 年龄： " << s1.age << " 分数： " << s1.score << endl;
printStudent1(s1);//值传递
cout << "main函数中打印 姓名： " << s1.name << " 年龄： " << s1.age << " 分数： " << s1.score << endl<<endl;
student s2;
s2.name = "李四";
s2.age = 18;
s2.score = 94;
cout << "main函数中打印 姓名： " << s2.name << " 年龄： " << s2.age << " 分数： " << s2.score << endl;
printStudent2(&s2);//地址传递
cout << "main函数中打印 姓名： " << s2.name << " 年龄： " << s2.age << " 分数： " << s2.score << endl;
system("pause");
return 0;
}
9.7结构体中 const使用场景
#include <iostream>
using namespace std;
#include <string>
//作用：用const来防止误操作
//const的使用场景
struct student
{
//成员列表
string name;//姓名
int age;//年龄
int score;//分数
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudents(const student *s)//加入const之后，一旦有修改的操作就会报错，可以防止我们的误操作
{
//s->age = 150;//可以读取，但不能改
cout << "姓名： " << s->name << " 年龄： " << s->age << " 得分： " << s->score << endl;
}
int main6()
{
//创建结构体变量
student s = { "张三",15,29 };
//通过函数打印结构体变量信息
printStudents(&s);
system("pause");
return 0;
}
9.8结构体案例（1）
/*
学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下：
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员
学生的成员有姓名、考试分数、创建数组存放3名老师，通过函数给每个老师及所带的学生赋值
最终打印出老师数据以及老师所带的学生数据。
*/
#include <iostream>
using namespace std;
#include <string>
#include <ctime>
//学生的结构体定义
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;//0+40~60+40
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 << "学生姓名： " << tArray[i].sArray[j].sName << " 考试分数： " << tArray[i].sArray[j].score << endl;
}
}
}
int main7()
{
//1、创建3名老师的数组
Teacher tArray[3];
//2、通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
int len = sizeof(tArray) / sizeof(tArray[0]);
allocateSpace(tArray, len);
//3、打印所有老师和学生的信息
printInfo(tArray, len);
system("pause");
return 0;
}
9.8结构体案例（2）
/*
设计一个英雄的结构体，包括成员姓名，年龄，性别；
创建结构体数组，数组中存放5名英雄。
通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印最后的排序结果
*/
#include <iostream>
using namespace std;
#include <string>
struct Hero
{
//姓名
string name;
//年龄
int age;
//性别
string sex;
};
//冒泡排序，实现年龄升序排列
void bubblesort(Hero hArray[], int len)
{
for (int i = 0; i < len; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
//如果j下标的元素的年龄 大于 j+1下标的元素的年龄，交换两个元素
if (hArray[j].age > hArray[j + 1].age)
{
Hero temp = hArray[j];
hArray[j] = hArray[j + 1];
hArray[j + 1] = temp;
}
}
}
}
//打印排序后数组中的信息
void printHero(Hero hArray[], int len)
{
for (int i = 0; i < len; i++)
{
cout << "姓名：" << hArray[i].name << " 年龄： " << hArray[i].age << " 性别： " << hArray[i].sex << endl;
}
}
int main8()
{
//1、设计英雄结构体
//2、创建数组存放5名英雄
Hero hArray[5] =
{
{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",21,"男"},
{"貂蝉",19,"女"}
};
int len = sizeof(hArray) / sizeof(hArray[0]);
//3、对数组进行排序，按照年龄进行升序排序
bubblesort(hArray, len);
//4、将排序后的结果打印输出
printHero(hArray, len);
system("pause");
return 0;
}
10.通讯录管理系统案例
#include <iostream>
#include <string>
#include <ctime>
using namespace std;
#define MAX 100
//显示菜单界面
//-封装函数显示该界面 如void showMenu()
//-再main函数中调用封装好的函数
void showMenu()
{
cout << "*************************" << endl;
cout << "***** " << "1、添加联系人" << " *****" <<endl;
cout << "***** " << "2、显示联系人" << " *****" << endl;
cout << "***** " << "3、删除联系人" << " *****" << endl;
cout << "***** " << "4、查找联系人" << " *****" << endl;
cout << "***** " << "5、修改联系人" << " *****" << endl;
cout << "***** " << "6、清空联系人" << " *****" << endl;
cout << "***** " << "0、退出通讯录" << " *****" << endl;
cout << "*************************" << endl;
}
//设计联系人结构体
struct Person
{
//姓名
string m_Name = "name";
//性别 1男 2女
int m_Sex = 0;
//年龄
int m_Age = 0;
//电话
string m_Phone="12345678910";
//住址
string m_Addr="adrress";
};
//设计通讯录结构体
struct Addressbooks
{
//通讯录中保存的联系人数组
struct Person personArray[MAX];
//通讯录中当前记录联系人个数
int m_Size = 0;
};
//1、添加联系人
void addPerson(Addressbooks* abs)
{
//判读通讯录是否已满，如果满了就不再添加
if (abs->m_Size == MAX)
{
cout << "通讯录已满，无法添加！" << endl;
return;
}
else
{
//添加具体联系人
//姓名
string name;
cout << "请输入姓名： " << endl;
cin >> name;
abs->personArray[abs->m_Size].m_Name = name;
//性别
cout << "请输入性别： " << endl;
cout << "请输入数字： 1--男，2--女" << endl;
int sex = 0;
while (true)
{
cin >> sex;
//如果输入的是1或者2可以退出循环，输入有误则重新输入
if (sex == 1 || sex == 2)
{
abs->personArray[abs->m_Size].m_Sex = sex;
break;
}
else
{
cout << "输入有误，请重新输入" << endl;
}
}
//年龄
cout << "请输入年龄： " << endl;
int age = 0;
cin >> age;
abs->personArray[abs->m_Size].m_Age = age;
//电话
cout << "请输入联系电话： " << endl;
string phone;
cin >> phone;
abs->personArray[abs->m_Size].m_Phone = phone;
//住址
cout << "请输入家庭住址： " << endl;
string address;
cin >> address;
abs->personArray[abs->m_Size].m_Addr = address;
//更新通讯录人数
abs->m_Size++;
cout << "添加成功" << endl;
system("pause");//请按任意键继续
system("cls");//清屏操作
}
}
//2、显示所有联系人
void showPerson(Addressbooks* abs)
{
//判断通讯录中人数是否为0，如果为0，提示记录为空
//如果不为0，显示记录的联系人信息
if (abs->m_Size == 0)
{
cout << "当前记录为空" << endl;
}
else
{
for (int i = 0; i < abs->m_Size; i++)
{
cout << "姓名： " << abs->personArray[i].m_Name << "\t";
cout << "性别： " << ((abs->personArray[i].m_Sex==1)?"男":"女") << "\t";
cout << "年龄： " << abs->personArray[i].m_Age << "\t";
cout << "电话： " << abs->personArray[i].m_Phone << "\t";
cout << "地址： " << abs->personArray[i].m_Addr << endl;
}
}
system("pause");//请按任意键继续
system("cls");//清屏操作
}
//检测联系人是否存在，如果存在，返回联系人所在数组中的具体位置，不存在返回-1
int isExist(Addressbooks* abs,string name)//参数1为通讯录，参数2为对比的姓名
{
for (int i = 0; i < abs->m_Size; i++)
{
if (abs->personArray[i].m_Name == name)
{
return i;
}
}
return -1;
}
//3、删除指定联系人
void deletePerson(Addressbooks* abs)
{
cout << "请输入您要删除的联系人" << endl;
string name;
cin >> name;
int ret = isExist(abs, name);//ret = -1未查到，不等于-1查到了
if (ret != -1)
{
//查到此人，要进行删除操作
for (int i = 0; i < abs->m_Size;i++)
{
//数据前移的逻辑删除操作
abs->personArray[i] = abs->personArray[i + 1];
}
abs->m_Size--;//更新通讯录中的人员数
cout << "删除成功" << endl;
}
else
{
cout << "查无此人" << endl;
}
system("pause");//请按任意键继续
system("cls");//清屏操作
}
//4、查找指定联系人信息
void findPerson(Addressbooks*abs)
{
cout << "请输入您要查找的联系人" << endl;
string name;
cin >> name;
//判断指定联系人是否存在通讯录中
int ret = isExist(abs, name);
if (ret != -1)
{
cout << "姓名： " << abs->personArray[ret].m_Name << "\t";
cout << "性别： " << ((abs->personArray[ret].m_Sex == 1) ? "男" : "女") << "\t";
cout << "年龄： " << abs->personArray[ret].m_Age << "\t";
cout << "电话： " << abs->personArray[ret].m_Phone << "\t";
cout << "地址： " << abs->personArray[ret].m_Addr << "\t";
}
else
{
cout << "查无此人" << endl;
}
system("pause");
system("cls");
}
//5、修改联系人
void modifyPerson(Addressbooks* abs)
{
cout << "请输入您要修改的联系人" << endl;
string name;
cin >> name;
int ret = isExist(abs, name);
if (ret != -1)
{
//姓名
cout << "请输入姓名： " << endl;
cin >> name;
//这里不是abs->personArray[abs->m_Size]，中括号里的是ret，原因是ret为返回的联系人的数组下标，而m_Size是已经+1的了
//比如你添加了一个联系人，此时isExist函数返回的值是0，而m_Size的值是1，数组personArray[0]里有你输入的第一个联系人的信息，而personArray[1]里是没有联系人信息的
abs->personArray[ret].m_Name = name;
//性别
cout << "请输入性别： " << endl;
cout << "请输入数字： 1--男，2--女" << endl;
int sex = 0;
while (true)
{
cin >> sex;
//如果输入的是1或者2可以退出循环，输入有误则重新输入
if (sex == 1 || sex == 2)
{
abs->personArray[ret].m_Sex = sex;
break;
}
else
{
cout << "输入有误，请重新输入" << endl;
}
}
//年龄
cout << "请输入年龄： " << endl;
int age = 0;
cin >> age;
abs->personArray[ret].m_Age = age;
//电话
cout << "请输入电话： " << endl;
string phone;
cin >> phone;
abs->personArray[ret].m_Phone = phone;
//地址
cout << "请输入地址： " << endl;
string address;
cin >> address;
abs->personArray[ret].m_Addr = address;
cout << "修改成功" << endl;
}
else
{
cout << "查无此人" << endl;
}
system("pause");
system("cls");
}
//6、清空联系人
void cleanPerson(Addressbooks* abs)
{
abs->m_Size = 0;//将当前记录联系人数量置为0，做逻辑清空操作
cout << "通讯录已清空" << endl;
system("pause");
system("cls");
}
int main()
{
//创建通讯录结构体变量
Addressbooks abs;
//初始化通讯录中当前人员个数
abs.m_Size = 0;
//创建用户选择输入的变量
int select = 0;
while (true)
{
//菜单调用
showMenu();
cin >> select;
switch (select)
{
case 1://1、添加联系人
addPerson(&abs);//利用地址传递可以修饰实参
break;
case 2://2、显示联系人
showPerson(&abs);
break;
case 3://3、删除联系人
deletePerson(&abs);
break;
case 4://4、查找联系人
findPerson(&abs);
break;
case 5://5、修改联系人
modifyPerson(&abs);
break;
case 6://6、清空联系人
cleanPerson(&abs);
break;
case 0://0、退出通讯录
cout << "欢迎下次使用" << endl;
system("pause");
return 0;
break;
default:
cout << "输入有误，请重新输入0~6的数字" << endl;
system("pause");
system("cls");
break;
}
}
system("pause");
return 0;
}
150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
