自己学习c++过程中写下的笔记,只做基础了解使用
程序员文章站
2024-02-28 08:29:16
...
01书写helloworld
#include <iostream>
using namespace std;
int main() {
cout << "Hello World" << endl;
system("pause");
return 0;
}
02变量创建的方法
#include <iostream>
using namespace std;
int main() {
//变量创建的方法
int a = 10;
cout << "a = " << a << endl;
system("pause");
return 0;
}
03常量的定义方式
#include <iostream>
using namespace std;
/*
常量的定义方式
1. #define 宏常量
注意,定义宏常量,后面不要加分号;
2. const修饰的变量不可修改,也称之为常量
const修饰的变量一般在主方法中
const 比 define更好
1. const方式可以明确指定类型
2. 可以使用c++的作用域规则,将定义限制在特定的函数或文件中(作用域规则描述了名称在各个模块中的可知程度)
3. const可以用在更复杂的场景
*/
//1.
#define Day 7
int main() {
cout << "一周总共有" << Day << "天" << endl;
//2.
const int mouth = 12;
cout << "一年有" << mouth << "个月" << endl;
system("pause");
return 0;
}
04 关键字
#include<iostream>
using namespace std;
/*
*/
int main() {
//创建变量
int a = 10;//这里的int就是关键字,不要用关键字给变量或常量起名称
return 0;
}
05 标识符命名规则
#include<iostream>
using namespace std;
/*
c++规定给标识符(变量,常量)命名时候,有一套自己的规则
1. 标识符不可以是关键字
2. 标识符只可以由字母,数字,下划线组成
3. 第一个字符必须是字母或下划线
4. 标识符的字母区分大小写
*/
int main() {
return 0;
}
06 数据类型 整型
#include<iostream>
using namespace std;
/*
1. 首先说明数据类型存在的意义,也就是为什么要区分数据类型:给变量分配合适的内存空间,避免空间浪费
2. 整型变量表示的是整数类型的数据
c++中可以表示整型的类型有以下几种方式,区别在于所占内存空间的不同
1. short,2字节,-2^15~2^15-1
2. int,4字节
3. long,windows为4字节,linux为4(32位操作系统)/8(64位操作系统)字节
4. long long,8字节
3. c++中,除非有理由存储为其他类型(例如用了特殊后缀表示特定的类型,或者值太大,不可以存储为int),否则c++将整型常量存储为int类型
4. 常见的后缀
l/L long
u/U unsigned int
ul unsigned long
ull
5. 长度
1. 对于十进制来说,对于不带后缀的十进制整数,将依次使用int ,long, long long来表示,例如20000就用int,而40000就用long
2. 对于八进制和十六进制,而是依次使用int,unsigned int,unsigned long,unsigned long long ,这是因为十六进制
通常用来表示内存地址,而内存地址是没有负数的
*/
int main() {
short num1 = 32769;
int num2 = 10;
long num3 = 10;
long long num4 = 10;
cout << "num1 = " << num1 << endl;//-32767,因为超过了short的数据范围
cout << "num2 = " << num2 << endl;
cout << "num3 = " << num3 << endl;
cout << "num4 = " << num4 << endl;
return 0;
}
07 sizeof
#include<iostream>
using namespace std;
/*
利用sizeof关键字,可以统计数据类型所占内存的大小
语法 : sizeof(数据类型/变量)
*/
int main() {
int a = 10;
cout << "short所占内存空间为 : " << sizeof(short) << endl; // 2
cout << "int所占内存空间为 : " << sizeof(int) << endl; // 4
cout << "long所占内存空间为 : " << sizeof(long) << endl; // 4
cout << "long long 所占内存空间为 : " << sizeof(long long) << endl; // 8
cout << "变量a所占内存空间为 : " << sizeof(a) << endl; // 4
return 0;
}
08 浮点型
#include<iostream>
using namespace std;
/*
作用 : 由于表示小数
浮点型变量分为两种:
1. 单精度 float
2. 双精度 double
两者的区别在于表示的有效数字范围不同
flaot,4字节,有效数字范围7位
double,8字节,有效数字范围15~16位
注意: 默认情况下,输出小数会显示6为有效数字,无论是double还是float
举例:3.14的有效数字为3位,31.4的有效数字也是3位
浮点数的运算速度要比整数运算慢,且精度将降低
*/
int main() {
float f1 = 3.1415926f;
/*
一般来说,我们会在单精度数字后面写一个 f ,如果没有 f ,编译器会把他当作一个双精度数字,因为编译器默认把小数视作
双精度
*/
//float f2 = 3.14;
//cout << "f2没有在数字后面写f,那么他的占用内存空间为 : " << sizeof(f2) << endl; // 8
double d1 = 3.1415926;
//cout << "d2占用内存空间为 : " << sizeof(d1) << endl; // 8
cout << f1 << endl;//3.14159
cout << d1 << endl;//3.14159
/*
不管单精度还是双精度,如果表示一个小数,都只会最多表示6为有效数字,如果想显示更多有效数字,需要进行一些额外的配置
这个过程比较复杂,后期学习
*/
return 0;
}
09 科学计数法
#include<iostream>
using namespace std;
/*
*/
int main() {
float f1 = 3e2;
float f2 = 3e-2;
/*
3e2
如果e后面是一个正数,则代表3 * 10^2
3e-2
如果e后面是一个负数,则代表3 * 10^-2
*/
cout << "f1 = " << f1 << endl; // 300
cout << "f2 = " << f2 << endl; // 0.03
return 0;
}
10 字符型
#include<iostream>
using namespace std;
/*
字符型
作用 : 字符型用于显示 单个 字符
语法 : char ch = 'a';
注意:
1. 在显示字符型变量的时候,用单引号将字符括起来,不要用双引号
2. 单引号内只能有一个字符,不可以是字符串
1. c++中字符串变量只占用一个字节
2. 字符型变量并不是把字符本身放到内存中存储,而是将对应的 ASC2 编码放入到存储单元中
重点 : 在c++中,char其实也属于整型变量,所以可以对char类型数据进行整数操作,而且char中存放的,一定是对应的字符编码,
只不过输出的时候,cout会根据值的类型选择如何显示值
*/
int main() {
char ch = 'a';
char ch2 = 65;
cout << ch << endl; // a
cout << sizeof(ch) << endl; // 1
cout << int(ch) << endl; // 97
cout << "ch2 : " << ch2 << endl; //A
char c;
cout << "请输入:";
cin >> c;//5
cout << c << " : " << (int)c; // 5 : 53
cout << '\007';
return 0;
}
11 转义字符
#include<iostream>
using namespace std;
/*
\n : 换行
\t : 水平制表,也就是一个TAB
\\ : 代表一个反斜杠\
\r : 回车
\" : "
\? : ?
*/
int main() {
//想输出一个反斜杠
//错误写法
//cout << "\" << endl;
// 正确写法
cout << "\\" << endl;
return 0;
}
12 *字符串型
#include<iostream>
#include<string> // 用c++风格字符串的时候,要包含这个头文件,vs2019可以不写
using namespace std;
/*
字符串型
作用 : 表示一串字符
两种风格
1. c语言风格: char 变量名[] = "字符串值";
c语言风格字符串有一个特点,就是以空字符结尾 ,空字符被写作\0,其ASC2码值为0,用来标记字符串的结尾
char str1[] = {'h','e','l','l','o','\0'};
这样子写起来非常的复杂,所以我们可以使用引号括起来即可,并且这种方式不要我们添加空字符,它会隐式的包含
char str1[] = "hello";
2. c++语言风格: string 变量名 = "字符串值";
string位于命名空间std中,string定义隐藏了字符串的 数组 性质
注意 :
字符串常量和字符常量不可以互换
例如:
字符串常量 "S";他实际保存的是两个字符,'S'和'\0',并且"S"实际上表达的是字符串所在的地址
而字符常量's,实际上保存的是ASC2,我们之前也说过,char数据类型其实属于整型
*/
int main() {
//1.
char str1[] = "我是何佳乐";//这种字符串被称之为字符串常量
cout << str1 << endl;
cout << sizeof(str1) << endl;
//2.
string str2 = "我也是何佳乐";
cout << str2 << endl;
cout << sizeof(str2) << endl;
return 0;
}
13 *字符串案例
#include<iostream>
#include<cstring> // for the strlen function
using namespace std;
/*
字符串案例
通过该案例可以知道
1. strlen返回的是存储在数组中的字符串长度,而不是数组本身的长度,并且strlen只计算可见的字符,不计算\0
2. cout输出字符串的时候,在扫描到\0的时候结束
*/
int main() {
const int Size = 15;
char name1[Size];
char name2[Size] = "C++owboy";//初始化数组
string name3 = "java is the \0 best";
cout << "name2 = " << name2 << endl;
cout << "what your name ?(name1)" << endl;
cin >> name1;//basicname
cout << "strlen(name1) = " << strlen(name1) << endl;//9
cout << "sizeof(name1) = " << sizeof(name1) << endl;//15
cout << "name1[0] = " << name1[0] << endl;//b
//可以通过设置\0来提前结束字符串的输出
name2[3] = '\0';//这样子cout只会输出三个字符
cout << "name2 = " << name2 << endl;//C++
cout << name3;//java is the
return 0;
}
14 字符串输入的陷阱
#include<iostream>
using namespace std;
/*
字符串输入的陷阱
*/
int main() {
/*string city,reason;
cout << "请输入你最喜欢的城市" << endl;
cin >> city;
cout << "为什么最喜欢这里?" << endl;
cin >> reason;
cout << "city = " << city << endl;
cout << "reason = " << reason << endl;*/
/*
输出:
请输入你最喜欢的城市
new yark
为什么最喜欢这里?
city = new
reason = yark
*/
/*
分析:
我们可以发现,我们第二次cin什么都没有输入,结果就已经运行完成了,这是因为:
cin使用空格,制表符和换行符来确定字符串的位置,这意味着用cin依次获取的是一个单词(new),获取该单词后,cin将
new放入city,并自动在结尾添加空字符,这样子导致的结果就是,第一次cin将new放入city,而将york留在了输入队列
当cin从输入队列中搜索输入数据的时候,发现了york,然后将york存入reason
*/
/*
解决方法:
通过cin.getline()一次获取一行的输入,getline通过换行符确认输入结束
*/
cout << "----------------------------" << endl;
const int arrSize = 20;
char city2[arrSize];
char reason2[arrSize];
cout << "请输入你最喜欢的城市" << endl;
cin.getline(city2,20);
cout << "为什么最喜欢这里?" << endl;
cin.getline(reason2, 20);
cout << "city = " << city2 << endl;
cout << "reason = " << reason2 << endl;
/*
输出:
请输入你最喜欢的城市
new york
为什么最喜欢这里?
fuck you
city = new york
reason = fuck you
*/
return 0;
}
15 字符串赋值和拼接
#include<iostream>
using namespace std;
/*
*/
int main() {
//1. 赋值
char char1[20];
char char2[20] = "jaguar";
string str1;
string str2 = "panther";;
//用数组实现的字符串,也继承了数组的特点,比如不可以将数组赋值给另一个数组,下面的操作就是错误的
//char1 = char2;
//但是string可以,因为string其实是对象
str1 = str2;
cout << "str1 = " << str1 << endl;
//2. 拼接
str1 += "何佳乐";
cout << "str1 = " << str1 << endl;
cout << "str1 length is : " << str1.size();
return 0;
}
16 *string和常规数字字符串
#include<iostream>
#include<string> // for getline function
using namespace std;
/*
在获取长度,和从输入流获取数据的时候,c风格字符串和c++string字符串方式不一样
*/
int main() {
char char1[20];
string str;
cout << "before length of char1 : " << strlen(char1) << endl;//31
/*
至于上面的输出为什么不是20,是因为strlen获得长度的方式是直到扫描到\0,但是我们初始化的数组并没有\0,所以
strlen会继续向后扫描,直到在别的地方扫描到了\0
*/
cout << "before length of str: " << str.size() << endl;//0
cout << "please enter for char1 : "; //new york
cin.getline(char1, 20);//cin是iostream的对象,而getline是cin类的类方法,第一个参数是目标数组,第二个参数是数组长度
//getline使用他来避免超越数组的边界
cout << "please enter for str : ";//zhan san
getline(cin, str);//这里要注意,与c风格字符串获取输入的方式不一样
/*
这里的getline不是类方法,因为iostream其实是c就有的库,那个时候没有string数据类型,所以没有对应string的getline方法
至于为什么istream没有处理string的类方法,为什么还可以执行cin >> str,这涉及到友元函数,之后讲
*/
cout << "after length of char1 : " << strlen(char1) << endl; // 8
cout << "after length of str : " << str.size() << endl; // 8
return 0;
}
17 原始字符串
#include<iostream>
using namespace std;
/*
原始字符串
原始字符串以"( 和 )"作为开始和结束,并且用R标识
*/
int main() {
cout << R"(jim "kind" tutt uses "\n" instead of endl. )" << endl;
//如果需要在原始字符串中输入"(的话,我们可以修改原始字符串的定界符
cout << R"+++("我是何佳乐,我活得很快乐哦\n")+++" << endl;
/*
上面的代码中, 我们用"+++( 和 +++)" 代替了原始的定界符
但是注意,相比较原始的定界符,我们只可以在" 和 ( 之间添加元素来扩充定界符,扩充后,cout扫描到)"就不会认为
字符串输入结束,所以原始字符串可以正确输入)"
*/
/*
jim "kind" tutt uses "\n" instead of endl.
"我是何佳乐,我活得很快乐哦\n"
*/
return 0;
}
18 布尔类型 bool
#include<iostream>
using namespace std;
/*
布尔类型 bool
bool只有两个值
1. true -- 真(本质是1),只要是非0值都代表true
2. false -- 假(本质是0)
bool类型占1个字节大小
*/
int main() {
bool b1 = false;
cout << b1 << endl;
cout << "bool占用的内存空间为 : "<< sizeof(bool) << endl; // 1
return 0;
}
19 数据的输入
#include<iostream>
#include<string>
using namespace std;
/*
数据的输入
作用 : 用于从键盘获取数据
关键字 : cin >> 变量
*/
int main() {
//整型输入
//int a = 0;
//cout << "请输入整型变量" << endl;
//cin >> a;
//cout << "a = " << a << endl;
//浮点型输入
//double d = 0;
//cout << "请输入浮点型变量" << endl;
//cin >> d;
//cout << "d = " << d << endl;
/*字符型输入
char ch = 'a';
cout << "请输入字符型变量" << endl;
cin >> ch;
cout << "ch = " << ch << endl;*/
//字符串输入
/*string str = "hello";
cout << "请输入字符串变量" << endl;
cin >> str;
cout << "str = " << str << endl;*/
//布尔类型输入
bool b = true;
cout << "请输入布尔数据类型变量" << endl;
cin >> b;
cout << b << endl;
}
20 比较运算符
#include<iostream>
using namespace std;
/*
*/
int main() {
int num1 = 10;
int num2 = 13;
cout << (num1 > num2) << endl;
cout << (num1 == num2) << endl;
cout << (num1 < num2) << endl;
return 0;
}
21 赋值运算符
#include<iostream>
using namespace std;
/*
*/
int main() {
int a = 10;
a = 100;
cout << "a = " << a << endl;//100
a += a;
cout << "a = " << a << endl;//200
a *= a;
cout << "a = " << a << endl;//40000
a %= a;
cout << "a = " << a << endl;//0
return 0;
}
22 逻辑运算符
#include<iostream>
using namespace std;
/*
逻辑运算符:! && ||
*/
int main() {
cout << !true << endl;//0
cout << (true && false) << endl;//0
cout << (true || false) << endl;//1
return 0;
}
23 算术运算符
#include<iostream>
using namespace std;
/*
运算符
作用 : 用于执行代码的运算
1. 算数运算符,四则运算
+ - * / %(取余,取模) ++ -- (分前置和后置)
注意 :
1. 除0会报错integer division by zero
2. 只有整数可以取模,小数不可以取模
2. 赋值运算符
3. 比较运算符,返回布尔类型数据
4. 逻辑运算符,返回布尔类型数据
*/
int main() {
// 算数运算符:/
int num1 = 10;
int num2 = 3;
double d1 = 10;
double d2 = 3;
cout << num1 / num2 << endl;//整数相除-->会舍弃所有小数位,只保留整数部分
cout << d1 / d2 << endl;//3.33333,浮点型数值相除,或者两个数中有一个是浮点数-->保留小数,结果是浮点数
//注意:
//cout << 10 / 0 << endl;//这里会报错,要极度注意 -->除0异常<--
cout << 10 % 3 << endl;//10/3余数为1,所以这里输出的是1
//cout << 10.0 % 3.0 << endl;//编译期间报错,因为只有整数可以取模,小数不可以取模
//递增运算符
cout << num1++ << endl;//10
cout << num1 << endl;//11
cout << ++num2 << endl;//4
cout << num2 << endl;//4
cout << 11.17 + 50.25 << endl;
return 0;
}
24 选择结构
#include<iostream>
using namespace std;
/*
选择结构
1. 单行格式if语句
2. 多行格式if语句
3. 多条件的if语句
*/
int main() {
//输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印
int score = 0;
cout << "请输入学生的成绩" << endl;
cin >> score;
if (score > 600)
{
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;
}
return 0;
}
25 案例 : 求三个数的最大值
#include<iostream>
using namespace std;
/*
利用选择结构,从三个值中找出最大值
*/
int main() {
int num1 = 3120;
int num2 = 212310;
int num3 = 310;
if (num1 > num2)
{
if (num1 > num3)
{
cout << "最大值为 : " << num1 << endl;
}
else {
cout << "最大值为 : " << num3 << endl;
}
}
else {
if (num2 > num3)
{
cout << "最大值为 : " << num2 << endl;
}
else {
cout << "最大值为 : " << num3 << endl;
}
}
return 0;
}
26 三目运算符
#include<iostream>
using namespace std;
/*
三目运算符
*/
int main() {
int num1 = 10;
int num2 = 20;
int c = num1 > num2 ? num1 : num2;
cout << c << endl;//20
num1 > num2 ? num1 : num2 = 100;
cout << "num1 : " << num1 << endl;//10
cout << "num2 : " << num2 << endl;//100
return 0;
}
27 switch
#include<iostream>
using namespace std;
/*
switch 语句
作用 : 执行多条件分支语句
注意:
> 注意1：switch语句中表达式类型只能是整型或者字符型
> 注意2：case里如果没有break，那么程序会一直向下执行
> 总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间
*/
int main() {
//请给电影评分
//10 ~ 9 经典
// 8 ~ 7 非常好
// 6 ~ 5 一般
// 5分以下 烂片
int score = 0;
cout << "请输入你对该电影的评分 : " << endl;
cin >> score;
switch (score)
{
case 10:
case 9 :
cout << "经典" << endl;
break;
case 8:
case 7:
cout << "非常好" << endl;
break;
case 6:
case 5:
cout << "一般" << endl;
break;
default:
cout << "烂片" << endl;
break;
}
return 0;
}
28 while循环结构
#include<iostream>
#include<ctime>
using namespace std;
/*
系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利
并且退出游戏。
*/
int main() {
//添加一个随机数的种子,利用当前系统时间生成随机数,防止每次随机数都是42(伪随机数)
srand((unsigned int)time(NULL));
int num1 = rand() % 100 + 1;//rand % 100 生成0 ~ 99的随机数,然后+1 就是 1~100
int num2 = 0;
while (1)
{
cout << "请输入你猜测的值" << endl;
cin >> num2;
if (num1 > num2)
{
cout << "猜小了" << endl;
}
else if (num1 < num2)
{
cout << "猜大了" << endl;
}
else
{
cout << "恭喜你猜对了" << endl;
break;
}
}
return 0;
}
29 do-while循环结构
#include<iostream>
using namespace std;
/*
do-while循环语句
作用 : 满足循环条件,执行循环语句
语法 : do{循环语句} while (循环条件);
注意 : 与while循环语句的差别在于do-while循环会先执行一遍循环语句,然后再进行判断
*/
int main() {
int num = 0;
do
{
cout << num << endl;
num++;
} while (num < 10);
// 0 1 2 3 4 5 6 7 8 9
return 0;
}
30 案例 : 水仙花数
#include<iostream>
using namespace std;
/*
练习案例：水仙花数
案例描述：水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身
例如：1^3 + 5^3+ 3^3 = 153
请利用do...while语句，求出所有3位数中的水仙花数
*/
int main() {
int num = 100;
do
{
int num1 = num / 100; // 获取百位
int num2 = num / 10 % 10; // 获取十位
int num3 = num % 10; // 获取个位
if (num == (num1*num1*num1 + num2*num2*num2 + num3*num3*num3))
{
cout << num << endl;
}
num++;
} while (num < 1000);
return 0;
}
31 for循环
#include<iostream>
using namespace std;
/*
for循环
练习案例：敲桌子
案例描述：
从1开始数到数字100， 如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子
其余数字直接打印输出。
*/
int main() {
for (int i = 1; i <= 100 ; i++)
{
//数字各位为7||数字是7的倍数||数字的十位有7
if (i % 10==7 || i % 7 == 0 || i / 10 == 7)
{
cout << "敲桌子" << endl;
}
else {
cout << i << endl;
}
}
return 0;
}
32 案例 : 循环嵌套实现九九乘法表
#include<iostream>
using namespace std;
/*
九九乘法表
*/
int main() {
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
cout << j << " * " << i << " = " << i * j << "\t";
}
cout << endl;
}
return 0;
}
33 break
#include<iostream>
using namespace std;
/*
break语句
作用 : 用于跳出选择结构或循环结构
break的使用时机:
1. 出现在switch语句中,作用是终止case并跳出switch
2. 出现在循环语句中,作用是跳出当前的循环语句
3. 出现在内层循环中,作用是跳出最近的内层循环
*/
int main() {
//比如说九九乘法表,不打印5
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
if (i == 5)
{
break;
}
cout << j << " * " << i << " = " << i * j << "\t";
}
cout << endl;
}
return 0;
}
34 continue
#include<iostream>
using namespace std;
/*
continue语句
作用 : 在循环语句中,跳过本次循环中余下尚未执行的语句,继续下一次循环
*/
int main() {
//打印1~100,但是跳过偶数
for (int i = 1; i <= 100; i++)
{
if (i % 2 == 0)
{
continue;
}
cout << i << endl;
}
return 0;
}
35 goto
#include<iostream>
using namespace std;
/*
作用：可以无条件跳转语句
语法： goto 标记
解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
注意：在程序中不建议使用goto语句，以免造成程序流程混乱
*/
int main() {
cout << "1" << endl;
goto FLAG;
cout << "2" << endl;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;
return 0;
}
36 *一维数组
#include<iostream>
using namespace std;
/*
数组 : 所谓数组,就是一个集合,里面存放了相同类型的数据元素
特点
1. 数组中每个数据元素都是相同的数据类型
2. 数组是由连续的内存位置组成的
一维数组
1. 定义方式
1. 数据类型 数组名[ 数组长度 ];
2. 数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};
3. 数据类型 数组名[ ] = { 值1，值2 ...};
2. 一维数组名称的用途,数组名就是数组的首地址
1. 可以统计整个数组在内存中的长度
2. 可以获取数组在内存中的首地址
注意 :
1. 只有定义的时候可以批量初始化数组,如果定义的时候没有初始化数组,那么就只可以根据数组下标初始化数组
2. 不可以将数组赋值给另一个数组
c++11新特性:
1. 大括号初始化数组的时候可以不写等号
2. 列表初始化不允许缩窄转换
*/
int main() {
//定义方式1
int score[10];
//然后利用下标赋值
score[0] = 1;
score[1] = 2;
score[2] = 3;
score[3] = 4;
//定义方式2
int score2[10] = { 1,2,3,4,5,6,7 };//不够的补0
/*for (int i = 0; i < 10; i++)
{
cout << score2[i] << " " << endl;
}*/
//定义方式3
int score3[] = { 1,2,3,4,5 };
//统计数组长度以及元素个数
cout << "数组score3占用的内存空间为 : " << sizeof(score3) << endl;//20
cout << "数组score3的每个元素占用的内存空间为 : " << sizeof(score3[0]) << endl;//4
cout << "数组的元素个数为 : " << sizeof(score3) / sizeof(score3[0]) << endl;//5
//获取数组在内存中的首地址,每次运行得到的地址都不一样
cout << "数组首地址为(十进制) : " << (int)score3 << endl;
cout << "数组首地址为(十六进制) : " << score3 << endl;
cout << "数组中第一个元素地址为 : " << (int)&score[0] << endl;
cout << "数组中第二个元素地址为 : " << (int)&score[1] << endl;
//数组名是常量,不可以进行赋值操作
//score3 = 100;
//c++11新特性
int score4[3]{ 1,2,3 };
return 0;
}
37 案例 ：五只小猪称体重
#include<iostream>
using namespace std;
/*
练习案例：五只小猪称体重
案例描述：
在一个数组中记录了五只小猪的体重，如：int arr[5] = {300,350,200,400,250};
找出并打印最重的小猪体重。
*/
int main() {
int arr[5] = { 300,350,200,400,250 };
int max = arr[0];
for (int i = 1; i < 5; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
}
cout << "最大值为 : " << max << endl;
return 0;
}
38 案例 : 数组元素逆置
#include<iostream>
using namespace std;
/*
练习案例：数组元素逆置
案例描述：
请声明一个5个元素的数组，并且将元素逆置.
(如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);
*/
int main() {
int arr[] = { 1,3,2,5,4,1,2,5,3 };
int temp = 0;//辅助变量,用于交换元素
int length = sizeof(arr) / sizeof(arr[0]);
for (int i = 0, j = length - 1; i <= length / 2; i++, j--)
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
for (int i = 0; i < length; i++)
{
cout << arr[i] << " " << endl;
}
return 0;
}
39 冒泡排序
#include<iostream>
using namespace std;
/*
实现冒泡排序
*/
int main() {
int arr[] = {12,231,2315,42,12,6,213,76,2,87,57,4 };
int length = sizeof(arr) / sizeof(arr[0]);//数组元素个数
int temp = 0;//辅助变量,用于交换数据
bool flag = false;
for (int i = 0; i < length - 1; i++)//外层循环定义排序趟数
{
flag = false;
for (int j = 1; j < length - i; j++)
{
if (arr[j]>arr[j-1])
{
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
flag = true;
}
}
if (!flag)//说明一趟排序中没有发生交换,则不用再进行之后的排序,数组已经有序
{
break;
}
}
for (int i = 0; i < length; i++)
{
cout << arr[i] << " " ;
}
return 0;
}
40 *二维数组
#include<iostream>
using namespace std;
/*
二维数组 : 二维数组就是在一维数组上，多加一个维度。
1. 定义方式:
1. 数据类型 数组名[ 行数 ][ 列数 ];
2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
4. 数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
建议：以上4种定义方式，利用第二种更加直观，提高代码的可读性
总结: 在定义二维数组时，如果初始化了数据，可以省略行数
2. 数组名:
总结1：二维数组名就是这个数组的首地址
总结2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小
*/
int main() {
//方式1
int arr[2][3];
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 4;
arr[1][1] = 5;
arr[1][2] = 6;
//for (int i = 0; i < 2; i++)
//{
// for (int j = 0; j < 3; j++)
// {
// cout << arr[i][j] << "\t";
// }
// cout << endl;
//}
方式2
//int arr2[2][3] = { {11,22,33},{44,55,66} };
//for (int i = 0; i < 2; i++)
//{
// for (int j = 0; j < 3; j++)
// {
// cout << arr2[i][j] << "\t";
// }
// cout << endl;
//}
方式3
//int arr3[2][3] = { 10,11,12,13,14,15 };
//for (int i = 0; i < 2; i++)
//{
// for (int j = 0; j < 3; j++)
// {
// cout << arr3[i][j] << "\t";
// }
// cout << endl;
//}
方式4
//int arr4[][3] = { 6,5,4,3,2,1 };
//for (int i = 0; i < 2; i++)
//{
// for (int j = 0; j < 3; j++)
// {
// cout << arr4[i][j] << "\t";
// }
// cout << endl;
//}
//查看二维数组所占用的空间
cout << "二维数组占用的空间为 : " << sizeof(arr) << endl;//24
//二维数组一行大小
cout << "二维数组一行的大小 : " << sizeof(arr[0]) << endl;//12
//二维数组一个数据元素的大小
cout << sizeof(arr[0][0]) << endl; //4
cout << "行数 : " << sizeof(arr) / sizeof(arr[0]) << endl;//2
cout << "列数 : " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;//3
//地址
cout << "首地址" << (int)arr << endl;
cout << "第一行首地址" << (int)&arr[0] << endl;
cout << "第一个元素地址" << (int)&arr[0][0] << endl;
return 0;
}
41 案例 : 考试成绩统计
#include<iostream>
using namespace std;
/*
考试成绩统计：
案例描述：
有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩
*/
int main() {
int scores[3][3] =
{
{100,100,100},
{90,50,100},
{60,70,80},
};
string names[3] = { "张三","李四","王五" };
for (int i = 0; i < 3; i++)
{
int sum = 0;
for (int j = 0; j < 3; j++)
{
sum += scores[i][j];
}
cout << names[i] << "同学的总成绩为 : " << sum << endl;
}
return 0;
}
42 *函数
#include<iostream>
using namespace std;
/*
1. 函数 :
作用 : 将一段经常使用的代码封装起来,减少重复代码,一个较大的程序,一般分为若干个程序块,每个模块实现特定的功能
2. 函数的定义 :
1. 返回值类型
2. 函数名
3. 参数表列
4. 函数体语句
5. return表达式
返回值类型 函数名 （参数列表）
{
函数体语句
return表达式
}
3. 注意 : c++中,不允许函数的嵌套定义,每个函数的定义都是独立的,所有函数的创建都是平等的
*/
//示例：定义一个加法函数，实现两个数相加
int add(int num1, int num2) {
//num1 num2称之为形参,因为定义函数的时候,num1和num2并没有真实数据
//当调用函数的时候,实参的值会传递给形参
return num1 + num2;
}
int main() {
int a = 10;
int b = 20;// a,b称之为实参
int c = add(a, b);
cout << "c = " << c << endl;
return 0;
}
43 值传递
#include<iostream>
using namespace std;
/*
值传递:
所谓值传递,就是函数调用的时候,实参将数值传入给形参
值传递的时候,如果形参发生任何改变,并不会影响实参
*/
//定义函数,实现两个数字进行交换
void swap(int num1, int num2) {
//交换前
cout << "交换前:num1 = " << num1 << endl;//10
cout << "交换前:num2 = " << num2 << endl;//20
int temp = num1;
num1 = num2;
num2 = temp;
//交换后
cout << "交换后:num1 = " << num1 << endl;//20
cout << "交换后:num2 = " << num2 << endl;//10
return;//没有返回值的时候,可以不写return
}
int main() {
int a = 10;
int b = 20;
swap(a, b);
cout << "a = " << a << endl;//10
cout << "b = " << b << endl;//20
return 0;
}
44 函数声明
#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 main() {
int num1 = 10;
int num2 = 20;
cout << max(num1, num2) << endl;
return 0;
}
//函数的定义
int max(int a, int b) {
return a > b ? a : b;
}
45 函数的分文件编写
- swap.h头文件
#pragma once
#include<iostream>
using namespace std;
//函数的声明
void swap(int a, int b);
- swap.cpp源文件
#include "swap.h"
//函数的定义
void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
#include "swap.h"
/*
函数的分文件编写
作用 : 让代码结构更加清晰
步骤 :
1. 创建后缀名为.h的头文件
2. 创建后缀名为.cpp的源文件
3. 在头文件中写函数的声明
4. 在源文件中写函数的定义
*/
int main() {
int a = 10;
int b = 20;
swap(a, b);
return 0;
}
46 *指针的定义和使用
#include<iostream>
using namespace std;
/*
指针 : 保存地址
作用 : 可以通过指针间接访问内存(可以通过指针保存一个地址)
注意 :
1. 内存编号是从0开始记录的,一般用十六进制数字表示
2. 可以利用指针变量保存地址
& : 取地址符
*p : 解引用
*/
int main() {
//1. 定义一个指针
int a = 10;
//指针定义的语法 数据类型 * 指针变量名;
int* p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址为" << &a << '\n';
cout << "指针p为" << p << '\n';//两者的输出是一样的
//2. 如何使用指针
//可以通过解引用 (指针前加*,找到指针指向的内存的数据) 的方式,找到指针指向的内存的数据
cout << *p << '\n';
return 0;
}
47 指针的占用空间
#include<iostream>
using namespace std;
/*
指针所占的内存空间
问 : 指针也是种数据类型,那么这种数据类型占用的空间是多少呢?
答 : 所有指针类型,在32位操作系统(x86)下是4个字节,在64位(x64)下占8个字节
*/
int main() {
int a = 10;
long long b = 20;
int* p;
long long* p2 = &b;
p = &a;//指针p指向a的地址
cout << sizeof(p) << '\n';//4
cout << sizeof(*p) << '\n';//4
cout << sizeof(*p2) << '\n';//8
cout << sizeof(char*) << '\n';//4
cout << sizeof(float*) << '\n';//4
cout << sizeof(double*) << '\n';//4
cout << sizeof(bool*) << '\n';//4
return 0;
}
48 空指针和野指针
#include<iostream>
using namespace std;
/*
空指针 : 指针变量指向内存中编号为0的空间
1. 用途 : 初始化指针变量 ( 创建了一个指针还不知道指哪,就可以让他先指NULL )
2. 注意 : 空指针指向的内存是不可以访问的
野指针 : 指针变量指向非法的内存空间( 0~255之间的内存编号是系统占用的,因此不可以访问 )
在程序中,一定要避免出现野指针
总结 : 空指针和野指针都不是我们申请的空间,因此不要访问
*/
int main() {
// 空指针
int* p = NULL;
cout << p << endl;//00000000
//一旦执行 *p 就会报错
// 野指针
int* p2 = (int *)0x1100;
//cout << *p2 << endl;//会报错 : 引发了异常: 读取访问权限冲突。
return 0;
}
49 *conts修饰指针
#include<iostream>
using namespace std;
/*
const修饰指针有三种情况:
1. const修饰指针 -- 常量指针
2. const修饰常量 -- 指针常量
3. const即修饰指针,又修饰常量
记忆方法 : 其实就看const是在 “*” 前面还是后面就得了。在 “*” 前面，就是指常量，在“*”后面就是指常指针。
*/
int main() {
int a = 10;
int b = 10;
//const 修饰的是指针,指针的指向可以改,指针指向的值不可以改 --常量指针
const int* p1 = &a;
//const 修饰的是常量,指针的指向不可以改,指针指向的值可以更改 --指针常量
int* const p2 = &b;
//const 即修饰常量,也修饰指针
const int* const p3 = &a;
return 0;
}
50 指针和数组配合使用
#include<iostream>
using namespace std;
/*
指针和数组
作用 : 利用指针访问数组元素,数组名就是一个地址,是首地址
*/
int main() {
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr; // 指向数组的指针
for (int i = 0; i < 10; i++)
{
cout << *p << endl;
p++;
}
return 0;
}
51 指针和函数
#include<iostream>
using namespace std;
/*
指针和函数
作用 : 利用指针作为函数参数,可以修改实参的值
总结 : 如果不想修改实参，就用值传递，如果想修改实参，就用地址传递
*/
//值传递
void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
}
//地址传递
void swap2(int* p1, int* p2) {//因为传入的是地址,所以需要用指针来接收
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main() {
int a = 10;
int b = 20;
swap(a, b);
cout << "值传递" << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
swap2(&a, &b);//传入的是地址
cout << "地址传递" << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
return 0;
}
52 案例 : 指针 数组 函数
#include<iostream>
using namespace std;
/*
案例描述 : 封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针
*/
//函数声明
void bubbleSort(int* arr, int len);
void printArray(int* arr, int len);
//主函数
int main() {
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
int len = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, len);
printArray(arr, len);
return 0;
}
//函数的定义
void bubbleSort(int* arr, int len) {
for (int i = 0; i < len - 1 ; i++)
{
for (int j = 1; j < len - i; 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) {
for (int i = 0; i < len; i++)
{
cout << arr[i] << endl;
}
}
53 结构体
#include<iostream>
using namespace std;
/*
结构体基本概念 : 结构体属于用户自定义的数据类型,允许用户存储不同的数据类型
结构体的定义和使用
1. 语法:
struct 结构体名 { 结构体成员列表 };
2. 通过结构体创建变量的方式有三种 :
1. struct 结构体名 变量名
2. struct 结构体名 变量名 = {成员1值,成员2值,成员3值...}
1~2的struct关键字可以省略
3. 定义结构体的时候顺便创建变量
总结1：定义结构体时的关键字是struct，不可省略
总结2：创建结构体变量时，关键字struct可以省略
总结3：结构体变量利用操作符 ''.'' 访问成员
*/
//结构体的定义
struct student
{
string name;//姓名
int age = 0; //年龄
int score = 0; //分数
}stu3;//方式3-->定义结构体的时候顺便创建变量
int main() {
//方式3
stu3.name = "何佳乐";
stu3.age = 22;
stu3.score = 100;
cout << stu3.name << " + " << stu3.age << " + " << stu3.score << endl;
//方式1
student stu1;
stu1.name = "吴超";
stu1.age = 21;
stu1.score = 100;
cout << stu1.name << " + " << stu1.age << " + " << stu1.score << endl;
//方式2
student stu2 = { "曹越" , 23 , 100 };
cout << stu2.name << " + " << stu2.age << " + " << stu1.score << endl;
return 0;
}
54 结构体数组
#include<iostream>
using namespace std;
/*
结构体数组
作用 : 将自定义的结构体放入到数组中方便维护
语法 : struct 结构体名 数组名[ 元素个数 ] = { {},{},{}...};
结构体指针
作用 : 通过指针访问结构体中的成员
总结 : 结构体指针可以通过 -> 操作符 来访问结构体中的成员
*/
//结构体的定义
struct student {
string name;
int age;
int score;
};
int main() {
student stus[3] = {
{"zhangsan" , 12 , 100},
{"lisi" , 14 , 100},
{"wangwu" , 19 , 100}
};
cout << sizeof(stus) / sizeof(stus[0]) << endl;//3
for (int i = 0; i < 3; i++)
{
cout << "姓名 : " << stus[i].name << "\t年龄 : " << stus[i].age << "\t成绩 : " << stus[i].score << endl;
}
//结构体指针
student* p = stus;
cout << "姓名 : " << p->name << "\t年龄 : " << p->age << "\t成绩 : " << p->score << endl;
p++;
cout << "姓名 : " << p->name << "\t年龄 : " << p->age << "\t成绩 : " << p->score << endl;
p++;
cout << "姓名 : " << p->name << "\t年龄 : " << p->age << "\t成绩 : " << p->score << endl;
return 0;
}
55 结构体嵌套
#include<iostream>
using namespace std;
/*
结构体嵌套结构体
作用 : 结构体中的成员可以是另一个结构体
例如 : 每个老师辅导一个学生,一个老师的结构体中,记录一个学生的结构体
总结 : 在结构体中可以定义另一个结构体作为成员，用来解决实际问题
*/
//学生结构体定义
struct student {
string name; //学生姓名
int age; //学生年龄
int score; //学生成绩
};
//老师结构体定义
struct teacher {
int id; //老师的工号
string name; //老师姓名
int age; //老师年龄
student stu; //老师辅导的学生
};
int main() {
student stu1 = { "zhangsan" , 12 , 100 };
teacher tea1 = { 12 , "laoshi" , 44 , stu1 };
cout << "老师工号 : " << tea1.id << "\t老师姓名 : " << tea1.name << "\t老师年龄 : " << tea1.age << "\t老师辅导的学生的成绩" << tea1.stu.score << endl;
return 0;
}
56 *结构体做函数参数
#include<iostream>
using namespace std;
/*
结构体做函数参数:
说明 : 我在学习的过程中,因为是先学习的java,所以将地址传递联想到了java的引用类型,然后想当然的把struct类比为
java中的类,那自然默认是引用类型传递,也就是当结构体做函数传递的时候,结构体变量名就是地址,其实这是错误
的,c++中struct也属于普通的数据类型,也有值传递和地址传递
总结 : 如果不想修改主函数中的数据，用值传递，反之用地址传递
*/
struct student {
string name;
int age;
int score;
};
//值传递
void printStudent1(student stu) {
stu.age = 40;
cout << "姓名 : " << stu.name << "\t年龄 : " << stu.age << "\t成绩 : " << stu.score << endl;
}
//地址传递
void printStudent2(student* stu) {
stu->age = 40;
cout << "姓名 : " << stu->name << "\t年龄 : " << stu->age << "\t成绩 : " << stu->score << endl;
}
int main() {
student stu = { "何佳乐" , 22 , 100 };
cout << "值传递" << endl;
printStudent1(stu);
cout << "姓名 : " << stu.name << "\t年龄 : " << stu.age << "\t成绩 : " << stu.score << '\n' << endl;
cout << "地址传递" << endl;
printStudent2(&stu);
cout << "姓名 : " << stu.name << "\t年龄 : " << stu.age << "\t成绩 : " << stu.score << endl;
return 0;
}
57 结构体和const
#include<iostream>
using namespace std;
/*
结构体中const的使用场景
作用 : 用const来防止误操作
*/
struct student {
string name;
int age;
int score;
};
//const的使用场景
void printStudent(const student* stu) {
//不可操作,因为const在*前,所以stu是常量,我们无法修改常量的值,这个时候只可以修改指针的指向
//stu->age = 100;
//修改指向
/*student stu2 = { "李四",18,100 };
stu = &stu2;*/
cout << "姓名 : " << stu->name << "\t年龄 : " << stu->age << "\t成绩 : " << stu->score << endl;
}
int main() {
student stu = { "张三",18,100 };
printStudent(&stu);
return 0;
}
58 结构体案例1
#include<iostream>
using namespace std;
/*
案例描述 :
学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员
学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值
最终打印出老师数据以及老师所带的学生数据。
*/
//定义结构体
struct student {
string name;
int score;
};
struct teacher {
string name;
student stus[5];
};
//定义函数
void allocateSpace(teacher tArray[], int len) {
string tName = "教师";
string sName = "学生";
string nameSeed = "ABCDE";
for (int i = 0; i < len; i++)
{
tArray[i].name = tName + nameSeed[i];
for (int j = 0; j < 5; j++)
{
tArray[i].stus[j].name = sName + nameSeed[j];
tArray[i].stus[j].score = rand() % 61 + 40;//0~60 + 1 --> 1~100
}
}
}
void printTeachers(teacher tArray[], int len) {
for (int i = 0; i < len; i++)
{
cout << tArray[i].name << endl;
for (int j = 0; j < 5; j++)
{
cout << "\t姓名 : " << tArray[i].stus[j].name << "\t分数 : " << tArray[i].stus[j].score << endl;
}
}
}
int main() {
srand((unsigned int)time(NULL));
teacher tArray[3];
int len = sizeof(tArray) / sizeof(tArray[0]);
allocateSpace(tArray, len);
printTeachers(tArray, len);
return 0;
}
59 结构体案例2
#include<iostream>
using namespace std;
/*
案例描述：
设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。
通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。
*/
//定义英雄结构体
struct Hero {
string name;
int age;
string sex;
};
//定义冒泡排序方法
void bubbleSort(Hero heros[], int len)
{
bool flag = false;
for (int i = 0; i < len - 1; i++)
{
for (int j = 1; j < len - i; j++)
{
if (heros[j].age < heros[j - 1].age)
{
/*int temp = heros[j].age;
heros[j].age = heros[j - 1].age;
heros[j - 1].age = temp;*/
Hero temp = heros[j];
heros[j] = heros[j - 1];
heros[j - 1] = temp;
flag = true;
}
}
if (!flag)
{
break;
}
flag = false;
}
}
//打印数组
void printHeros(Hero heros[], int len)
{
for (int i = 0; i < len; i++)
{
cout << "姓名 : " << heros[i].name << "\t年龄 : " << heros[i].age << "\t性别 : " << heros[i].sex << endl;
}
}
int main() {
Hero heros[5] = {
{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",21,"男"},
{"貂蝉",19,"女"}
};
bubbleSort(heros, 5);
printHeros(heros, 5);
return 0;
}
60 *namespace
#include<iostream>
//using namespace std;
//using std::cout;
//using std::endl;
/*
namespace可以方便我们的操作,如果我们编写的是大型项目,或者将多个厂商现有的代码组合起来的时候,会有一个潜在的问题
可能会有多个已封装好的产品存在相同的函数,这个时候编译器就无法确切的知道这个函数是属于哪个版本的了,命名空间可以让
厂商将其产品封装在一个名称空间的单元中,这样子就可以使用名称空间的名称来具体指出想使用哪个厂商的产品
所以,如果没有using namespace std;
cout << "--" << endl;应该写成
std::cout << "--" << std::endl;
所以using namespace std;可以看作偷懒的行为,让我们可以少些很多内容,但是在实际开发中,我们推荐下面的写法
using std::cout
using std::endl
还需要注意的是,我们经常会将命名空间写在头文件名后面,但是这并不是强制的,我们也可以将命名空间写到main函数里面,那么这个
时候,命名空间只针对main函数,比如在test方法中,cout << "曹越" << endl;语句就是错误的
当前通行的理念是,只让需要访问命名空间std的函数访问他是最好的选择,比如有两个函数main和test,只有main需要用到cout,而
tset不需要,那么这个时候我们最好将命名空间的定义放到main函数中,而不是放到函数外,使得只有mian函数可以访问命名空间
*/
void test() {
//会报错//cout << "曹越" << endl;
}
int main() {
using std::cout;
using std::endl;
//std::cout << "何佳乐" << std::endl;
cout << "何佳乐" << endl;
return 0;
}
61 *cout和endl
#include<iostream>
using namespace std;
/*
1. cout:
1. cout 是一个预定义的对象,知道如何显示字符串,数字和单个字符
(提前了解对象 : 对象是类的特定实例,而类定义了数据的存储和实现方式,这里表现了对象的长处,不了解对象的内部情况
就可以使用他,只需要知道他的接口,即如何使用他)
2. 整数25与字符串25存在天壤之别,计算机中,整数25存储的是25对应的二进制,而字符串25存储的是2和5分别对应的
ASC2编码,这里我们就要夸一夸cout的聪明了,cout可以知道要输出的是字符串还是整数还是浮点数,而老式的printf不可以
,他需要程序员指定要输出的是哪种数据类型
cout的智能行为源自c++的面向对象特性,c++插入运算符(<<)将根据其后的数据类型相对应的调整其行为,这是一个运算符重载的例子,cout是可扩展的,我们可以重新定义<<运算符,使得cout可以识别和显示所开发的新数据类型
2. endl:
endl是一个特殊的c++符号,表示一个重要的概念,重启一行
3. endl和'\n'
(选自书上的一段话,个人没有完全理解)
endl确保程序继续运行前刷新输出(将其立刻显示在屏幕上),而使用'\n'不能够提供这样子的保证,这意味着在有些系统中
又是可能在您输入信息后才会出现提示
*/
int main() {
return 0;
}
62 *赋值语句
#include<iostream>
using namespace std;
/*
赋值语句将值赋给存储单元,例如,下面的句子将整数25赋值给变量carrots标识的内存单元
carrots = 25;
c++和c不一样的地方在于,c++允许连续使用赋值运算符(=),例如,下面的语句在c++中是正确的
num1 = num2 = num3 = 10;
这里要注意的是,赋值是从右至左进行的,首先,10先赋值给num3,然后num3的值赋值给num2,最后num2的值赋值给num1
*/
int main() {
return 0;
}
63 声明语句和变量
#include<iostream>
using namespace std;
/*
计算机是一种精确的,有条理的机器,要将信息项存储到计算机中,就必须指出信息的存储位置和所需的内存空间
在c++中,完成这一任务有一种相对简便的方法,就是使用
声明语句
来指出存储类型并提供位置标签
例如 :
int carrots;
这条语句包含了两个信息,需要的内存以及该内存单元的名称
1. 在c++中,int表示整数,这条语句指出程序需要足够的存储空间来存储一个整数
2. 第二项任务是给存储单元指定名称,因为我们要是每次使用数据都要写出该数据的存储位置的话,会非常麻烦,因为数据的
存储地址通常都是16进制的数字,所以我们给存储单元指定一个名字,跳过该名字使用数据,会方便程序员的操作.该声明语句
指出,之后将使用carrots来标识存储在该内存单元中的值,carrots被称之为变量,因为他的值可以修改
程序中的声明语句叫做定义声明语句,简称为定义,当然,之后还会学习到更为复杂的 引用声明
*/
int main() {
int carrots;
return 0;
}
64 unsigned
#include<iostream>
#include<climits>
#define ZERO 0;
/*
unsigned 代表无符号数
在double ,int , long , long long前加上unsigned就会变为对应的无符号数,无符号数的好处是没有负值,所以可以扩大数字的
表示范围,最好用在没有负数的情况,比如人口,资源总量等等
注意 : unsigned 就是unsigned int 的缩写
下面的例子可以明显的表示出unsigned的特点,并且要观察发生溢出后的结果有什么规律
*/
int main() {
using namespace std;
short sam = SHRT_MAX; // 32767 最大值
unsigned short sue = sam; // sue = sam = 32767,无符号数short的最大值为65535,表示范围为0~65535
cout << "sam = " << sam << endl;//32767
cout << "sue = " << sue << endl;//32767
sam = sam + 1;
sue = sue + 1;
cout << "sam = " << sam << endl; //-32768
cout << "sue = " << sue << endl; //32768-->因为无符号数的表示范围更大
sam = ZERO;
sue = ZERO;
cout << "sam = " << sam << endl; // 0
cout << "sue = " << sue << endl; // 0
sam = sam - 1;
sue = sue - 1;
cout << "sam = " << sam << endl; // -1
cout << "sue = " << sue << endl; // 65535
return 0;
}
65 进制
#include<iostream>
using namespace std;
/*
c++可以以三种不同的计数方式来书写整数,10.8.16
c++使用前1~2位来标识数字常量的基数
1. 若第一位为1~9 ->十进制
2. 若第一位为0,第二位为1~7 ->八进制
3. 若前两位为0x或0X ->十六进制
下面的案例可以说明如上的内容
注意 :
1. 默认情况下,cout以十进制格式显示整数
2. 不论是几进制,计算机都是以二进制的方式存储数据
如果要用cout按进制显示数据,也可以使用cout的一些特性,与endl一样,cout 提供了控制符dex hex oct分别用于
十进制,十六进制和八进制
*/
int main() {
int num1 = 42;
int num2 = 0x42;
int num3 = 042;
cout << "num1 = " << num1 << endl;//42
cout << "num2 = " << num2 << endl;//66
cout << hex << "原十六进制显示 : " << num2 << endl;//42
cout << "num3 = " << num3 << endl;//34
cout << oct << "原八进制显示 : " << num3 << endl; //42
return 0;
}
66 **列表初始化
#include<iostream>
using namespace std;
/*
潜在的数值转换问题
1. 将较大的浮点数转换为较小的浮点数类型,如将double转换为float-->精度(有效数位)降低,值可能超出目标类型的取值
范围,在这种情况下,结果将是不确定的
2. 将浮点类型转换为整型-->小数部位丢失,原来的值去掉小数后可能超过对应整型的取值范围,结果将不确定
3. 将较大的整型转换为较小的整型,如将long转换为short-->原来的值可能超出目标类型的取值范围,通常只取右边的部分
*/
int main() {
//1. 初始化或赋值进行的转换
cout.setf(ios_base::fixed, ios_base::floatfield);
float tree = 3; // int ->float
int guess(3.3983); // double -> int ,这里发生的是截取而不是四舍五入
int debt = 7.2E12;
cout << "tree = " << tree << endl;
cout << "guess = " << guess << endl;
cout << "debt = " << debt << endl;
/*
tree = 3.000000
guess = 3
debt = 1634811904
*/
//2. 花括号转换
/*
以花括号{}方式初始化时进行的转换-->列表初始化,这种初始化方式通常用于给复杂的数据类型提供值列表,这种转换与
上面的转换相比,要求更加严格,他不允许收缩转换,即如果接收的变量类型可能无法正确表示赋给他的值,比如将
int a = (int)3212999L,就是不允许的
也不允许将浮点值转换为整型
*/
const int code = 66;
int x = 66;
//char c1{ 31313 };//报错 : 从int转换到char需要收缩转换
char c2 = { 66 };//允许,因为char的取值范围包括66
char c3 = { code };//允许
//char c4 = { x };//报错,从int到char需要收缩转换,虽然可能认为,x不是66嘛?但是编译器不会考虑到这么多,因为x是int变量
//所以int -> char 是大转小,不允许
//但是,如果c4采用的是常规赋值进行的转化,就可以
char c4 = x;
//3. 表达式中的转换
/*
3.1 在计算表达式的时候,c++将bool,char,unsigned char,signed char 和 short值转换为int,具体的说,true -> 1
false -> 0,这些转换被称之为整型提升
*/
short s1 = 20;
short s2 = 30;
short s3 = s1 + s2;
/*
上述代码,在计算的时候,c++程序取到s1和s2的值,然后将他们转换为int,计算完成之后,再将结果转换为short
注意 :
如果short比int短,则unsigned short 转换为 int
如果两者一样长,则unsigned short 转换为 unsigned int,这样子可以保证不会丢失数据
*/
/*
3.2 不同类型进行算数运算的时候,例如int和float相加,当运算涉及到两种类型的时候,较小的类型会转换为较大的类型
*/
cout << sizeof(2 + 3.4); // 8
return 0;
}
67 强制类型转换
#include<iostream>
using namespace std;
/*
*/
int main() {
int num1, num2, num3;
num1 = 19.99 + 11.99;
num2 = (int)19.99 + (int)11.99;//c语言风格的强制类型转换
num3 = int(19.99) + int(11.99);//c++语言风格的强制类型转换,这样子的目的是取值类型转换看起来就和函数调用一样
cout << "num1 = " << num1 << endl;//31,因为num1的计算结果是先double类型相加,然后得到的结果通过舍去小数位转为int
cout << "num2 = " << num2 << endl;//30,而num2和num3的计算是先类型转换为int然后相加,
cout << "num3 = " << num3 << endl;//30
char ch = 'z';
cout << "the code for " << ch << " is " << int(ch) << endl;//122
//c++引入的强制类型转换符,该运算符比传统取值类型转换更加严格,更加安全
cout << "the code for " << ch << " is " << static_cast<int>(ch) << endl;//122
return 0;
}
68 **内存分析模型
#include<iostream>
using namespace std;
/*
内存分区模型 : c++程序在执行的时候,将内存大体分为四个区域
1. 代码区 : 存放函数的二进制代码,由os进行管理, -- 注释不会进入代码区
2. 全局区 : 存放全局变量和静态变量以及常量
3. 栈区 : 由编译器自动分配释放,存放函数的参数值,局部变量等等
4. 堆区 : 由程序员分配和释放,若程序员不释放,程序结束时由os回收
内存四区的意义 : 不同区域存放不同的数据,赋予不同的生命周期,给我们更大的灵活编程
1. 代码区：
存放 CPU 执行的机器指令
代码区是**共享**的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是**只读**的，使其只读的原因是防止程序意外地修改了它的指令
2. 全局区：
全局变量和静态变量存放在此.
全局区还包含了常量区, 字符串常量和其他常量也存放在此.
==该区域的数据在程序结束后由操作系统释放==.
3. 栈区:
由编译器自动分配释放, 存放函数的参数值(形参),局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放
*/
int* fun() {
int a = 10;//局部变量,存放在栈区,栈区的数据在函数执行完后自动释放
return &a;//返回局部变量的地址
}
int* fun2() {
//利用new关键字,可以将数据开辟到堆区
int* p = new int(10);
return p;
}
int main() {
//int* p = fun();//接收fun的返回值
//cout << *p << endl;//第一次可以打印正确的数据,是因为编译器做了保留
//cout << *p << endl;//第二次这个数据就不再保留了
int* p = fun2();
cout << *p << endl;
cout << *p << endl;
cout << *p << endl;
return 0;
}
69 *new操作符
#include<iostream>
using namespace std;
/*
C++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符 delete
语法： new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针
*/
int* func() {
//在堆区创建一个整型数据,堆区的数据由程序员管理和释放
int* p = new int(10);
return p;
}
void test01() {
int* p = func();
cout << *p << endl;
cout << *p << endl;
//如果想释放堆区的数据,利用关键字delete
delete p;
//内存已经被释放,再次访问就是非法操作,会报错
//cout << *p << endl;
}
void test02() {
//在堆区创建大小为10的整型数组
int* arr = new int[10];//注意,这里是方括号,不是圆括号,方括号里的10代表数组的大小为10,而圆括号里面的10代表值为10
for (int i = 0; i < 10; i++)
{
arr[i] = i + 100;
}
for (int i = 0; i < 10; i++)
{
cout << arr[i] << endl;
}
//释放堆区的数组,但是要注意,这里和释放变量不一样
delete[] arr;
}
int main() {
test01();//10
test02();
return 0;
}
70 引用的基本使用
#include<iostream>
using namespace std;
/*
引用的基本使用
作用 : 给变量起别名
语法 : 数据类型 &别名 = 原名
引用vs指针
1. 不存在空引用,引用必须知道一个合法的内存空间,但是指针存在空指针和野指针
2. 一旦引用初始化为一个对象,就不可以指向另一个对象,所以,引用和常指针很像.指针可以在任何时候指向到另一个对象,引用指向对象的值是可以修改的
3. 引用必须在创建的时候就初始化,指针可以在任何时间初始化
*/
int main() {
int a = 10;
int& b = a;
b = 20;
cout << "a = " << a << endl;
return 0;
}
71 引用做函数参数
#include<iostream>
using namespace std;
/*
引用做函数参数
1. 作用 : 函数传参的时候,可以利用引用技术,让形参修饰实参(也就是形参改变,实参也改变,类似地址传递)
2. 优点 : 可以简化指针
引用一般用在做函数参数的情况比较多,通过引用参数产生的效果和使用地址传递的效果是一样的,引用的语法更清楚简单
*/
//交换
//引用传递
void swap1(int& num1, int& num2) {
int temp = num1;
num1 = num2;
num2 = temp;
}
//地址传递
void swap2(int* p1, int* p2) {
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
//值传递
void swap3(int num1, int num2) {
int temp = num1;
num1 = num2;
num2 = temp;
}
int main() {
int num1 = 10;
int num2 = 20;
//使用引用传递
swap1(num1, num2);
cout << "num1 = " << num1 << endl;//20
cout << "num2 = " << num2 << endl;//10
//使用地址传递
swap1(num1, num2);
cout << "num1 = " << num1 << endl;//10
cout << "num2 = " << num2 << endl;//20
//使用值传递
swap1(num1, num2);
cout << "num1 = " << num1 << endl;//10
cout << "num2 = " << num2 << endl;//20
return 0;
}
72 引用做函数返回值
#include<iostream>
using namespace std;
/*
引用做函数返回值
1. 作用 : 引用是可以作为函数的返回值的
2. 注意 : 不要返回局部变量引用
3. 语法 : 函数调用作为左值
因为函数返回的是一个引用,所以我们可以把函数放到赋值语句的左边
*/
double vals[] = { 10.1, 12.6, 33.1, 24.1, 50.0 };
double& setValue(int i) {
double& ref = vals[i];
return ref;//返回的是下标为i的元素的引用,ref是一个引用变量,ref引用vals[i],最后在返回shit
}
//当函数返回一个引用的时候,要注意被引用的对象不可以超出作用域,所以返回一个局部变量的引用是不合法的,但是,可以返回一个
//对静态变量的引用
int& setNum1() {
int num1;
return num1;
}
int& setNum2() {
static int a = 10;//静态变量,存放在全局区,全局区上的数据在程序结束后由系统释放
return a;
}
int main() {
int len = sizeof(vals) / sizeof(vals[0]);
cout << "改变前 : " << endl;
for (int i = 0; i < len; i++)
{
cout << "vals[ " << i << " ] = " << vals[i] << endl;
}
setValue(1) = 12;
setValue(3) = 13;
cout << "改变后 : " << endl;
for (int i = 0; i < len; i++)
{
cout << "vals[ " << i << " ] = " << vals[i] << endl;
}
return 0;
}
73 引用和指针
#include<iostream>
using namespace std;
/*
*/
int main() {
int b = 0;
int& a = b;
a = 4;
cout << "a = " << a << endl; // 4
cout << "b = " << b << endl; // 4
int* p = &b;
b = 100;
cout << "a = " << a << endl; // 100
cout << *p << endl; // 100
return 0;
}
74 *引用的本质
#include<iostream>
using namespace std;
/*
引用的本质
本质 : 引用的本质在c++内部实现是一个指针常量 (指针的指向不可以修改,值可以修改)
*/
//发现是引用，转换为 int* const ref = &a;
void func(int& ref) {
ref = 100; // ref是引用，转换为*ref = 100
}
int main() {
int a = 10;
//自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
int& ref = a;
ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
cout << "a:" << a << endl;
cout << "ref:" << ref << endl;
func(a);
return 0;
}
75 常量引用
#include<iostream>
using namespace std;
/*
常量引用
作用 : 常量引用主要用来修饰形参,防止误操作
在函数形参列表中,可以加const修饰形参,防止形参变实参
*/
//打印数据的函数
void showValue(const int& val) {
//val = 1000;//报错 : 表达式必须是可修改的左值
cout << "val = " << val << endl;
}
int main() {
//int a = 10;
//int& ref = 10;// 引用必须引用一块合法的空间
//const int& ref = 10;// 但是这样子就是正确的,加上const之后,编译器将代码,修改为
/*
int temp = 10;
const int& ref = temp;
这样子就合法了
*/
//ref = 20;//会报错:表达式必须是可修改的左值,这里的ref既不能修改指向,也不可以修改值,变为只读状态
int a = 100;
showValue(a);
cout << "a = " << a << endl;
return 0;
}
76 函数默认参数
#include<iostream>
using namespace std;
/*
函数默认参数
在c++中,函数的参数列表中的形参是可以有默认值的
语法 : 返回值类型 函数名 (参数 = 默认值) {}
注意 :
1. 假设参数列表的第n个参数加上了默认值,那么之后的参数也必须加上默认值
2. 函数声明和函数实现只能有一个有默认值
*/
int func(int a, int b = 20, int c = 30);
int func(int a, int b, int c) {
return a + b + c;
}
int main() {
//int sum = func(1, 2, 3);
int sum = func(10);
cout << sum << endl;//60
return 0;
}
77 *函数重载
#include<iostream>
using namespace std;
/*
函数重载
作用 : 函数名称可以相同,提高复用性
函数重载满足条件 :
1. 同一个作用域
2. 函数名称相同
3. 函数参数类型不同,或者个数不同或者顺序不同
注意 : 函数的返回值不可以作为函数重载的条件,也就是函数重载和返回值无关
*/
void func() {
cout << "func的调用" << endl;
}
//void func() {//这时候会运行失败,因为main不知道该调用哪个func函数,这两个func不满足函数重载的要求
// cout << "func的调用!" << endl;
//}
void func(int a) {
cout << "a = " << a << endl;
}
void func(double d) {
cout << "d = " << d << endl;
}
void func(int num1, int num2) {
cout << "int num1 = " << num1 << "|| int num2 = " << num2 << endl;
}
void func(int num1, double num2) {
cout << "int num1 = " << num1 << "|| double num2 = " << num2 << endl;
}
void func(double num1, int num2) {
cout << "double num1 = " << num1 << " || int num2 = " << num2 << endl;
}
//int func(double num1, int num2) {//报错 : 无法重载仅用返回值类型区分的函数
// cout << "double num1 = " << num1 << " || int num2 = " << num2 << endl;
//}
int main() {
func();
func(3);
func(3, 2.0);
func(2, 3);
func(2.0, 3);
return 0;
}
78 函数重载注意事项
#include<iostream>
using namespace std;
/*
1. 引用作为重载条件
const int& 和 int& 属于类型不同
2. 函数重载碰到函数默认参数
*/
//1. 引用作为重载条件
void func(int& a) {//也属于函数重载
cout << "func(int& a) 调用" << endl;
}
void func(const int& a) {
cout << "func(const int& a) 调用" << endl;
}
//2. 函数重载遇到函数默认参数
void func2(int a,int b = 10) {
cout << "func2(int a, int b = 10) 的调用" << endl;
}
void func2(int a) {
cout << "func2(int a) 的调用" << endl;
}
int main() {
int a = 10;
func(a);//func(int& a) 调用 , 因为传入的是变量,可读可写,而const修饰后变成只读的了,所以会调用没有const修饰的
func(10);//func(const int& a) 调用
/*
首先分析,如果调用的是第一个函数,那么等同于代码
int& a = 10;这是错误的,因为引用必须指向合法的内存空间
如果调用的是第二个函数
const int& a = 10;
然后编译器会帮助我们进行代码优化,变为 :
int temp = 10;
const int& a = temp;
就是正确的了
*/
//func2(10);//会报错,出现了二义性,两个func2函数都可以调用,所以在函数有默认参数的时候要注意,函数重载的时候就尽量不要默认参数了
return 0;
}
79 类和对象概述
#include<iostream>
using namespace std;
/*
类和对象
c++面向对象的三大特性为:
1. 封装
2. 继承
3. 多态
c++认为万事万物皆是对象,对象上有其属性和行为
类是用户定义的类型,但是作为用户,我们并没有设计ostream和istream类,就像函数可以来自函数库一样,类也可以来自类库
*/
int main() {
return 0;
}
80 封装
#include<iostream>
using namespace std;
/*
封装
意义 :
1. 将属性和行为作为一个整体,表现生活中的事物
2. 将属性和行为的权限加以控制
语法 :
class 类名{ 访问权限: 属性/行为 };
*/
#define PI 3.14
class circle
{
public://访问权限,公共的权限
//属性
int r;//半径
//行为
double caculateZC()
{
return 2 * PI * r;
}
};
int main() {
circle c;//实例化一个对象
c.r = 10;//给对象的属性赋值
cout << c.caculateZC() << endl;//62.8
return 0;
}
81 案例
#include<iostream>
using namespace std;
/*
设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
*/
class student
{
public:
//属性
string name;
string id;
public:
void setName(string s_name) {
name = s_name;
}
void setId(string s_id) {
id = s_id;
}
void toString() {
cout << "name = " << name << endl;
cout << "id = " << id << endl;
}
};
int main() {
student s1;
s1.setId("20171611607");
s1.setName("何佳乐");
s1.toString();
return 0;
}
82 权限控制
#include<iostream>
using namespace std;
/*
封装意义2 : 类在设计的时候,可以把属性和行为放在不同的权限下,加以控制
访问权限有3种
1. public 公共权限 类内可以访问,类外可以访问
2. protected 保护权限 类内可以访问,类外不可以访问
3. private 私有权限 类内可以访问,类外不可以访问
protected 和 private 的区别在继承会提到,这里简单说一下,就是继承的时候,子类的成员函数可以访问父类中保护权限的内容
但是子类不可以访问父类中的私有内容
*/
class person
{
public:
string name;//姓名,公共权限
protected:
string car; //汽车,保护权限
private:
int password;//密码,私有权限
public:
void func()
{
name = "zhangsan";
car = "拖拉机";
password = 123456;
}
void toString() {
cout << "name = " << name << endl;
cout << "car = " << car << endl;
cout << "password = " << password << endl;
}
};
int main() {
person p;
p.func();
p.name = "何佳乐";
//这里,p打点后发现car 和 password是不可以访问的,因为私有权限和保护权限,类外不可以访问
p.toString();
return 0;
}
83 struct 和 class的区别
#include<iostream>
using namespace std;
/*
c++中struct和class的区别(唯一)
1. struct默认权限为公共
2. class 默认权限为私有
*/
class C1
{
int m_A;//默认权限是私有,外部类无法访问
};
struct C2
{
int m_B;//默认权限是公共
};
int main() {
C1 c1;
//cout << c1.m_A << endl;//报错,不可访问
C2 c2;
c2.m_B = 100;
cout << c2.m_B << endl;
return 0;
}
84 成员属性设置为私有
#include<iostream>
using namespace std;
/*
成员属性设置为私有
1. 可以自己控制读写权限
2. 对于写可以检测数据的有效性
*/
class Person
{
private:
string name;// 读写
int age = 20; // 只读,写的年龄必须在0~100之间
string lover;//只写
public:
void setName(string s_name)
{
name = s_name;
}
string getName()
{
return name;
}
int getAge()
{
return age;
}
void setLover(string s_lover)
{
lover = s_lover;
}
void setAge(int s_age) {
if (s_age >150 || s_age < 0)
{
cout << "请输入合法的年龄" << endl;
return;
}
age = s_age;
}
};
int main() {
Person p;
p.setName("zhangsan");
cout << "name = " << p.getName() << endl;
cout << "age = " << p.getAge() << endl;
p.setLover("lisi");
p.setAge(50);
cout << "age = " << p.getAge() << endl;
return 0;
}
85 案例 : 立方体
#include "Cube.h"
/*
设计立方体类(Cube)
1. 求出立方体的面积和体积
2. 分别用全局函数和成员函数判断两个立方体是否一样
*/
//class Cube
//{
//private:
// int m_H;
// int m_L;
// int m_W;
//public:
// int getH(){
// return m_H;
// }
// int getW() {
// return m_W;
//
// }
// int getL() {
// return m_L;
// }
// void setH(int h)
// {
// m_H = h;
// }
// void setL(int l)
// {
// m_L = l;
// }
// void setW(int w)
// {
// m_W = w;
// }
// int getArea()
// {
// return (m_H * m_L + m_H * m_W + m_L * m_W) * 2;
// }
// int getVolume()
// {
// return m_H * m_L * m_W;
// }
// bool isEqual(Cube cube)
// {
// if (m_H == cube.getH() && m_W == cube.getW() && m_L == cube.getL())
// {
// return true;
// }
// return false;
// }
//
//};
int main() {
Cube cube;
cube.setH(10);
cube.setW(10);
cube.setL(10);
Cube cube2;
cube2.setH(10);
cube2.setW(10);
cube2.setL(10);
cout << "area = " << cube.getArea() << endl;
cout << "volume = " << cube.getVolume() << endl;
cout << cube.isEqual(cube2);
return 0;
}
86 案例 : 点和圆的关系,分文件编写
#include "Circle.h"
/*
设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。
*/
int main() {
Circle c;
c.c_x = 0;
c.c_y = 0;
c.c_r = 10;
Point p;
p.p_x = 10;
p.p_y = 10;
c.getRelation(p);
c.test(p);
cout << p.p_x << endl;
cout << &p << endl;
return 0;
}
- Circle.h
#pragma once
#include "Point.h"
class Circle
{
public:
int c_x;
int c_y;
int c_r;
void getRelation(Point p);
void test(Point& p);
};
- Circle.cpp
#include "Circle.h"
void Circle::getRelation(Point p)
{
double distance = sqrt(pow(p.p_x - c_x, 2) + pow(p.p_y - c_y, 2));
if (distance < c_r)
{
cout << "点在圆内" << endl;
return;
}
else if (distance == c_r) {
cout << "点在圆上" << endl;
}
else {
cout << "点在圆外" << endl;
}
}
void Circle::test(Point& p) {
p.p_x = 100;
}
87 构造函数和析构函数
#include<iostream>
using namespace std;
/*
对象的**初始化和清理**也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
c++利用了**构造函数**和**析构函数**解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此如果**我们不提供构造和析构，编译器会提供**
**编译器提供的构造函数和析构函数是空实现。**
* 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
* 析构函数：主要作用在于对象**销毁前**系统自动调用，执行一些清理工作。
构造函数 :
类名(){}
1. 没有返回值也不用写void
2. 函数名称与类名相同
3. 构造函数可以有参数,所以可以发生重载
4. 程序在调用对象的时候会自动调用构造,无需手动调用,而且只会调用一次
析构函数 :
~类型(){}
1. 析构函数没有返回值也不写void
2. 函数名称与类名相同,在名称前面加上符号~
3. 析构函数不可以有参数,因此不可以发生重载
4. 程序在对象销毁前会自动调用析构,无需手动调用,而且只会调用一次
*/
class Person
{
public:
//构造函数
Person() {
cout << "构造函数的调用" << endl;
}
//析构函数
~Person() {
cout << "析构函数调用" << endl;
}
};
void test01() {
Person p;//构造函数和析构函数自动调用
}
int main() {
//test01();
Person p;//代码走到这里,person不会执行析构函数,因为没有执行到return 0;
system("pause");
return 0;
}
88 *构造函数的分类和调用
#include<iostream>
using namespace std;
/*
构造函数的分类和调用
1. 两种分类方式
1. 按参数分 : 有参构造和无参构造
2. 按类型分 : 普通构造和拷贝构造
2. 三种调用方式
1. 括号法
2. 显示法
3. 隐式转换法
额外知识 : 匿名对象
*/
class Person
{
public:
int age;
public:
//无参构造函数,也叫做默认构造,因为如果用户没有写构造函数,那么编译器会自动帮助我们加上一个无参构造函数,并且实现为空
Person() {
cout << "Person的构造函数调用" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "Person的有参构造函数调用 a = " << a << endl;
}
//上面的两个构造函数也可以称之为普通构造函数
/*
拷贝构造函数,他的作用是将参数p赋值给当前的对象
加const是为了防止修改原p,比较我们是以p为样本,总不能复制完还把样本p修改了
加引用是为了节省地址空间
*/
Person(const Person& p) {
cout << "Person的拷贝构造函数调用" << endl;
age = p.age;
}
//析构函数
~Person() {
cout << "Person的析构函数调用" << age << endl;
}
};
//构造函数的调用
void test01()
{
//1. 括号法
Person p;//调用默认构造函数
Person p2(10);//调用有参构造函数
//拷贝构造函数
Person p3(p2);
/*
注意事项 :
1. 调用默认构造函数的时候,不要加小括号
Person p();
因为编译器将上面的代码视作函数的声明,不会创建对象
*/
cout << "p2.age = " << p2.age << endl; // 10
cout << "p3.age = " << p3.age << endl; // 10
cout << "-----------------------" << endl;
Person(30);//匿名对象,这一行结束就释放
/*
注意事项 :
不要利用拷贝构造函数来初始化一个匿名对象
Person(p3)
编译器会认为是
Person p3;所以会导致p3重定义
*/
//2. 显示法
Person p4;
Person p5 = Person(20); // 调用有参构造
//显示法调用拷贝构造
Person p6 = Person(p5);
cout << "-----------------------" << endl;
//3. 隐式转换法
Person p7 = 40; // 编译器会将该代码转换为 : Person p7 = Person(40);
Person p8 = p7; // 拷贝构造,编译器会将该代码转换为 : Person p8 = Person(p7)
}
int main() {
test01();
return 0;
}
89 拷贝构造函数的调用时机
#include<iostream>
using namespace std;
/*
拷贝构造函数的调用时机
c++中,拷贝构造函数的调用时机通常有三种情况
1. 使用一个已经创建完毕的对象来初始化一个新对象
2. 值传递的方式给函数传递值
3. 以值方式返回局部对象
*/
class Person
{
public:
int mAge;
public:
Person()
{
cout << "无参构造函数!" << endl;
mAge = 0;
}
Person(int age)
{
cout << "有参构造函数!" << endl;
mAge = age;
}
Person(const Person& p)
{
cout << "拷贝构造函数!" << endl;
mAge = p.mAge;
}
~Person()
{
cout << "析构函数" << endl;
}
};
//1. 使用一个已经构造完毕的对象来初始化一个对象
void test01()
{
Person p1 = Person(20);
Person p2 = Person(p1);//拷贝构造p2
cout << "p2.mAge = " << p2.mAge << endl; // 20
}
//2. 值传递的方式给函数参数传值
void doWork(Person w_p)
{
}
void test02()
{
Person p3;
doWork(p3);
/*
值传递其实就是构造函数隐式写法
相当于代码:
Person w_p = p3;
*/
}
//3. 值方式返回局部对象
Person doWork2()
{
Person p4;
cout << &p4 << endl;
return p4;
}
void test03()
{
Person p5 = doWork2();
cout << &p5 << endl;
}
int main() {
//test01();
//test02();
test03();
return 0;
}
90 **构造函数的调用规则
#include<iostream>
using namespace std;
/*
构造函数的调用规则
默认情况下,c++至少给一个类添加三个函数
1. 默认构造函数(无参,函数体为空)
2. 默认析构函数(无参,函数体为空)
3. 默认拷贝构造函数,对属性值进行拷贝
构造函数调用规则如下
1. 如果用户定义有参构造函数,c++不再默认提供无参构造,但是会提供默认拷贝构造
2. 如果用户定义拷贝构造函数,c++不会再提供其他构造函数
*/
class Person
{
public:
int mAge;
public:
Person()
{
cout << "无参构造函数!" << endl;
mAge = 0;
}
Person(int age)
{
cout << "有参构造函数!" << endl;
mAge = age;
}
/*Person(const Person& p)
{
cout << "拷贝构造函数!" << endl;
mAge = p.mAge;
}*/
~Person()
{
cout << "析构函数" << endl;
}
};
void test01()
{
Person p1(18);
Person p2(p1);
cout << "p2.age = " << p2.mAge << endl;
}
int main() {
test01();
return 0;
}
91 ***深拷贝和浅拷贝
#include<iostream>
using namespace std;
/*
深拷贝与浅拷贝是面试经常问到的,也是常见的一个坑
浅拷贝 : 简单的赋值拷贝操作
深拷贝 : 在堆区重新申请空间,进行拷贝操作
总结 : 如果数据有在堆区开辟的,一定要自己提供拷贝构造函数而不是依靠编译器默认实现,防止浅拷贝带来的问题
*/
class Person
{
public:
int m_age;
int* m_height;
public:
Person()
{
cout << "Person的默认无参构造函数调用" << endl;
}
Person(int age,int height)
{
m_age = age;
m_height = new int(height);//将height通过new创建在堆区,堆区的数据由程序员手动开辟,也由程序员手动关闭
cout << "Person的默认有参构造函数调用" << endl;
}
/*
这里,析构函数第一次有了真正的作用,就是在对象销毁前,关闭用户在堆区创建的有关数据
但是,这里的代码会出现错误 : 堆区的内容重复释放
因为我们的Person类有个int型指针变量height,那么由于p2 是基于p1的浅拷贝,所以p1指针和p2指针存储的是同一个
地址单元,那么在delete的时候就会出错,函数内由栈实现,所以是先进后出,p2先执行析构函数中的delete代码,对该
地址空间进行了delete,但是之后p1也会执行析构函数,对该地址空间进行delete,所以
一个空间进行多次delete操作就会报错
所以,浅拷贝的问题,要由深拷贝解决,自己写一个拷贝构造函数,解决浅拷贝带来的问题
我们拷贝的时候,再堆区重新申请一个地址空间,存储和p1的height一样的数值,那么这个时候,p1和p2指向不同的地址空间,
但是地址空间内的值是一样的
*/
~Person()
{
if (m_height != NULL)
{
delete(m_height);
m_height = NULL;
}
cout << "默认析构函数调用" << endl;
}
Person(const Person& p)
{
cout << "Person的拷贝构造函数调用" << endl;
m_age = p.m_age;
//m_height = p.m_height;//如果是默认拷贝构造函数,那么编译器会写的是这行代码,而这就是会出问题的
//接下来做深拷贝的操作
m_height = new int(*p.m_height);
//然后代码就可以正常实现了
}
};
void test01()
{
Person p1(18,160);
cout << "p1.age = " << p1.m_age << " || p1.height = " << *p1.m_height << endl;//18
Person p2(p1);
cout << "p2.age = " << p2.m_age << " || p2.height = " << *p2.m_height << endl;//18
p1.m_age = 20;
cout << "p1.age = " << p1.m_age << " || p1.height = " << *p1.m_height << endl;//20
cout << "p2.age = " << p2.m_age << " || p2.height = " << *p2.m_height << endl;//18
/*
这里不一样,是因为我们的Person没有提供默认拷贝构造函数,所以编译器会默认创建一个拷贝构造函数,这个构造函数
实现的是值拷贝
*/
}
int main() {
test01();
return 0;
}
92 初始化列表
#include<iostream>
using namespace std;
/*
初始化列表
作用 :
c++提供了初始化语法列表,原来初始化属性
语法 :
构造函数():属性名1(属性值1),属性名2(属性值2),属性名3(属性值3)..{}
*/
class Person
{
public:
int m_A;
int m_B;
int m_C;
public:
//传统的初始化操作
/*Person(int a, int b, int c)
{
m_A = a;
m_B = b;
m_C = c;
}*/
//初始化列表初始化属性
Person(int a, int b ,int c) :m_A(a), m_B(b), m_C(c)
{
}
};
void test01()
{
//Person p(10, 20, 30);
Person p(30,20,10);
cout << "a = " << p.m_A << endl;
cout << "b = " << p.m_B << endl;
cout << "c = " << p.m_C << endl;
}
int main() {
test01();
return 0;
}
93 类对象作为类成员
#include<iostream>
using namespace std;
/*
类对象作为类成员
两者构造函数和析构函数的调用顺序
1. 首先,先调用类对象的构造函数,然后调用本类的构造函数
2. 先调用本类的析构函数,然后调用类对象的析构函数
*/
class A
{
public:
int num1 = 10;
public:
A() {
cout << "A的无参构造函数" << endl;
}
~A() {
cout << "A的析构函数" << endl;
}
};
class B
{
public:
A a;
public:
B() {
cout << "B的无参构造函数" << endl;
}
~B() {
cout << "B的析构函数" << endl;
}
};
int main() {
B b;
cout << b.a.num1 << endl;
return 0;
}
94 静态成员变量
#include<iostream>
using namespace std;
/*
静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员
静态成员分为
1. 静态成员变量
1. 所有对象共享同一份数据,整个内存就这么一份数据
2. 在编译阶段分配内存,不是创建对象的时候分配,分配的内存位于全局区
3. 类内声明,类外初始化
2. 静态成员函数
1. 所有对象共享同一个函数
2. 静态成员函数只可以访问静态成员变量
*/
class Person
{
public:
//所有对象都共享同一份数据
static int m_a;//类内声明
/*
静态成员变量,也是有访问权限的
*/
private:
static int m_b;
};
int Person::m_a = 100;//类外初始化,如果不写Person::,编译器会认为这是一个全局变量,而不是静态变量
int Person::m_b = 200;
void test01()
{
Person p;
cout << p.m_a << endl;//100
Person p2;
p2.m_a = 200;
cout << p.m_a << endl;//200
cout << p2.m_a << endl;//200
}
void test02()
{
//静态成员变量,不属于某一个对象,所以所有对象共享同一份数据
//因此,静态成员变量有两种访问方式
//1. 通过对象进行访问
Person p3;
cout << p3.m_a << endl;//100
//2. 通过类名进行访问
cout << Person::m_a << endl;//100
//cout << Person::m_b << endl;//报错,显示不可访问
}
int main() {
//test01();
test02();
return 0;
}
95 静态成员函数
#include<iostream>
using namespace std;
/*
静态成员函数
1. 所有对象共享同一个函数
2. 静态成员函数只可以访问静态成员变量
因为静态成员属性的创建比成员属性的早,你要访问一个还没有开辟空间的数据,肯定是不可以的
*/
class Person
{
public:
int m_a = 100;//非静态成员变量
static int m_b;//静态成员变量
public:
//静态成员函数,并且静态成员函数也是有访问权限的,也可以设置权限为public,private和protected
static void func()
{
//cout << "m_a = " << m_a;//报错,静态成员函数只可以访问静态成员变量
cout << "m_b = " << m_b << endl;//可以运行,因为m_b是静态成员变量
cout << "static void func调用" << endl;
}
};
int Person::m_b = 200;//类外初始化
void test01()
{
//1. 通过对象访问
Person p;
p.func();
//2. 通过类名访问
Person::func();
}
int main() {
test01();
return 0;
}
96 成员函数和成员变量分开存储
#include<iostream>
using namespace std;
/*
在c++中,类内的成员变量和成员函数分开存储
只有非静态变量才属于类的对象上
*/
class Person
{
//public:
//非静态成员变量占据对象的空间
int m_A;
//静态成员变量不占对象空间
static int m_B;
//非静态成员函数
void func() {};
//静态成员变量
static void func2() {};
//public:
// Person()
// {
// m_A = 0;
// }
};
int Person::m_B = 100;
void test01()
{
Person p;
//空对象占用的内存空间为 1
/*
因为c++编译器会给每个空对象分配一个字节的空间,是为了区分空对象占内存的位置,因为如果不分配空间,那么如果有多个
空对象,编译器就无法区分他们了,至于为什么分配1个字节,肯定是分配越少越好,毕竟只是为了区分,没必要分配太多空间
*/
//接下来,如果类有一个成员变量 int m_A;则占用的空间为4
//接下来,类再加上一个静态成员变量static int m_B;则占用空间还是4,因为静态成员不属于对象,不占用对象的空间
/*
接下来, 再加上一个函数, 占用的空间还是4, 因为成员变量和成员函数是分开存储的, 也不属于类的对象上,并且, 其实非
静态成员函数也是只有一个,这方面的内容97讲
*/
cout << "size of p = " << sizeof(p) << endl;// 1
}
int main() {
test01();
return 0;
}
97 this指针
#include<iostream>
using namespace std;
/*
this指针
通过96的代码,我们可以直到成员变量和成员函数是分开存储的,每一个非静态成员函数只会诞生一份函数实例,也就是说,多个类型
的对象会共用一块代码
那么问题是 : 这一块代码是如何区分是类的哪个对象调用自己的呢?
c++通过提供特殊含义的指针 : this指针,解决上述问题,this指针指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针
this指针无需定义,直接使用即可
this指针的用途:
1. 当形参和成员变量同名的时候,可以用this指针来区分
2. 在类的非静态成员函数中返回对象本身,可以使用return *this;
this指针的本质是一个常指针,指针的指向是不可以修改的
*/
class Person
{
public:
int age;
public:
Person(int age)
{
this->age = age;
}
Person& addAge(Person p)
{
this->age += p.age;
//this指向p2的指针,而*this指向的就是p2对象本体
return *this;
}
};
//方式命名冲突
void test01()
{
Person p1(18);
cout << "age = " << p1.age << endl;
}
//返回对象本身
void test02()
{
Person p1(10);
Person p2(20);
p2.addAge(p1).addAge(p1).addAge(p1).addAge(p1);
/*
在这里,如果addAge返回值是Person,那么cout输出为30,因为返回的Person是一个新的对象,只不过新的对象值和p2一样是
30,每次addAge返回的都是一个新对象,如果我们用Person p3接收上面链式编程的返回值,那么p3.age = 60
但是如果输出p2.age,由于p2.age只执行了链式编译的第一个addAge,之后的addAge都是新Person执行的,所以cout输出
为30
如果返回的是Person&,那么相当于 Person& p3 = p2.addAge;那么p3其实指向的就是p2,那么之后继续执行addAge,返回的
都是p2的引用,修改的自然也就是p2的age,所以cout输出为60
*/
cout << "p2.age = " << p2.age << endl;
}
int main() {
//test01();
test02();
return 0;
}
98 空指针访问成员函数
#include<iostream>
using namespace std;
/*
空指针访问成员函数
c++中,空指针也是可以调用成员函数的,但是也要注意有没有用到this指针
如果用到this指针,需要加以判断,以保持代码的健壮性
*/
class Person
{
public:
int m_Age = 10;
public:
void showClassNama()
{
cout << "this is person class " << endl;
}
void showPersonAge()
{
//cout << "age = " << m_Age << endl; // 访问异常,在c++中,我们会默认的在m_Age前面加上this,而this是nullper
if (!this)//这样子可以提高代码的健壮性
{
cout << "传入的指针为空" << endl;
return;
}
cout << "age = " << this->m_Age << endl;
}
};
void test01()
{
Person* p = new Person();
p->m_Age = 19;
p->showClassNama();
p->showPersonAge();
}
int main() {
test01();
return 0;
}
99 **const修饰成员函数&mutable
#include<iostream>
using namespace std;
/*
const修饰成员函数
1. 常函数
1. 成员函数后加const我们称这个函数为常函数
2. 常函数内不可以修改成员属性
3. 成员属性声明时加关键字mutable,在常函数中依然可以修改
2. 常对象
1. 声明对象前加const称该对象为常对象
2. 常对象只可以调用常函数
*/
class Person
{
public:
void showPerson() const
{
//m_A = 100; //报错 : 表达式必须是可修改的左值
m_B = 100; //当成员属性声明的时候加上关键字mutable,就可以在常函数中修改,也可以被常对象修改
}
void func()
{
}
public:
mutable int m_B;
int m_A;
};
void test01()
{
Person p;
p.showPerson();
}
void test02()
{
const Person p; //在对象前加const,变为常对象
//p.m_A = 100; //报错,常对象只可以调用常函数和mutable成员属性
p.m_B = 100;
p.showPerson();
//p.func(); //报错,常对象只可以调用常函数,因为普通成员函数可以修改属性,所以矛盾
}
int main() {
return 0;
}
100 全局函数做友元
#include<iostream>
using namespace std;
/*
友元 :
在程序里,有些 私有属性,也希望让类外特殊的一些函数或者类进行访问,就需要用到友元的技术
友元的目的就是让一个函数或者类 访问另一个类中的私有成员
友元的关键字为 : friend
友元的三种实现 :
1. 全局函数做友元
2. 类做友元
3. 成员函数做友元
*/
class Building
{
friend void goodGay(Building& b);//现在,goodGay函数就可以访问Building类的私有成员
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom; //卧室
};
//全局函数
void goodGay(Building& b)
{
cout << "好基友的全局函数 正在访问 : " << b.m_SittingRoom << endl;
cout << "好基友的全局函数 正在访问 : " << b.m_BedRoom << endl;
}
void test01()
{
Building b;
goodGay(b);
}
int main() {
test01();
return 0;
}
101 类做友元
#include<iostream>
using namespace std;
/*
类做友元
*/
class Building;
class GoodGay
{
public:
void visit();//参观,访问build中的属性,不可以访问私有属性
void visit2();//参观,访问build中的属性,可以访问私有属性
public:
GoodGay();
public:
Building* b;//这里不可以是Building& b 因为引用必须初始化
};
class Building
{
//friend class GoodGay;
friend void GoodGay::visit2();
public:
Building();
public:
string m_SettingRoom;//客厅
private:
string m_BedRoom;//卧室
};
//类外写成员函数
Building::Building() {
m_SettingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
b = new Building();
}
void GoodGay::visit()
{
cout << "好基友正在访问 : " << b->m_SettingRoom << endl;
}
void GoodGay::visit2()
{
cout << "好基友正在访问 : " << b->m_SettingRoom << endl;
cout << "好基友正在访问 : " << b->m_BedRoom << endl;
}
void test01()
{
GoodGay g;
g.visit();
}
void test02()
{
GoodGay g;
g.visit2();
}
int main() {
//test01();
test02();
return 0;
}
102 +运算符重载
#include<iostream>
using namespace std;
/*
运算符重载 : 对已经有的运算符重新进行定义,赋予其另外一种功能,以适应不同的数据类型
注意:
1. 对于内置的数据类型的表达式的运算符是不可能改变的 比如通过运算符重载实现int 1 + int 2 = 100;是不可能的
2. 不要滥用运算符重载
*/
class Person
{
public:
int m_A;
int m_B;
Person() {
}
Person(int a, int b) {
m_A = a;
m_B = b;
}
//成员函数实现 + 号运算符重载
Person operator+(const Person& p) {
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
};
//全局函数做运算符重载
Person operator+(Person& p1, Person& p2)
{
Person temp;
temp.m_A = p1.m_A + p2.m_A;
temp.m_B = p1.m_B + p2.m_B;
return temp;
}
//运算符重载的函数也可以进行函数重载
Person operator+(Person& p1, int num)
{
Person temp;
temp.m_A = p1.m_A + num;
temp.m_B = p1.m_B + num;
return temp;
}
void test01()
{
Person p1(10, 20);
Person p2(20, 30);
/*
本质是
Person p3 = p1.operator+(p2)
*/
Person p3 = p1 + p2;
cout << "p3.a = " << p3.m_A << endl;
cout << "p3.b = " << p3.m_B << endl;
}
void test02()
{
Person p1(10, 20);
Person p2(20, 30);
/*
本质是
Person p3 = operator+(p1 , p2)
*/
Person p3 = p1 + p2;//简化后
cout << "p3.a = " << p3.m_A << endl;
cout << "p3.b = " << p3.m_B << endl;
//调用重载的函数
Person p4 = p1 + 100;
cout << "p4.a = " << p4.m_A << endl;
cout << "p4.b = " << p4.m_B << endl;
}
int main() {
//test01();
test02();
return 0;
}
103 左移运算符重载
#include<iostream>
using namespace std;
/*
左移<<运算符重载
*/
class Person
{
friend ostream& operator<<(ostream& cout, Person& p);
public:
Person(int a, int b)
{
m_A = a;
m_B = b;
}
private:
int m_A;
int m_B;
//利用成员函数重载左移运算符
/*
我们一般不适用成员函数重载左移运算符,不是不可以,而是无法达到需要的cout << p样式
*/
/*void operator<<(Person& p)
{
}
*/
};
//全局函数重载,本质就是cout << p
ostream& operator<<(ostream& cout, Person& p)
{
cout << "m_A = " << p.m_A << endl;
cout << "m_B = " << p.m_B << endl;
return cout;
}
void test01()
{
Person p(10,10);
//cout << p << endl;//报错 : 没有与这些操作数匹配的左移运算符,无法链式编程,所以返回对象类型必须是ostream
cout << p << endl << "helloworld" << endl;
}
int main() {
test01();
return 0;
}
104 递增运算符重载
#include<iostream>
using namespace std;
/*
递增运算符重载 ++
作用 : 通过重载递增运算符,实现自己的整型数据
*/
//自定义整型
class MyInteger
{
friend ostream& operator<<(ostream& cout, const MyInteger& myint);//友元
private:
int m_Num;
public:
MyInteger()
{
m_Num = 0;
}
//重载后置++运算符
/*
这里注意,和重载前置不同,这里我们的返回值是MyInteger而不是MyInteger&,因为如果这里我们返回MyInteger&,就导致
我们返回了一个局部对象的引用,局部对象在当前函数执行完之后就销毁了,所以后面的操作都是违法操作
*/
MyInteger operator++(int)
{
MyInteger temp = *this;
this->m_Num++;
return temp;
}
//重载前置++运算符
MyInteger& operator++()
{
m_Num++;
return *this;
}
};
//返回类型是ostream&,是为了可以实现链式编程
ostream& operator<<(ostream& cout, const MyInteger& myint)
{
cout << myint.m_Num << endl;
return cout;
};
void test01()
{
MyInteger myint;
cout << ++++myint << endl;
}
void test02() {
MyInteger myint;
cout << myint++ << endl;
cout << myint << endl;
}
int main() {
//test01();
test02();
return 0;
}
105 *赋值运算符重载
#include<iostream>
using namespace std;
/*
赋值运算符重载
c++编译器至少给一个类添加4个函数
1. 默认构造函数(无参，函数体为空)
2. 默认析构函数(无参，函数体为空)
3. 默认拷贝构造函数，对属性进行值拷贝
4. 赋值运算符 operator=, 对属性进行值拷贝(因为是值拷贝,所以如果有属性创建在堆区,就会引发深浅拷贝的问题)
*/
class Person
{
public:
int* m_A;
public:
Person(int age)
{
m_A = new int(age);
}
~Person()
{
if (m_A!=NULL)
{
delete(m_A);
m_A = NULL;
}
}
//重载赋值运算符
Person& operator=(const Person& p)
{
//编译器提供的是浅拷贝
//我们应该提供的是深拷贝
if (m_A != NULL)
{
delete(m_A);
m_A = NULL;
}
m_A = new int(*p.m_A);
return *this;
}
};
void test01()
{
Person p1(18);
Person p2(20);
Person p3(30);
cout << "p1.age = " << *p1.m_A << endl;//18
cout << "p2.age = " << *p2.m_A << endl;//20
p3 = p2 = p1;
cout << "p1.age = " << *p1.m_A << endl;//18
cout << "p2.age = " << *p2.m_A << endl;//18
cout << "p3.age = " << *p3.m_A << endl;//18
}
int main() {
test01();
return 0;
}
106 关系运算符重载
#include<iostream>
using namespace std;
/*
关系运算符重载
作用 : 重载关系运算符,可以让两个自定义类型对象进行对比操作
*/
class Person
{
public:
int age;
public:
Person(int age) {
this->age = age;
}
bool operator==(const Person& p) {
if (this->age == p.age)
{
return true;
}
else {
return false;
}
}
bool operator!=(const Person& p) {
if (this->age != p.age)
{
return true;
}
else {
return false;
}
}
};
void test01()
{
Person p1(18);
Person p2(19);
cout << "p1 == p2 ? " << (p1 == p2) << endl;
cout << "p1 != p2 ? " << (p1 != p2) << endl;
}
int main() {
test01();
return 0;
}
107 函数调用运算符重载
#include<iostream>
using namespace std;
/*
函数调用运算符重载
1. 函数调用运算符()也可以重载
2. 由于重载后的使用方式非常像函数的调用,因此称之为仿函数
3. 仿函数没有固定的写法,非常灵活
*/
//打印输出类
class MyPrint
{
public:
//重载的函数调用运算符
void operator()(string test) {
cout << test << endl;
}
};
//加法类
class MyAdd {
public:
int operator()(int num1, int num2) {
return num1 + num2;
}
};
void test01() {
MyPrint mp;
mp("何佳乐");//使用起来非常类似于函数调用,因此称之为函数调用
//mp.operator()("何佳乐");
}
void test02() {
MyAdd ma;
cout << ma(100, 100) << endl;
//匿名函数对象 MyAdd()(100, 100),匿名对象执行完当前行就销毁
cout << MyAdd()(100, 100) << endl;
}
int main() {
//test01();
test02();
return 0;
}
108 继承
#include<iostream>
using namespace std;
/*
继承是面向对象的三大特性之一
*/
class BasePage {
public:
void header() {
cout << "首页 公开课 登录 注册" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java,Python,C++...(公共分类列表)" << endl;
}
};
class JAVA :public BasePage {
public:
void content() {
cout << "this is a java page" << endl;
}
};
class CPP :public BasePage {
public:
void content() {
cout << "this is a c++ page" << endl;
}
};
void test01()
{
CPP cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.content();
JAVA java;
java.header();
java.footer();
java.left();
java.content();
}
int main() {
test01();
return 0;
}
109 **继承方式
#include<iostream>
using namespace std;
/*
继承方式
1. 公共继承,公共依然公共,保护依然保护,私有无法访问
2. 保护继承,公共变成保护,保护依然保护,私有无法访问
3. 私有继承,公共变成私有,保护变成私有,私有无法访问
*/
class Person
{
public:
int num1 = 1;
protected:
int num2 = 2;
private:
int num3 = 3;
};
class Person1: public Person
{
//public:
// void show() {
// cout << "num1 = " << num1 << endl;
// cout << "num2 = " << num2 << endl;
// //cout << "num3 = " << num3 << endl;
// }
public:
Person1() {
Person p;
num2 = 3;
cout << "num2 = " << num2 << endl;//子类成员函数可以访问父类的受保护内容
//p.num2 = 4;// 错误:p不是this指针所指的对象,所以不能访问其保护成员
}
};
class Person2 :protected Person
{
};
class Person3 :private Person
{
};
void test01()
{
Person1 p1;
cout << p1.num1 << endl;
//cout << p1.num2 << endl; //错误 : 不在派生类成员函数内，不能访问基类保护成员
Person2 p2;
//cout << p2.num1 << endl;
}
int main() {
test01();
return 0;
}
110 **继承中的对象模型
#include<iostream>
using namespace std;
/*
继承中的对象模型
问题 : 从父类继承过来的成员,哪些属于子类对象
首先,c++中,成员变量和成员函数分开存储,并且只有非静态变量才属于类的对象
父类中,所有非静态成员属性都会被子类继承下去,不论该成员属性能否被访问到
接下来,我们可以利用vs提供的工具,查看Son类的布局
1. 找到vs文件夹,或者在开始菜单中找到vs文件夹
2. 打开Developer Command Prompt for VS 2019
3. cd 进入到项目所在的文件夹
4. 输入 cl /d1 reportSingleClassLayout类的名称 "42 继承中的对象模型.cpp"
例如 : cl /d1 reportSingleClassLayoutSon "42 继承中的对象模型.cpp" 就可以查看son的类结构
class Son size(16):
+---
0 | +--- (base class Base)
0 | | m_A
4 | | m_B
8 | | m_C
| +---
12 | m_D
+---
*/
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son :public Base {
public:
int m_D;
};
void test01()
{
Son son;
cout << "sizeof(son) = " << sizeof(son) << endl; // 16
}
int main() {
test01();
return 0;
}
111 继承中构造和析构的顺序
#include<iostream>
using namespace std;
/*
继承中,构造和析构的顺序
子类继承父类后,当创建子类对象,也会调用父类的构造函数
问 : 父类和子类的构造和析构顺序是谁先谁后
答 : 先构造父类,再构造子类,先析构子类,再析构父类
*/
class Base
{
public:
Base() {
cout << "父类的构造函数调用" << endl;
}
~Base() {
cout << "父类的析构函数调用" << endl;
}
};
class Son :public Base
{
public:
Son() {
cout << "子类的构造函数调用" << endl;
}
~Son() {
cout << "子类的析构函数调用" << endl;
}
};
void test01() {
Son son;
/*
父类的构造函数调用
子类的构造函数调用
子类的析构函数调用
父类的析构函数调用
*/
}
int main() {
test01();
return 0;
}
112 继承时同名成员的处理方式
#include<iostream>
using namespace std;
/*
继承中,同名成员的处理方式
问 : 当子类与父类出现同名的成员,如何通过子类对象,访问到子类或父类中同名的数据呢?
答 :
1. 访问子类同名成员,直接访问即可
2. 访问父类同名成员,需要加作用域
总结：
1. 子类对象可以直接访问到子类中同名成员
2. 子类对象加作用域可以访问到父类同名成员
3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
*/
class Base {
public:
int num1 = 1;
void func() {
cout << "base-func调用" << endl;
}
void func(int a) {
cout << "base-func(int a)调用" << endl;
}
};
class Son :public Base {
public:
int num1 = 2;
void func() {
cout << "son-func调用" << endl;
}
};
void test01()
{
Son son;
cout << "son子类的num1 = " << son.num1 << endl;
cout << "父类的num1 = " << son.Base::num1 << endl;
}
void test02() {
Son son;
son.func();
son.Base::func();
son.Base::func(10);
}
int main() {
//test01();
test02();
return 0;
}
113 继承时同名静态成员的处理方式
#include<iostream>
using namespace std;
/*
继承同名静态成员的处理方式
问 : 继承中同名的静态成员在子类对象上如何进行访问
静态成员和非静态成员出现同名,处理方式一致
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
*/
class Base
{
public :
static void func() {
cout << "Base static void func() " << endl;
}
static void func(int a) {
cout << "Base static void func(int a) " << endl;
}
static int m_A;
};
int Base::m_A = 100;
class Son :public Base {
public:
static void func() {
cout << "Son static void func()" << endl;
}
static int m_A;
};
int Son::m_A = 200;
void test01()
{
Son son;
cout << "son.m_A = " << son.m_A << endl;
cout << "son.Base::m_A = " << son.Base::m_A << endl;
cout << "-----------------" << endl;
son.func();
son.Base::func();
son.Base::func(10);
}
void test02() {
cout << Son::m_A << endl;
cout << Son::Base::m_A << endl;
Son::func();
Son::Base::func();
Son::Base::func(20);
}
int main() {
//test01();
test02();
return 0;
}
114 多继承语法
#include<iostream>
using namespace std;
/*
多继承语法
c++允许一个类继承多个类
1. 语法 : class 子类 : 继承方式 父类1,继承方式 父类2 ,...,继承方式 父类n
2. 注意 : 多继承可能引发父类中同名成员出现,需要加作用域区分
c++实际开发中,不建议使用多继承
*/
class Base1 {
public:
int m_A = 100;
int a = 2;
};
class Base2 {
public:
int b = 3;
int m_A = 200;
};
class Base3 {
public:
int c = 4;
int m_A = 300;
};
class Son :public Base1, public Base2, public Base3 {
public:
int d = 5;
int m_A = 400;
};
void test01() {
Son son;
cout << son.m_A << endl;//400
cout << son.Base1::m_A << endl;//100
cout << son.Base2::m_A << endl;//200
cout << son.Base3::m_A << endl;//300
cout << sizeof(son) << endl;
}
int main() {
test01();
return 0;
}
115 菱形继承
#include<iostream>
using namespace std;
/*
菱形继承
**菱形继承概念：**
两个派生类继承同一个基类
又有某个类同时继承者两个派生类
这种继承被称为菱形继承，或者钻石继承
**菱形继承问题：**
1. 羊继承了动物的数据，驼同样继承了动物的数据，当*使用数据时，就会产生二义性。
2. *继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。
*/
class Animal {
public:
int age;
};
/*
利用虚继承,可以解决菱形继承的问题
Animal就称之为 虚基类
*/
//羊类
class Sheep :virtual public Animal {
};
//驼类
class Camal :virtual public Animal {
};
//羊驼
class CNM :public Sheep, public Camal {
};
void test01() {
CNM cnm;
cnm.Sheep::age = 18;//报错 : CNM::age 不明确,就是有二义性
cnm.Camal::age = 20;//报错 : CNM::age 不明确,就是有二义性
cout << "cnm.Sheep::age = " << cnm.Sheep::age << endl;
cout << "cnm.Camal::age = " << cnm.Camal::age << endl;
cout << "cnm.size is " << sizeof(cnm) << endl; // 8,继承了来自sheep和camal的age各一份,所以是8
//但是其实我们有一份就可以了,菱形继承导致这个数据有两份,导致了浪费
/*
解决后观察对象模型
class CNM size(12):
+---
0 | +--- (base class Sheep)
0 | | {vbptr}
| +---
4 | +--- (base class Camal)
4 | | {vbptr}
| +---
+---
+--- (virtual base Animal)
8 | age
+---
CNM::[email protected]@:
0 | 0
1 | 8 (CNMd(Sheep+0)Animal)
CNM::[email protected]@:
0 | 0
1 | 4 (CNMd(Camal+0)Animal)
vbi: class offset o.vbptr o.vbte fVtorDisp
Animal 8 0 4 0
解读 :
1. {vbptr}代表虚基类指针 v->virtual b->base基类 ptr->pointer
该指针指向virtual base table 虚基类表,虚基类表中记录一个偏移量
*/
}
int main() {
test01();
return 0;
}
116 多态
#include<iostream>
using namespace std;
/*
多态
1. 多态分为两类:
1. 静态多态 : 函数重载和运算符重载属于静态多态,复用函数名
2. 动态多态 : 派生类和虚函数实现运行时多态
2. 静态多态和多态多态的区别
1. 静态多态的函数地址早绑定 - 编译阶段确定函数地址
2. 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
总结：
多态满足条件
* 有继承关系
* 子类重写父类中的虚函数
多态使用条件
* 父类指针或引用指向子类对象
重写：函数返回值类型 函数名 参数列表 完全一致称为重写
*/
class Animal {
public:
//虚函数 :
virtual void speak() {
cout << "动物在说话" << endl;
}
};
class Cat:public Animal {
public:
void speak() {
cout << "小猫在说话" << endl;
}
};
class Dog :public Animal {
public:
void speak() {
cout << "小狗在说话" << endl;
}
};
class A {
public:
int num1 = 10;
int* p = &num1;
};
class B:public A {
};
//地址早绑定,在编译阶段就确定了函数的地址,如果想让猫说话,那么这个函数的地址就不可以早绑定,需要进行动态多态
void doSpeak(Animal& animal) {//Animal& animal = cat;父类引用指向子类对象
animal.speak();
}
void test01() {
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
void test02() {
cout << sizeof(Animal) << endl; // 4,vfptr虚函数指针 f->function
}
void test03() {
int num1 = 10;
int* p1 = &num1;
int* p2 = p1;
cout << (int)p1 << endl;
cout << (int)p2 << endl;
}
void test04() {
A a;
B b;
cout << (int)(a.p) << endl;
cout << *(a.p) << endl;
cout << (int)(b.p) << endl;
cout << *b.p << endl;
}
int main() {
//test01();
//test02();
//test03();
test04();
return 0;
}
117 案例 : 多态计算器
#include<iostream>
using namespace std;
/*
多态案例 计算器类
案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
多态的优点：
* 代码组织结构清晰
* 可读性强
* 利于前期和后期的扩展以及维护
*/
//普通写法,如果要添加别的计算方式,比如取余之类的,就必须修改源码
class calculator {
public:
int num1;
int num2;
int getResult(string oper) {
if (oper == "+")
{
return num1 + num2;
}
else if (oper == "-")
{
return num1 - num2;
}
else if (oper == "-")
{
return num1 * num2;
}
else if (oper == "/" && num2 !=0)
{
return num1 / num2;
}
else {
cout << "请输入正确的运算符" << endl;
return -1;
}
}
};
class AbstractCalculator {
public:
int num1;
int num2;
virtual int getResult() {
return 0;
}
};
class AddCalculator :public AbstractCalculator{
int getResult() {
return num1 + num2;
}
};
class SubCalculator :public AbstractCalculator {
int getResult() {
return num1 - num2;
}
};
class MulCalculator :public AbstractCalculator {
int getResult() {
return num1 * num2;
}
};
void test01() {
calculator calculator;
calculator.num1 = 10;
calculator.num2 = 11;
cout << "num1 + num2 = " << calculator.getResult("+") << endl;
}
void test02() {
AbstractCalculator* ac = new AddCalculator;
ac->num1 = 10;
ac->num2 = 20;
cout << ac->getResult() << endl;
delete(ac);
AbstractCalculator* ac2 = new SubCalculator;
ac2->num1 = 10;
ac2->num2 = 20;
cout << ac2->getResult() << endl;
delete(ac2);
}
int main() {
//test01();
test02();
return 0;
}
118 纯虚函数和抽象类
#include<iostream>
using namespace std;
/*
纯虚函数和抽象类
在多态中,通常父类当中的虚函数的实现是毫无意义的,主要都是调用子类重复书写的内容
因此,可以将虚函数改为纯虚函数
纯虚函数语法 : virtual 返回值类型 函数名 (参数列表) = 0
当类有了纯虚函数,这个类也称之为抽象类
抽象类特点 :
1. 无法实例化对象
2. 子类必须重写抽象类中的纯虚函数,否则也属于抽象类
*/
class Base {
public:
virtual void func() = 0;
};
class Son :public Base {
public:
virtual void func() {
cout << "son-func() 调用" << endl;
}
};
void test01() {
//Son son;//报错,son没有重写Base中的纯虚函数
Son son;
son.func();
//Base base;//报错 : 因为有Base有纯虚函数,所以Base是抽象类,抽象类不允许实例化对象
Base* base = new Son;
base->func();
}
int main() {
test01();
return 0;
}
119 案例 : 制作饮品
#include<iostream>
using namespace std;
/*
多态案例1 : 制作饮品
案例描述 :
制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶
*/
class Drink {
public:
virtual void Boil() = 0;
virtual void Brew() = 0;
virtual void PourInCup() = 0;
virtual void PutSomething() = 0;
void MakeDrink() {
Boil();
Brew();
PourInCup();
PutSomething();
}
~Drink() {
cout << "Drink的析构函数" << endl;
}
};
class Tea: public Drink {
public:
virtual void Boil() {
cout << "煮山泉水" << endl;
}
virtual void Brew() {
cout << "冲洗两遍" << endl;
}
virtual void PourInCup() {
cout << "倒入茶杯" << endl;
}
virtual void PutSomething() {
cout << "加入茶叶" << endl;
}
~Tea() {
cout << "tea的析构函数" << endl;
}
};
class Coffee :public Drink {
public:
virtual void Boil() {
cout << "煮地下水" << endl;
}
virtual void Brew() {
cout << "冲洗" << endl;
}
virtual void PourInCup() {
cout << "倒入咖啡杯" << endl;
}
virtual void PutSomething() {
cout << "加入咖啡豆" << endl;
}
};
void doWork(Drink& drink) {
drink.MakeDrink();
}
void test01() {
Drink* tea = new Tea;
tea->MakeDrink();
delete(tea);
/*Drink* coffee = new Coffee;
coffee->MakeDrink();
delete(coffee);*/
}
void test02() {
Tea tea;
doWork(tea);
}
int main() {
test01();
//test02();
return 0;
}
120 虚析构和纯虚析构
#include<iostream>
using namespace std;
/*
虚析构和纯虚析构 :
多态使用的时候,如果子类中有属性开辟到堆区,那么父类指针在释放的时候无法调用到子类的析构代码,子类当中的堆区元素
就无法释放
解决方式 :
将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性 :
1. 可以解决父类指针释放子类对象
2. 都需要有具体的函数实现
区别 :
1. 如果该类中有纯虚析构,则该类属于抽象类,无法实例化对象
总结：
1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类
*/
class Animal {
public:
virtual void speak() = 0;
Animal() {
cout << "Animal的构造函数调用" << endl;
}
//利用虚析构,可以解决父类指针无法调用子类析构函数的问题
/*virtual ~Animal() {
cout << "Animal的析构函数调用" << endl;
}*/
//纯虚析构也可以解决上述的问题,这里是纯虚析构的声明,注意,有了纯虚析构函数的类,是抽象类,无法实例化对象
virtual ~Animal() = 0;
};
//纯虚析构的定义
Animal::~Animal() {
cout << "Animal纯虚析构函数的调用" << endl;
}
class Cat :public Animal {
public:
string* m_Name;//堆区
Cat(string name) {
cout << "CAT构造函数调用" << endl;
m_Name = new string(name);
}
virtual void speak() {
cout << *m_Name << "小猫在说话" << endl;
}
~Cat() {
if (m_Name != NULL)
{
cout << "cat析构函数调用" << endl;
delete(m_Name);
m_Name = NULL;
}
}
};
void test01() {
Animal* cat = new Cat("何佳乐");
cat->speak();
//父类指针在析构的时候,不会调用子类的析构函数,导致如果子类有堆区属性,会出现内存的泄露
delete(cat);
}
int main() {
test01();
return 0;
}
121 文本文件-写文件
#include<iostream>
#include<fstream>
using namespace std;
/*
1. 文件操作:
概述:
程序运行时产生的数据都属于临时数据,程序一旦运行结束都会被释放
通过文件可以将数据持久化
c++中对文件操作需要包含头文件<fstream>
文件类型分两种:
1. 文本文件,文件以文本的ASC2码形式存储在计算机中
2. 二进制文件,文件以文本的二进制形式存储在计算机中,用户不能直接读懂
操作文件的三大类
1. ofstream : 写操作
2. ifstream : 读操作
3. fstream : 读写操作
2. 文本文件(写)
步骤 :
1. 包含头文件
\#include <fstream\>
2. 创建流对象
ofstream ofs;
3. 打开文件
ofs.open("文件路径",打开方式);
4. 写数据
ofs << "写入的数据";
5. 关闭文件
ofs.close();
文件打开方式
ios::in为读文件而打开文件
ios::out为写文件而打开文件
ios::ate初始位置：文件尾
ios::app追加方式写文件
ios::trunc如果文件存在先删除，再创建
ios::binary二进制方式
*/
void test01() {
//1. 包含头文件
//2. 创建流对象
ofstream ofs;
//3. 指定打开的方式
ofs.open("test.txt", ios::out);
//4. 写内容
ofs << "姓名:张三" << endl << "年龄:18" << endl << "性别:男" ;
//5. 关闭文件
ofs.close();
}
int main() {
test01();
return 0;
}
122 文本文件-读文件
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
/*
文本文件 读文件
读文件步骤如下：
1. 包含头文件
\#include <fstream\>
2. 创建流对象
ifstream ifs;
3. 打开文件并判断文件是否打开成功
ifs.open("文件路径",打开方式);
4. 读数据
四种方式读取
5. 关闭文件
ifs.close();
*/
void test01() {
//1. 包含头文件
//2. 创建流对象
ifstream ifs;
//3. 打开文件,并且判断是否打开成功
ifs.open("test.txt", ios::in);
if (!ifs.is_open()) {
cout << "打开文件失败" << endl;
return;
}
//4. 读数据
//第一种
/*char buf[1024] = { 0 };
while (ifs >> buf) {
cout << buf << endl;
}*/
//第二种
/*char buf[1024] = { 0 };
while (ifs.getline(buf, sizeof(buf)))
{
cout << buf << endl;
}*/
//第三种
/*string buf;
while (getline(ifs, buf)) {
cout << buf << endl;
}*/
//第四种
char c;
while ((c = ifs.get()) != EOF) {//EOF end of file 文件末尾标志
cout << c;
}
//5. 关闭
ifs.close();
}
int main() {
test01();
return 0;
}
123 二进制文件-写文件
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
/*
二进制文件 读文件
以二进制的方式对文件进行读写操作
打开方式指定为 ios::binary
写文件
概述 :
二进制方式写文件主要利用流对象调用成员函数write
函数原型 :
ostream& write(const char* buffer,int len);
参数解释
1. 字符指针buffer指向内存中的一段存储空间
2. len是读写的字节数
*/
class Person {
public:
char m_Name[6];
int m_Age;
};
void test01() {
//1. 包含头文件
//2. 创建流文件
ofstream ofs;
//3. 打开文件
ofs.open("person.txt", ios::out | ios::binary);
//4. 写文件
Person p = { "好人" , 18 };
ofs.write((const char*)&p, sizeof(Person));
//5. 关闭
ofs.close();
}
int main() {
test01();
return 0;
}
124 二进制文件-读文件
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
/*
二进制文件 读文件
二进制方式读文件主要利用流对象调用成员函数read
函数原型：
istream& read(char *buffer,int len);
参数解释：
字符指针buffer指向内存中一段存储空间。len是读写的字节数
*/
class Person {
public:
char m_Name[6];
int m_Age;
};
void test01() {
ifstream ifs;
ifs.open("person.txt", ios::in | ios::binary);
if (!ifs.is_open())
{
cout << "打开失败" << endl;
return;
}
//4. 读文件
Person p;
ifs.read((char*)&p, sizeof(Person));
cout << p.m_Name << endl;
cout << p.m_Age << endl;
ifs.close();
}
int main() {
test01();
return 0;
}
125 模板
#include<iostream>
using namespace std;
/*
模板的概念:
模板就是通用的模具,大大提高复用性
函数模板
1. c++的另一种编程思想称为 泛型编程 ,主要利用的技术就是模板
2. c++提供两种模板机制 : 函数模板和类模板
函数模板的语法 :
1. 函数模板的作用 : 建立一个通用函数,其函数返回值类型和形参类型可以不具体指定,用一个虚拟类型来代表
模板语法:
template<typename T> //声明一个模板,告诉编译器,后面紧跟着的T不要报错,T是一个通用的数据类型
模板使用:
利用模板函数有两种方法
1. 自动类型推到
mySwap(a, b);
2. 显示指定类型
mySwap<int>(a, b);
*/
//两个整型交换的函数
void swapInt(int& num1, int& num2)
{
int temp = num1;
num1 = num2;
num2 = temp;
}
//两个浮点型数据交换的函数
void swapDouble(double& a, double& b) {
double temp = a;
a = b;
b = temp;
}
//模板
template<typename T> //声明一个模板,告诉编译器,后面紧跟着的T不要报错,T是一个通用的数据类型
void mySwap(T& num1, T& num2)
{
T temp = num1;
num1 = num2;
num2 = temp;
}
void test01()
{
int a = 10;
int b = 20;
//swapInt(a, b);
//利用模板函数有两种方法
//1. 自动类型推到
//mySwap(a, b);
//2. 显示指定类型
mySwap<int>(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
double c = 1.1;
double d = 2.2;
mySwap(c, d);
mySwap<double>(c, d);
cout << "c = " << c << endl;
cout << "d = " << d << endl;
}
int main() {
test01();
return 0;
}
126 模板注意事项
#include<iostream>
using namespace std;
/*
模板注意事项 :
1. 自动类型推到,必须推到出一致的数据类型T才可以使用
2. 模板必须要确定出T的数据类型才可以使用
*/
//1.
template<typename T>
void mySwap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 1;
int b = 2;
char c = 'c';
//mySwap(b, c);//报错 : 参数类型为 (int char),无法推到出一致的数据类型
}
template<typename T>
void func() {
cout << "func调用" << endl;
}
void test02() {
func();//报错 : 没有与参数列表匹配的函数模板func实例,模板必须要确定出T的数据类型才可以使用,即使模板函数没有T也会报错
}
int main() {
return 0;
}
127 函数模板案例
#include<iostream>
using namespace std;
/*
案例描述：
1. 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
2. 排序规则从大到小，排序算法为选择排序
3. 分别利用char数组和int数组进行测试
*/
template<typename T>
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
template<typename T>
void mySort(T arr[],int len)
{
for (int i = 0; i < len; i++)
{
int min = i;
for (int j = i + 1; j < len; j++)
{
if (arr[j] < arr[min])
{
min = j;
}
}
if (min != i)
{
mySwap(arr[min], arr[i]);
}
}
}
template<typename T>
void printArr(T arr[], int len)
{
for (int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
void test01()
{
//测试char数组
char charArr[] = {'b','d','c','f','e','a','g','h'};
mySort(charArr, sizeof(charArr)/sizeof(charArr[0]));
printArr(charArr, sizeof(charArr) / sizeof(charArr[0]));
//测试int数组
int intArr[] = { 7, 5, 8, 1, 3, 9, 2, 4, 6 };
int num = sizeof(intArr) / sizeof(int);
mySort(intArr, num);
printArr(intArr, num);
}
int main() {
test01();
return 0;
}
128 普通函数和函数模板的区别
#include<iostream>
using namespace std;
/*
普通函数与函数模板的区别
1. 普通函数调用的时候可以发生自动类型转换(隐式类型转换)
2. 函数模板调用的时候,如果利用自动类型推到,不会发生隐式类型转换
3. 如果利用显示指定类型的方式,可以发生隐式类型转换
*/
int myAdd01(int num1, int num2) {
return num1 + num2;
}
template<typename T>
T myAdd02(T num1,T num2) {
return num1 + num2;
}
//1. 普通函数调用的时候可以发生自动类型转换(隐式类型转换)
void test01() {
int a = 10;
int b = 20;
char c = 'c';
cout << myAdd01(a, c) << endl;
}
//2. 函数模板调用的时候, 如果利用自动类型推到, 不会发生隐式类型转换
void test02() {
int num1 = 10;
char num2 = 'c';
//cout << myAdd02(num1, num2) << endl;// 没有匹配到(int,char)类型,换言之,无法进行自动类型转换
}
//3. 如果利用显示指定类型的方式,可以发生隐式类型转换
void test02() {
int num1 = 10;
char num2 = 'c';
cout << myAdd02<int>(num1, num2) << endl;// 采用显示指定类型的方式,就可以进行自动类型转换
}
int main() {
test01();
return 0;
}
129 普通函数和模板函数的调用规则
#include<iostream>
using namespace std;
/*
普通函数和函数模板的调用规则
1. 如果函数模板和普通函数都可以实现,优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以更好的产生匹配,优先调用函数模板
总结 : 既然提供了函数模板,就最好不要提供普通函数,容易出现二义性
*/
void myPrint(int a, int b) {
cout << "调用的普通函数" << endl;
}
template<typename T>
void myPrint(T a, T b) {
cout << "调用的函数模板" << endl;
}
template<typename T>
void myPrint(T a, T b, T c) {
cout << "调用重载的函数模板" << endl;
}
void test01() {
int a = 10;
int b = 20;
myPrint(a, b);//这个时候,优先调用普通函数
//通过空模板参数列表,强制调用函数模板
myPrint<>(a,b);//这个时候,强制调用函数模板
myPrint(a, b, 100);//即使没有空模板参数列表,这个时候也调用重载的函数模板
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2);//调用的函数模板,这里是产生了更好的匹配,因为如果走普通函数,需要进行隐式类型转换,而函数模板不需要
}
int main() {
test01();
return 0;
}
130 模板的局限性
#include<iostream>
using namespace std;
/*
模板的局限性 : 模板的通用性并不是万能的
例如 :
template<class T>
void f(T a, T b)
{
a = b;
}
如果传入的是一个数组, 就无法实现了
因此,c++为了解决这种问题,提供模板的重载,可以为这些特定的类型提供具体化的模板
总结 :
1. 利用具体化模板,可以解决自定义类型的通用化
2. 学习模板并不是为了写模板,而是在stl能够运用系统提供的模板
*/
class Person {
public:
int age;
string name;
Person(int age,string name) {
this->age = age;
this->name = name;
}
//1. 利用运算符重载解决问题
/*bool operator==(Person& p2) {
if (this->age == p2.age && this->name == p2.name)
{
return true;
}
else {
return false;
}
}*/
};
template<typename T>
bool myCompare(T& a, T& b) {
return a == b;
}
//利用具体化Person的版本实现代码,具体化优先调用
template<> bool myCompare(Person& a, Person& b) {
if (a.age == b.age && a.name == b.name)
{
return true;
}
else {
return false;
}
}
void test01() {
int a = 10;
int b = 20;
cout << myCompare(a, b) << endl;
}
void test02() {
Person p1(18, "Tom");
Person p2(18, "Tom");
cout << myCompare(p1, p2) << endl;
}
int main() {
//test01();
test02();
return 0;
}
131 类模板
#include<iostream>
using namespace std;
/*
类模板
类模板与函数模板的区别 :
1. 类模板没有自动类型推导的使用方式
2. 类模板在模板参数列表中可以有默认参数
*/
template<class NameType, class AgeType = int>//这里就是为AgeType指定了默认参数
class Person {
public:
NameType name;
AgeType age;
Person(NameType name, AgeType age) {
this->age = age;
this->name = name;
}
void showPerson() {
cout << "name = " << name << endl;
cout << "age = " << age << endl;
}
};
void test01() {
//Person p("zhangsan", 18);//这是错误的,类模板没有自动类型推导
Person<string, int> p("zhangsan", 18);//只可以用显示指定类型
p.showPerson();
}
void test02() {
Person<string> p("lisi", 20);//因为AgeType有默认参数类型,所以这里可以不用指定,只指定NameTyoe即可
p.showPerson();
}
int main() {
//test01();
test02();
return 0;
}
132 类模板中成员函数的创建时机
#include<iostream>
using namespace std;
/*
类模板中成员函数的创建时机
类模板中成员函数和普通类中的成员函数的创建时机是有区别的
1. 普通类中的成员函数一开始就可以创建
2. 类模板中的成员函数在调用的时候才可以创建,不调用,哪些成员函数也不存在
*/
class Person1 {
public:
void showPerson1() {
cout << "Person1 show" << endl;
}
};
class Person2 {
public:
void showPerson2() {
cout << "Person2 show" << endl;
}
};
template<class T>
class myClass {
public:
T obj;
//类模板中的成员函数
void fun1() {//在调用的时候,T的类型才会确认,所以fun1和fun2两个成员函数是在调用的时候才创建的
obj.showPerson1();
}
void fun2() {
obj.showPerson2();
}
};
void test01() {
myClass<Person1> m;
m.fun1();
//m.fun2();
}
int main() {
test01();
return 0;
}
133 类模板对象做函数参数
#include<iostream>
using namespace std;
/*
类模板对象做函数参数
学习目标 : 类模板实例化出的对象,向函数传参的方式
一共有三种传入的方式
1. 指定传入的类型 -- 直接显示对象的数据类型
2. 参数模板化 -- 将对象中的参数变为模板进行传递
3. 整个类模板化 -- 将这个对象类型模板化进行传递
总结 :
在实际开发中,最常用的是指定传入的类型
*/
template<class T1,class T2>
class Person {
public:
T1 name;
T2 age;
Person(T1 name, T2 age) {
this->age = age;
this->name = name;
}
void showPerson() {
cout << "name = " << name << endl;
cout << "age = " << age << endl;
}
};
//1. 指定传入类型
void printPerson1(Person<string, int>& p) {
p.showPerson();
}
//2. 参数模板化
template<class T1,class T2>
void printPerson2(Person< T1, T2>& p) {
p.showPerson();
cout << "T1的数据类型为: " << typeid(T1).name() << endl;
cout << "T2的数据类型为: " << typeid(T2).name() << endl;
}
//整个类模板化
template<class T>
void printPerson3(T& p) {
p.showPerson();
cout << "T的数据类型为 : " << typeid(T).name() << endl;
}
void test01() {
Person<string, int> p("hejiale", 20);
printPerson1(p);
printPerson2(p);
printPerson3(p);
}
/*
name = hejiale
age = 20
name = hejiale
age = 20
T1的数据类型为: class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
T2的数据类型为: int
name = hejiale
age = 20
T的数据类型为 : class Person<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>
*/
int main() {
test01();
return 0;
}
134 类模板与继承
#include<iostream>
using namespace std;
/*
类模板与继承
当类模板遇到继承的时候,需要注意以下几点
1. 当子类继承的父类是一个类模板的时候,子类在声明的时候,要指定出父类中T的类型
2. 如果不指定,编译器无法给子类分配内存
3. 如果想灵活指定出父类中T的类型,子类也要变为类模板
*/
template<class T>
class Base
{
public:
T m;
};
//class Son :public Base //错误 : 必须要知道父类中的T类型,才可以继承给子类
class Son :public Base<int>
{
};
// 如果想灵活的指定父类中T的类型,那么子类也必须是类模板
template<class T,class T1>
class Son2 :public Base<T>
{
T1 obj;
char c2;
};
void test01()
{
Son s1;
s1.m = 20;
cout << "s1.m = " << s1.m << endl;
}
void test02()
{
Son2<int, char> s2;
cout << sizeof(s2) << endl;
//为什么占用空间是8个字节?正常的思路应该是int+char+char = 6,因为操作系统会进行对其操作,所以最终占用空间是8
}
int main() {
//test01();
test02();
return 0;
}
135 类模板成员函数类外实现
#include<iostream>
using namespace std;
/*
类模板成员函数类外实现
学习目标 : 可以掌握类模板中的成员函数类外实现
*/
template<class T1,class T2>
class Person
{
public:
T1 name;
T2 age;
Person(T1 name, T2 age);
/*{
this->age = age;
this->name = name;
}*/
void showPerson();
/*{
cout << "age = " << age << endl;
cout << "name = " << name << endl;
}*/
};
//构造函数的类外实现
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->age = age;
this->name = name;
}
//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "age = " << age << endl;
cout << "name = " << name << endl;
}
int main() {
Person<string, int> p("hejiale", 19);
p.showPerson();
return 0;
}
136 类模板分文件编写
#include<iostream>
#include "person.hpp"
using namespace std;
/*
类模板分文件编写
学习目标 :
掌握类模板成员函数分文件编写产生的问题以及解决方式
问题 :
类模板中成员函数创建时机是在调用阶段,导致分文件编写的时候链接不到
解决 :
1. 直接包含.cpp源文件
2. 将声明和实现写到一个文件中,并命名为.hpp,hpp是约定的名称,并不是强制
*/
//template<class T1,class T2>
//class Person
//{
//public:
// T1 name;
// T2 age;
// Person(T1 name,T2 age);
// void showPerson();
//};
//template<class T1, class T2>
//Person<T1, T2>::Person(T1 name, T2 age)
//{
// this->age = age;
// this->name = name;
//}
//template<class T1, class T2>
//void Person<T1, T2>::showPerson()
//{
// cout << "age = " << age << endl;
// cout << "name = " << name << endl;
//}
void test01()
{
Person<string, int> p("zhangsan", 19);
p.showPerson();
}
int main() {
test01();
return 0;
}
- .hpp
#pragma once
#include <iostream>
using namespace std;
template<class T1, class T2>
class Person
{
public:
T1 name;
T2 age;
Person(T1 name, T2 age);
void showPerson();
};
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->age = age;
this->name = name;
}
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "age = " << age << endl;
cout << "name = " << name << endl;
}
137 类模板与友元
#include<iostream>
using namespace std;
/*
类模板与友元
学习目标 : 掌握类模板配合友元函数的类内和类外实现
全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在
*/
//2、全局函数配合友元 类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
template<class T1, class T2> class Person;
//如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
//template<class T1, class T2> void printPerson2(Person<T1, T2> & p);
template<class T1, class T2>
void printPerson2(Person<T1, T2>& p)
{
cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}
template<class T1, class T2>
class Person
{
//1、全局函数配合友元 类内实现
friend void printPerson(Person<T1, T2>& p)
{
cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}
//全局函数配合友元 类外实现
friend void printPerson2<>(Person<T1, T2>& p);
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
//1、全局函数在类内实现
void test01()
{
Person <string, int >p("Tom", 20);
printPerson(p);
}
//2、全局函数在类外实现
void test02()
{
Person <string, int >p("Jerry", 30);
printPerson2(p);
}
int main() {
//test01();
test02();
return 0;
}
138 类模板案例
#include "MyArray.hpp"
/*
类模板案例
案例描述 : 实现一个通用的数组类,要求如下
* 可以对内置数据类型以及自定义数据类型的数据进行存储
* 将数组中的数据存储到堆区
* 构造函数中可以传入数组的容量
* 提供对应的拷贝构造函数以及operator=防止浅拷贝问题
* 提供尾插法和尾删法对数组中的数据进行增加和删除
* 可以通过下标的方式访问数组中的元素
* 可以获取数组中当前元素个数和数组的容量
*/
//测试自定义数据类型
class Person
{
public:
string name;
int age;
Person() {};
Person(string name, int age)
{
this->name = name;
this->age = age;
}
};
void printArray(MyArray<int>& arr)
{
for (int i = 0; i < arr.getSize(); i++)
{
cout << arr[i] << endl;
}
}
void printArray(MyArray<Person>& arr)
{
for (int i = 0; i < arr.getSize(); i++)
{
cout << "姓名 : " << arr[i].name << " || 年龄 : " << arr[i].age << endl;
}
}
void test01()
{
MyArray<int> arr1(5);
for (int i = 0; i < 5; i++)
{
arr1.push_back(i);
}
cout << "arr1的打印输出 : " << endl;
printArray(arr1);
cout << "arr的容量 : " << arr1.getCapacity() << endl;
cout << "arr的大小 : " << arr1.getSize() << endl;
cout << arr1[4] << endl;
arr1.pop_back();
arr1.pop_back();
arr1.pop_back();
cout << "arr的容量 : " << arr1.getCapacity() << endl;
cout << "arr的大小 : " << arr1.getSize() << endl;
printArray(arr1);
}
void test02()
{
MyArray<Person> arr(10);
Person p1("孙悟空", 999);
Person p2("貂蝉", 19);
Person p3("赵云", 20);
Person p4("韩信", 30);
Person p5("李云龙", 44);
arr.push_back(p1);
arr.push_back(p2);
arr.push_back(p3);
arr.push_back(p4);
arr.push_back(p5);
//打印数组
printArray(arr);
//输出容量
cout << arr.getCapacity() << endl;
cout << arr.getSize() << endl;
}
int main() {
//test01();
test02();
return 0;
}
139 STL
#include<iostream>
using namespace std;
/*
STL(standard template library)
1. STL的诞生
* 长久以来，软件界一直希望建立一种可重复利用的东西
* C++的面向对象和泛型编程思想，目的就是复用性的提升
* 大多情况下，数据结构和算法都未能有一套标准,导致*从事大量重复工作
* 为了建立数据结构和算法的一套标准,诞生了STL
2. 基本概念
* STL(Standard Template Library,**标准模板库**)
* STL 从广义上分为: **容器(container) 算法(algorithm) 迭代器(iterator)**
* **容器**和**算法**之间通过**迭代器**进行无缝连接。
* STL 几乎所有的代码都采用了模板类或者模板函数
3. STL六大部件
STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器
1. 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
2. 算法：各种常用的算法，如sort、find、copy、for_each等
3. 迭代器：扮演了容器与算法之间的胶合剂。
4. 仿函数：行为类似函数，可作为算法的某种策略。
5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
6. 空间配置器：负责空间的配置与管理。
4. STL中容器、算法、迭代器
*/
int main() {
return 0;
}
140 vector容器中存放自定义数据类型
#include<iostream>
#include<vector>
using namespace std;
/*
vector容器中存放自定义数据类型
*/
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name = name;
this->age = age;
}
};
void test01()
{
vector<Person> v;
Person p1("zhangsan", 18);
Person p2("lisi", 28);
Person p3("wangwu", 13);
Person p4("zhaoli", 20);
Person p5("tianqi", 22);
//向容器中插入数据
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
//遍历容器的数据
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "姓名 : " << it->name << "\t" << "年龄 : " << it->age << endl;
}
}
/*
存放自定义数据类型指针
*/
void test02()
{
vector<Person*> v;
Person p1("zhangsan", 18);
Person p2("lisi", 28);
Person p3("wangwu", 13);
Person p4("zhaoli", 20);
Person p5("tianqi", 22);
//向容器中插入数据
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
v.push_back(&p5);
//遍历容器
for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "姓名 : " << (*it)->name << "\t" << "年龄 : " << (*it)->age << endl;
}
}
int main() {
//test01();
test02();
return 0;
}
141 vector容器中嵌套容器
#include<iostream>
#include<vector>
using namespace std;
/*
学习目标 : 容器中嵌套容器,外面将对所有数据进行遍历输出
*/
void test01()
{
vector<vector<int>> v;
//创建小容器
vector<int> v1;
vector<int> v2;
vector<int> v3;
vector<int> v4;
//向小容器添加数据
for (int i = 0; i < 4; i++)
{
v1.push_back(i + 1);
v2.push_back(i + 2);
v3.push_back(i + 3);
v4.push_back(i + 4);
}
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
v.push_back(v4);
//通过大容器,把所有的数据遍历
for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
{
for (vector<int>::iterator it2 = it->begin(); it2 != it->end(); it2++)
{
cout << *it2 << "\t";
}
cout << endl;
}
}
int main() {
test01();
return 0;
}
142 string构造
#include<iostream>
using namespace std;
/*
string的基本概念
1. 本质 : string是c++风格的字符串,而string本质上是一个类
2. string和char*的区别
1. char*是一个指针
2. string是一个类,类内部封装了char*,管理zhe'ge字符串,是一个char*的容器
3. 特点
1. string类内部封装了很多成员方法
例如 : 查找find,删除delete,拷贝copy,替换replace,插入insert
string管理char*分配的内存,不用担心复制越界和取值越界等,由类内部进行负责
4. 构造函数
string() //创建一个空的字符串
string(const char* s) //使用字符串s初始化
string(const string& str) //使用一个string对象初始化另一个string对象
string(int n, char c) //使用n个字符c初始化
*/
void test01()
{
//1.
string s1; //默认构造
//2.
const char* str = "hello world";
string s2(str);
cout << s2 << endl;
//3.
string s3(s2);
cout << s3 << endl;
//4.
string s4(10, 'a');
cout << s4 << endl;
}
int main() {
test01();
return 0;
}
143 string赋值操作
#include<iostream>
using namespace std;
/*
string赋值操作
赋值的函数原型：
* `string& operator=(const char* s);` //char*类型字符串 赋值给当前的字符串
* `string& operator=(const string &s);` //把字符串s赋给当前的字符串
* `string& operator=(char c);` //字符赋值给当前的字符串
* `string& assign(const char *s);` //把字符串s赋给当前的字符串
* `string& assign(const char *s, int n);` //把字符串s的前n个字符赋给当前的字符串
* `string& assign(const string &s);` //把字符串s赋给当前字符串
* `string& assign(int n, char c);` //用n个字符c赋给当前字符串
*/
void test01()
{
string str1;
str1 = "hello world";
cout << str1 << endl;
string str2 = str1;
cout << str2 << endl;
//必须分开写,不能直接等号连接上写
string str3;
str3 = 'a';
cout << str3 << endl;
string str4;
str4.assign("hello c++");
cout << str4 << endl;
string str5;
str5.assign("hello c++", 6);
cout << str5 << endl;
string str6;
str6.assign(str5);
cout << str6 << endl;
string str7;
str7.assign(10, 'w');
cout << str7 << endl;
}
int main() {
test01();
return 0;
}
144 string拼接
#include<iostream>
using namespace std;
/*
string拼接 : 实现在字符串末尾拼接字符串
* `string& operator+=(const char* str);` //重载+=操作符
* `string& operator+=(const char c);` //重载+=操作符
* `string& operator+=(const string& str);` //重载+=操作符
* `string& append(const char *s); ` //把字符串s连接到当前字符串结尾
* `string& append(const char *s, int n);` //把字符串s的前n个字符连接到当前字符串结尾
* `string& append(const string &s);` //同operator+=(const string& str)
* `string& append(const string &s, int pos, int n);`//字符串s中从pos开始的n个字符连接到字符串结尾
*/
void test01()
{
string str1 = "我";
str1 += "爱玩游戏";
cout << str1 << endl;
str1 += ';';
cout << str1 << endl;
string str2 = "LOL DNF";
str1 += str2;
cout << str1 << endl;
}
void test02()
{
string str3 = "I";
str3.append(" LOVE");
cout << str3 << endl;
str3.append(" game abcde ", 5);//把" game abcde "的前五个字符拼接到str3的末尾
cout << str3 << endl;
string str4 = " hejiale";
str3.append(str4);
cout << str3 << endl; //I LOVE game hejiale
string str5 = "LOLDNF";
str3.append(str5, 0, 3);//将str5从下标0开始截取三个字符拼接到str5
cout << str3 << endl;//I LOVE game hejialeLOL
str3.append(str5, 3, 3);
cout << str3 << endl;//I LOVE game hejialeLOLDNF
}
int main() {
//test01();
test02();
return 0;
}
145 string查找和替换
#include<iostream>
using namespace std;
/*
string查找和替换
**功能描述：**
* 查找：查找指定字符串是否存在
* 替换：在指定的位置替换字符串
**函数原型：**
* `int find(const string& str, int pos = 0) const;` //查找str第一次出现位置,从pos开始查找
* `int find(const char* s, int pos = 0) const; ` //查找s第一次出现位置,从pos开始查找
* `int find(const char* s, int pos, int n) const; ` //从pos位置查找s的前n个字符第一次位置
* `int find(const char c, int pos = 0) const; ` //查找字符c第一次出现位置
* `int rfind(const string& str, int pos = npos) const;` //查找str最后一次位置,从pos开始查找
* `int rfind(const char* s, int pos = npos) const;` //查找s最后一次出现位置,从pos开始查找
* `int rfind(const char* s, int pos, int n) const;` //从pos查找s的前n个字符最后一次位置
* `int rfind(const char c, int pos = 0) const; ` //查找字符c最后一次出现位置
* `string& replace(int pos, int n, const string& str); ` //替换从pos开始n个字符为字符串str
* `string& replace(int pos, int n,const char* s); ` //替换从pos开始的n个字符为字符串s
*/
//查找
void test01()
{
//find
string str1 = "abcdefgde";
cout << str1.find("de") << endl;//3
/*
rfind 和 find的区别
rfind从右往左查找,一般是查找最后出现的位置
find从左往右查找
*/
cout << str1.rfind("de") << endl;//7
}
//替换
void test02()
{
string str1 = "abcdefg";
//从1号位置起,3个字符,替换为1111
str1.replace(1, 3, "1111");
cout << str1 << endl;
}
int main() {
//test01();
test02();
return 0;
}
146 string比较
#include<iostream>
using namespace std;
/*
**功能描述：**
* 字符串之间的比较
**比较方式：**
* 字符串比较是按字符的ASCII码进行对比
= 返回 0
> 返回 1
< 返回 -1
**函数原型：**
* `int compare(const string &s) const; ` //与字符串s比较
* `int compare(const char *s) const;` //与字符串s比较
*/
void test01()
{
string str1 = "aello";
string str2 = "hello";
cout << str1.compare(str2) << endl;
}
int main() {
test01();
return 0;
}
147 字符存取
#include<iostream>
using namespace std;
/*
string字符存取
string中单个字符存取方式有两种
* `char& operator[](int n); ` //通过[]方式取字符
* `char& at(int n); ` //通过at方法获取字符
*/
void test01()
{
string str = "hello";
cout << str[0] << endl;
cout << str[1] << endl;
cout << str[2] << endl;
for (int i = 0; i < str.size(); i++)
{
cout << str[i] << " ";
}
cout << endl;
for (int i = 0; i < str.size(); i++)
{
cout << str.at(i) << " ";
}
cout << endl;
//注意 : 这里必须是单引号
str[0] = 'x';
cout << str << endl;
}
int main() {
test01();
return 0;
}
148 string插入和删除
#include<iostream>
using namespace std;
/*
string插入和删除
**功能描述：**
* 对string字符串进行插入和删除字符操作
**函数原型：**
* `string& insert(int pos, const char* s); ` //插入字符串
* `string& insert(int pos, const string& str); ` //插入字符串
* `string& insert(int pos, int n, char c);` //在指定位置插入n个字符c
* `string& erase(int pos, int n = npos);` //删除从Pos开始的n个字符
*/
void test01()
{
string str = "hello world";
//插入
str.insert(1, "111");
cout << str << endl;// h111ello world
//删除
str.erase(1, 3);
cout << str << endl;
}
int main() {
test01();
return 0;
}
149 string子串
#include<iostream>
using namespace std;
/*
string子串
**功能描述：**
* 从字符串中获取想要的子串
**函数原型：**
* `string substr(int pos = 0, int n = npos) const;` //返回由pos开始的n个字符组成的字符串
*/
void test01()
{
string str = "abcdef";
string substr = str.substr(1, 3);
cout << substr << endl;//bcd
}
//实用操作
void test02()
{
string email = "[email protected]";
//从邮箱中获取 用户名信息
int pos = email.find("@");
string username = email.substr(0, pos);
cout << username << endl;
}
int main() {
//test01();
test02();
return 0;
}
150 vector的构造函数
#include<iostream>
#include<vector>
using namespace std;
/*
基本概念 :
1. 功能 : vector数据结构和数组非常相似,也称为单端数组
2. vector和普通数组的区别 : 不同之处在于数组是静态空间,而vector可以动态扩展
3. 动态扩展 : 并不是在原空间之后续接新的空间,而是找更大的空间,然后将原数据拷贝新空间,释放原空间
4. vector的迭代器是支持随机访问的迭代器
vector的构造函数
功能描述 : 创建vector容器
函数原型 :
1. vector<T> v; //采用模板实现类实现，默认构造函数
2. vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
3. vector(n, elem); //构造函数将n个elem拷贝给本身。
4. vector(const vector &vec); //拷贝构造函数。
常用成员方法 :
1. begin 获取指向第一个元素的指针,指针类型是迭代器,下同
2. end 获取指向最后一个元素后一个位置的指针
3. insert 插入
4. rbegin 指向最后一个元素的指针
5. rend 指向第一个元素前一个位置的指针
*/
void printVector(vector<int>& v1)
{
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
{
cout << *it << " " ;
}
cout << endl;
}
void test01()
{
vector<int> v1;//默认无参构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
//2. 通过区间构造
vector<int> v2(v1.begin(), v1.end());//[begin,end)前闭后开区间
printVector(v2);
//3.
vector<int> v3(10, 100);//容器中放10个100
printVector(v3);
//4. 拷贝构造
vector<int> v4(v3);
printVector(v4);
}
int main() {
test01();
return 0;
}
151 vector赋值操作
#include<iostream>
#include<vector>
using namespace std;
/*
vector赋值操作
功能描述 : 给vector容器进行赋值
函数原型 :
1. vector& operator=(const vector &vec);//重载等号操作符
2. assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
3. assign(n, elem); //将n个elem拷贝赋值给本身。
*/
void printVector(vector<int>& v1)
{
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
//赋值
//1.
vector<int> v2 = v1;
printVector(v2);
//2.
vector<int> v3;
v3.assign(v1.begin(), v1.end());
printVector(v3);
//3.
vector<int> v4;
v4.assign(10, 100);//10个100
printVector(v4);
}
int main() {
test01();
return 0;
}
152 vector的容量和大小
#include<iostream>
#include<vector>
using namespace std;
/*
vector的容量和大小
功能描述 : 对vector容器的容量和大小操作
函数原型 :
1. empty(); //判断容器是否为空
2. capacity(); //容器的容量
3. size(); //返回容器中元素的个数
4. resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
5. resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除
*/
void test01()
{
vector<int> v1;
cout << v1.empty() << endl;//1
cout << v1.capacity() << endl;//0
cout << v1.size() << endl;//0
v1.resize(10, 10);
cout << v1.empty() << endl;//0
cout << v1.capacity() << endl;//10
cout << v1.size() << endl;//10
v1.push_back(20);
cout << v1.capacity() << endl;//15
cout << v1.size() << endl;//11
v1.push_back(20);
v1.push_back(20);
v1.push_back(20);
v1.push_back(20);
v1.push_back(20);
cout << v1.capacity() << endl;//22
cout << v1.size() << endl;//16
v1.resize(2);
cout << v1.capacity() << endl;//22
cout << v1.size() << endl;//2
v1.resize(30);
cout << v1.capacity() << endl;//33
cout << v1.size() << endl;//30
cout << v1[29] << endl;//0
}
int main() {
test01();
return 0;
}
153 vector插入和删除
#include<iostream>
#include<vector>
using namespace std;
/*
vector插入和删除
函数原型 :
* `push_back(ele);` //尾部插入元素ele
* `pop_back();` //删除最后一个元素
* `insert(const_iterator pos, ele);` //迭代器指向位置pos插入元素ele
* `insert(const_iterator pos, int count,ele);`//迭代器指向位置pos插入count个元素ele
* `erase(const_iterator pos);` //删除迭代器指向的元素
* `erase(const_iterator start, const_iterator end);`//删除迭代器从start到end之间的元素
* `clear();` //删除容器中所有元素
*/
void printVector(vector<int>& v1)
{
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
vector<int> v1;
//尾插法
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
printVector(v1);
//尾删
v1.pop_back();
v1.pop_back();
printVector(v1);
//插入 第一个参数是迭代器
v1.insert(v1.begin(), 100);
printVector(v1);//100 1 2 3
v1.insert(v1.begin(), 2, 1000);//在最前面插入2个1000
printVector(v1);//1000 1000 100 1 2 3
//删除
v1.erase(v1.begin());//1000 100 1 2 3
printVector(v1);
/*
删除区间
v1.erase(v1.begin(), v1.end());
printVector(v1);
*/
v1.clear();
printVector(v1);
}
int main() {
test01();
return 0;
}
154 vector数据存取
#include<iostream>
#include<vector>
using namespace std;
/*
vector数据存取
功能描述 : 对vector中的数据的存取操作
函数原型 :
1. at(int idx); //返回索引idx所指的数据
2. operator[]; //返回索引idx所指的数据
3. front(); //返回容器中第一个数据元素
4. back(); //返回容器中最后一个数据元素
*/
void test01()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";//0 1 2 3 4 5 6 7 8 9
}
cout << endl;
for (int i = 0; i < v1.size(); i++)
{
cout << v1.at(i) << " ";//0 1 2 3 4 5 6 7 8 9
}
cout << endl;
cout << v1.front() << endl;//0
cout << v1.back() << endl; //9
}
int main() {
test01();
return 0;
}
155 vector互换容器以及内存收缩
#include<iostream>
#include<vector>
using namespace std;
/*
vector互换容器以及内存收缩
功能描述 : 实现两个容器内元素互换
函数原型 :
swap(vec) //将vec与本身的元素互换
*/
void printVector(vector<int>& v1)
{
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);//0 1 2 3 4 5 6 7 8 9
}
cout << "交换前 : " << endl;
printVector(v1);
vector<int> v2;
for (int i = 10; i > 0; i--)
{
v2.push_back(i);// 10 9 8 7 6 5 4 3 2 1
}
printVector(v2);
cout << "交换后" << endl;
v1.swap(v2);
printVector(v1);
printVector(v2);
}
//2. 实际用处
//巧用swap可以收缩内存空间
void test02()
{
vector<int> v1;
for (int i = 0; i < 100000; i++)
{
v1.push_back(i);
}
cout << v1.capacity() << endl; //138255
cout << v1.size() << endl; //100000
v1.resize(3);
cout << v1.capacity() << endl; //138255
cout << v1.size() << endl; //3
//我们会发现,v1只存储了三个元素,但是容量确是138255非常大的,容量可以自动扩充,但是无法自动收缩
//利用swap,我们可以收缩内存空间
vector<int>(v1).swap(v1);
/*
vector<int>(v1) 利用拷贝构造函数构造了一个匿名对象,
*/
cout << v1.capacity() << endl; //3
cout << v1.size() << endl; //3
}
int main() {
//test01();
test02();
return 0;
}
156 vector预留空间
#include<iostream>
#include<vector>
using namespace std;
/*
vector预留空间
功能描述 : 减少vector在动态扩展容量时的扩展次数
函数原型 :
reserve(int len)//容器预留len个元素长度,预留位置不初始化,元素不可访问,意思就是分配内存了,但是没有初始化
无法访问,访问就报错
*/
void test01()
{
vector<int> v;
//预留空间
v.reserve(100000);
int num = 0; // 统计开辟次数
int* p = NULL;
for (int i = 0; i < 100000; i++)
{
v.push_back(i);
/*
首先,我们要知道,容量的改变不是原地改变,而是重新开辟一个内存空间,所以,每次容量改变,容器的地址也会发生改变
因此,我们可以利用这个机制,计算出存储100000个数据的时候,会扩容多少次
*/
if (p != &v[0])
{
p = &v[0];
num++;
}
}
cout << num << endl; // 预留空间前 : 30次,预留空间后 : 1次
}
int main() {
test01();
return 0;
}
157 deque容器
#include<iostream>
#include<deque>
using namespace std;
/*
deque容器
功能 : 双端数组,可以对头端尾端进行插入删除操作
deque和vector的区别 :
1. vector对于头部的插入删除效率低下,数据量越大,效率越低
2. deque相对而言,对头部的插入删除速度要比vector快
3. vector访问元素的速度会比deque快,这和两者内部实现有关
常用的类方法
1. push_front
2. pop_front
3. push_back
4. pop_back
5. insert
6. front
7. back
8. insert
9. begin
10. end
deque内部工作原理:
deque内部有个**中控器**，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间
构造函数
功能描述 : deque容器构造
函数原型：
1. deque<T> deqT; //默认构造形式
2. deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
3. deque(n, elem); //构造函数将n个elem拷贝给本身。
4. deque(const deque &deq); //拷贝构造函数
*/
void printDeque(deque<int>& d1)
{
for (int i = 0; i < d1.size(); i++)
{
cout << d1[i] << " ";
}
cout << endl;
}
void test01()
{
//1.
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
//2.
deque<int> d2(d1.begin(), d1.end());
printDeque(d1);
printDeque(d2);
//3.
deque<int> d3(10, 2);
printDeque(d3);
//4.
deque<int> d4(d2);
printDeque(d4);
}
int main() {
test01();
return 0;
}
158 deque赋值操作
#include<iostream>
#include<deque>
using namespace std;
/*
deque赋值操作
功能描述 : 给deque容器进行赋值
函数原型 :
1. deque& operator=(const deque& deq)
2. assign(begin,end)
3. assign(n,elme)
*/
void printDeque(deque<int>& d1)
{
for (int i = 0; i < d1.size(); i++)
{
cout << d1[i] << " ";
}
cout << endl;
}
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_front(i);
}
printDeque(d1);//9 8 7 6 5 4 3 2 1 0
deque<int> d2 = d1;
printDeque(d2);//9 8 7 6 5 4 3 2 1 0
deque<int> d3;
d3.assign(d1.begin(), d1.end());
printDeque(d3);//9 8 7 6 5 4 3 2 1 0
d3.assign(10, 2);
printDeque(d3);// 2 2 2 2 2 2 2 2 2 2
}
int main() {
test01();
return 0;
}
159 deque大小操作
#include<iostream>
#include "printDeque.h"
using namespace std;
/*
deque大小操作
功能描述 : 对deque容器的大小操作
函数原型 :
1. deque.empty() //判空
2. deque.size() //返回容器中元素个数
3. deque.resize(num) //重新指定容器长度,若超出本身长度,补默认值
4. deque.resize(num,elem)//重新指定容器长度,若超出本身长度,补elem
*/
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
cout << d1.empty() << endl;
cout << d1.size() << endl;
d1.resize(20);
printDeque(d1);
d1.resize(30, 19);
printDeque(d1);
/*
0 1 2 3 4 5 6 7 8 9
0
10
0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 0 0 0 补0
0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 0 0 0 19 19 19 19 19 19 19 19 19 19 补19
*/
}
int main() {
test01();
return 0;
}
160 deque插入和删除
#include "printDeque.h"
#include<iostream>
using namespace std;
/*
deque插入和删除
功能描述 : 向deque容器中插入和删除数据
函数原型 :
两端插入操作
1. push_back(elem)
2. push_front(elem)
3. pop_back
4. pop_front
指定位置操作 -->提供的位置都是迭代器,而不是下标
1. insert(pos,elem) //在pos位置插入一个elem元素的拷贝，返回新数据的位置
2. insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。
3. insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。
4. clear(); //清空容器的所有数据
5. erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
6. erase(pos); //删除pos位置的数据，返回下一个数据的位置。
*/
//两端插入操作
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_front(i);
}
deque<int> d2;
for (int i = 0; i < 10; i++)
{
d2.push_back(i);
}
printDeque(d1);//9 8 7 6 5 4 3 2 1 0
printDeque(d2);//0 1 2 3 4 5 6 7 8 9
d1.pop_back();
d1.pop_back();
printDeque(d1);//9 8 7 6 5 4 3 2
d1.pop_front();
d1.pop_front();
d1.pop_front();
printDeque(d1);//6 5 4 3 2
}
//指定位置操作
void test02()
{
deque<int> d1;
d1.push_back(10);
d1.push_back(20);
d1.push_back(30);
d1.push_back(40);
printDeque(d1);
deque<int>::iterator it = d1.begin();
it++;
d1.insert(it, 4);
printDeque(d1);//10 4 20 30 40
d1.insert(d1.begin(), 2, 1000);
printDeque(d1);//1000 1000 10 4 20 30 40
deque<int> d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
d2.push_back(4);
d2.insert(d2.begin(), d1.begin(), d1.end());
printDeque(d2);//1000 1000 10 4 20 30 40 1 2 3 4
}
//删除
void test03()
{
deque<int> d1;
d1.push_back(10);
d1.push_back(20);
d1.push_front(100);
d1.push_front(200);//200 100 10 20
deque<int>::iterator it = d1.begin();
it++;
d1.erase(it);
printDeque(d1);//200 10 20
//按区间删除
//区间删除
d1.erase(d1.begin(), d1.end());
printDeque(d1);
d1.clear();//清空操作
}
int main() {
//test01();
//test02();
test03();
return 0;
}
161 deque数据存取
#include "printDeque.h"
#include<iostream>
using namespace std;
/*
deque数据存取
- at(int idx); //返回索引idx所指的数据
- operator[]; //返回索引idx所指的数据
- front(); //返回容器中第一个数据元素
- back(); //返回容器中最后一个数据元素
*/
void test01()
{
deque<int> d1;
d1.push_back(10);
d1.push_back(20);
d1.push_back(30);
d1.push_back(40);
cout << d1[0] << endl;//10
cout << d1.at(2) << endl;//30
cout << d1.front() << endl;//10
cout << d1.back() << endl;//40
}
int main() {
test01();
return 0;
}
162 deque排序
#include "printDeque.h"
#include<iostream>
#include<algorithm>
using namespace std;
/*
deque排序
算法 :
1. sort(iterator beg, iterator end) //对beg和end区间内元素进行排序
注意 : 对于支持随机访问的迭代器的容器,都可以利用sort算法直接对其进行排序,vector也可以利用sort进行排序
*/
void test01()
{
deque<int> d1;
d1.push_back(1);
d1.push_back(4);
d1.push_back(2);
d1.push_back(3);
d1.push_back(8);
d1.push_back(6);
d1.push_back(0);
d1.push_back(7);
sort(d1.begin(), d1.end());//默认从小到大
printDeque(d1);//0 1 2 3 4 6 7 8
}
int main() {
test01();
return 0;
}
163 评委打分案例
#include<iostream>
#include<ctime>//和产生真随机数有关的包
#include<vector>
#include<deque>
#include<algorithm>
using namespace std;
/*
评委打分案例 :
案例描述 : 有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
实现步骤 :
1. 创建五名选手,放到vector容器里面
2. 遍历vector容器,取出每一个选手,执行for循环,可以把10个评委打分存到deque容器里面
3. sort算法对deque容器中分数排序,去除一个最高分和一个最低分
4. 遍历deque容器,累加总分,求平均值
*/
class Person
{
public:
string name;//姓名
int score;//平均分
Person(string name, int score)
{
this->name = name;
this->score = score;
}
};
void createPerson(vector<Person>& v)
{
string nameSeed = "ABCDE";
for (int i = 0; i < 5; i++)
{
string name = "选手";
name += nameSeed[i];
Person p(name, 0);//创建选手
v.push_back(p);//将选手放入容器
}
}
void setScore(vector<Person>& v)
{
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
{
//将评委的分数,放入deque容器
deque<int> d;
for (int i = 0; i < 10; i++)
{
int score = rand() % 41 + 60;//60~100的随机数
d.push_back(score);
}
sort(d.begin(), d.end());//排序,方便排序一个最高分和最低分
d.pop_back();
d.pop_front();//这里就是为什么我们要选用deque,因为deque可以对首尾两端操作,方便我们删除最低分,而vector只可以对尾部操作
//求平均分
int sum = 0;
for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
{
sum += *(it);
}
int avg = sum / d.size();
//将平均分给选手
it->score = avg;
}
}
void showScore(vector<Person>& v)
{
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
{
cout << it->name << "\t" << it->score << endl;
}
}
int main() {
srand((unsigned int)time(NULL));//只有rand的话,产生的是伪随机数,加上这一行代码,可以产生正真意义上的随机数
//创建五名选手
vector<Person> v;//存放选手的容器
createPerson(v);
//给选手打分
setScore(v);
//显示最后得分
showScore(v);
return 0;
}
164 stack基本概念
#include<iostream>
#include<stack>
using namespace std;
/*
stack基本概念 : stack是一种 先进后出 (First In Last Out,FILO)的数据结构，它只有一个出口
1. push()入栈
2. void pop()出栈
3. T top()栈顶元素
4. empty()判空
5. size()栈的元素个数
注意 :
1. 栈不允许有遍历行为,因为我们只可以访问栈的栈顶元素,如果想访问次顶元素,就必须去除栈顶元素,这就破坏了
栈的原有结构了,就不是遍历了
2. 栈可以判断容器是否为空-->empty()
构造函数
stack<T> stk; // stack采用模板类实现,stack对象的默认构造形式
stack(const stack& stk) // 拷贝构造函数
赋值操作
运算符重载等号
stack& operator=(const stack& stk)
数据存取
push
void pop()
top
*/
void test01()
{
stack<int> stk;
stk.push(1);
stk.push(2);
stk.push(3);
stk.pop();
cout << stk.top() << endl;//2
stack<int> stk2(stk);
cout << stk2.top() << endl; //2
stk2.pop();
cout << stk2.top() << endl; //1
}
void test02()
{
stack<int> stk;
stk.push(1);
stk.push(2);
stk.push(3);
stack<int> stk2 = stk;
cout << stk2.top() << endl; //3
}
void test03()
{
stack<int> stk;
stk.push(1);
stk.push(2);
stk.push(3);
cout << stk.size() << endl;//3
cout << stk.empty() << endl;//0
}
void test04()
{
stack<int> stk;
stk.push(1);
stk.push(2);
stk.push(3);
stk.pop();
stk.pop();
stk.pop();
stk.pop();//会报错,因为stack只有三个元素,pop第四次的时候,stk以及没有数据,所以报错
stk.pop();
stk.pop();
}
int main() {
//test01();
//test02();
//test03();
test04();
return 0;
}
165 queue队列
#include<iostream>
#include<queue>
using namespace std;
/*
queue队列 : 先进先出的数据结构,有两个出口
注意 : 队列中只有队头和队尾可以被外界使用,所以不允许有遍历行为
常用接口 :
push 入队
pop 出队
构造函数 :
queue<T> que;
queue(const queue& que)
赋值操作
重载等号运算符
数据存取
push
pop
back() 返回最后一个元素
front() 返回第一个元素
大小操作
empty
size();
*/
void test01()
{
queue<int> q;
q.push(1);
q.push(2);
q.push(3);
cout << "q.size = " << q.size() << endl;//3
cout << "q.front = " << q.front() << endl;//1
cout << "q.back = " << q.back() << endl;//3
cout << "q is empty ? " << q.empty() << endl;//false
while (!q.empty())
{
cout << q.front() << endl;
q.pop();
}
}
int main() {
test01();
return 0;
}
166 list容器
#include<iostream>
using namespace std;
/*
list容器
功能 : 将数据进行链式存储
链表 : 是一种物理存储单元上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接实现的
组成 : 链表由一系列结点组成
结点的组成 : 一个是存储数据元素的数据域,一个是存储下一个结点地址的指针域
stl中的链表是一个双向循环链表,指针域由两个指针,分别指向前一个指针和后一个指针,实现双向,并且首元素的前指针域会指向尾元素
实现循环
优点 :
通过修改指针,方便进行增删元素,不会因为增删元素导致大量的 数据移动
动态存储分配,不会造成内存浪费和溢出
缺点 :
不支持随机访问,不可以利用[]访问,遍历的耗费较大
由于存在指针域和数据域,所以占用空间比数组大
注意 :
1. 由于链表的存储方式并不是连续的空间,一次链表list中的迭代器只支持前移和后移,属于双向迭代器
2. List有一个重要的性质,插入操作和删除操作都不会造成原有list迭代器失效(迭代器地址变化,比如vector插入
一个元素导致容器满了,这个时候就会重新开辟一个空间,导致迭代器指针改变),这在vector是不成立的
3. list的迭代器是双向迭代器,不可以进行跳跃访问,即使 it + 1 也是错误的
*/
int main() {
return 0;
}
167 ***迭代器失效
#include<iostream>
#include<vector>
#include<deque>
using namespace std;
/*
迭代器失效,失效就是迭代器不能用了,不能通过解引用得到数据
一、迭代器失效的类型
a.由于插入元素，使得容器元素整体“迁移”导致存放原容器元素的空间不再有效，从而使得指向原空间的迭代器失效。
b.由于删除元素使得某些元素次序发生变化使得原本指向某元素的迭代器不再指向希望指向的元素。
二、vector
内部数据结构：数组
随机访问每个元素，所需要的时间为O(1)
在末尾增加或删除元素所需时间与元素数目无关，在中间或开头增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，但程序员可以使用reserve()成员函数来管理内存。
vector的迭代器在内存重新分配时将失效（它所指向的元素在该操作的前后不再相同）。
当把超过capacity()-size()个元素插入vector中时，内存会重新分配，所有的迭代器都将失效；否则，指向当前元素以后的任何元素的迭代器都将失效。
当删除元素时，指向被删除元素以后的任何元素的迭代器都将失效。
说明:
当插入（push_back）一个元素后，end操作返回的迭代器肯定失效。
当插入(push_back)一个元素后，capacity返回值与没有插入元素之前相比有改变，则需要重新加载整个容器，此时first和end操作返回的迭代器都会失效。
当进行删除操作（erase，pop_back）后，指向删除点的迭代器全部失效；指向删除点后面的元素的迭代器也将全部失效。
三、deque
内部数据结构：数组
随机访问每个元素，所需要的时间为O(1)
在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，不提供用于内存管理的成员函数。
增加任何元素都将使deque的迭代器失效。在deque的中间删除元素将使迭代器失效。在deque的头或尾删除元素时，只有指向该元素的迭代器失效。
说明:
在deque容器首部或者尾部插入元素不会使得任何迭代器失效。
在其首部或尾部删除元素则只会使指向被删除元素的迭代器失效。
在deque容器的任何其他位置的插入和删除操作将使指向该容器元素的所有迭代器失效。
四、list
内部数据结构：双向环状链表
不能随机访问一个元素。
可双向遍历。
在开头、末尾和中间任何地方增加或删除元素所需时间都为O(1)
可动态增加或减少元素，内存管理自动完成。
增加任何元素都不会使迭代器失效。删除元素时，除了指向当前被删除元素的迭代器外，其它迭代器都不会失效。
说明:
插入操作（insert）和接合操作（splice）不会造成原有的list迭代器失效，这在vector中是不成立的，
因为vector的插入操作可能造成记忆体重新配置，导致所有的迭代器全部失效。
list的删除操作（erase）也只有指向被删除元素的那个迭代器失效，其他迭代器不受影响。（list目前只发现这一种失效的情况）
五、slist
内部数据结构：单向链表
不可双向遍历，只能从前到后地遍历。
其它的特性同list相似。
六、stack
适配器，它可以将任意类型的序列容器转换为一个堆栈，一般使用deque作为支持的序列容器。
元素只能后进先出（LIFO）。
不能遍历整个stack。
七、queue
适配器，它可以将任意类型的序列容器转换为一个队列，一般使用deque作为支持的序列容器。
元素只能先进先出（FIFO）。
不能遍历整个queue。
八、priority_queue
适配器，它可以将任意类型的序列容器转换为一个优先级队列，一般使用vector作为底层存储方式。
只能访问第一个元素，不能遍历整个priority_queue。
第一个元素始终是优先级最高的一个元素。
九、set
键唯一。
元素默认按升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。
十、multiset
键可以不唯一。
其它特点与set相同。
十一、map
键唯一。
元素默认按键的升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。
十二、multimap
键可以不唯一。
其它特点与map相同。
*/
void test01()
{
vector<int> v;
v.push_back(1);
cout << v.capacity() << endl; //此时的容量为1
vector<int>::iterator it = v.begin(); //获得了指向v首元素的迭代器
v.push_back(2); //此时的容量为2
cout << *it << endl;//这个时候会报错,因为容器的容量发生改变,说明重新开辟了内存空间,所以原来的全部迭代器都失效
}
void test02()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7);
v.push_back(8);
v.push_back(9);
v.push_back(10);
v.push_back(11);
v.push_back(12);
v.push_back(13);
v.push_back(14);
cout << v.capacity() << endl; // 19
vector<int>::iterator it = v.begin();
for (int i = 0; i < 10; i++)
{
it++;
}
cout << *it << endl; //11
v.erase(it);
cout << *it << endl;//这个时候会报错,因为11以及以后元素的迭代器都已经失效了
}
void test03()
{
deque<int> d;
d.push_back(1);
d.push_back(2);
d.push_back(3);
d.push_back(4);
d.push_back(5);
d.push_back(6);
d.push_back(7);
deque<int>::iterator it = d.begin();
deque<int>::iterator it2 =d.begin();
it2++;
//删除前
cout << *it << endl;//1
cout << *it2 << endl;//2
d.pop_front();
//cout << *it << endl;//报错,因为迭代器已经失效
cout << *it2 << endl;//2
it2++;
cout << *it2 << endl;//3
}
int main() {
//test01();
//test02();
test03();
return 0;
}
168 list构造函数
#include<iostream>
#include<list>
#include "MyPrint.h"
using namespace std;
/*
list构造函数
* `list<T> lst;` //list采用采用模板类实现,对象的默认构造形式：
* `list(beg,end);` //构造函数将[beg, end)区间中的元素拷贝给本身。
* `list(n,elem);` //构造函数将n个elem拷贝给本身。
* `list(const list &lst);` //拷贝构造函数。
*/
void test01()
{
list<int> lst;
lst.push_back(1);
lst.push_back(2);
lst.push_back(3);
list<int> lst2(lst.begin(), lst.end());
cout << lst2.front() << endl; //1
list<int> lst3(10, 100);
printList(lst3);
list<int> lst4 = lst3;
printList(lst4);
}
int main() {
test01();
return 0;
}
169 list赋值和交换
#include<iostream>
#include<list>
#include "MyPrint.h"
using namespace std;
/*
list赋值和交换
swap可以用来交换
*/
void test01()
{
list<int> l1;
l1.push_back(10);
l1.push_back(20);
l1.push_back(30);
l1.push_back(40);
printList(l1);
list<int> l2;
l2 = l1;
printList(l2);
list<int> l3;
l3.assign(l2.begin(), l2.end());
printList(l3);
list<int> l4;
l4.assign(10, 100);
printList(l4);
}
void test02()
{
list<int> l1;
l1.push_back(10);
l1.push_back(20);
l1.push_back(30);
l1.push_back(40);
list<int> l2;
l2.assign(10, 100);
cout << "交换前 :" << endl;
printList(l1);
printList(l2);
l1.swap(l2);
cout << "交换后 : " << endl;
printList(l1);
printList(l2);
}
int main() {
//test01();
test02();
return 0;
}
170 list大小操作
#include<iostream>
#include<list>
#include "MyPrint.h"
using namespace std;
/*
list大小操作
size
empty
resize(num) 重新指定容器的长度为num
resize(num,elem)
*/
void test01()
{
list<int> l1;
l1.push_back(1);
l1.push_back(2);
l1.push_back(3);
l1.push_back(4);
cout << "size = " << l1.size() << endl;
cout << "l1 is empty ? " << l1.empty() << endl;
l1.resize(10);
printList(l1);
l1.resize(20, 1000);
printList(l1);
}
int main() {
test01();
return 0;
}
171 list插入和删除
#include<iostream>
#include<list>
#include "MyPrint.h"
using namespace std;
/*
list插入和删除
* push_back(elem);//在容器尾部加入一个元素
* pop_back();//删除容器中最后一个元素
* push_front(elem);//在容器开头插入一个元素
* pop_front();//从容器开头移除第一个元素
* insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
* insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
* insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
* clear();//移除容器的所有数据
* erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
* erase(pos);//删除pos位置的数据，返回下一个数据的位置。
* remove(elem);//删除容器中所有与elem值匹配的元素。
*/
void test01()
{
list<int> l1;
l1.push_back(1);//尾插
l1.push_back(2);
l1.push_back(3);
l1.push_front(4);//头插
l1.push_front(5);
l1.push_front(6);
printList(l1);//6 5 4 1 2 3
l1.pop_back();
l1.pop_front();
printList(l1);//5 4 1 2
}
void test02()
{
list<int> l1;
l1.push_back(1);
l1.push_back(2);
l1.push_back(3);
l1.push_back(4);// 1 2 3 4
list<int>::const_iterator it = l1.begin();
it++;
it++;// it指向3
l1.insert(it, 5);//在3前插入5
printList(l1);//1 2 5 3 4
l1.insert(it, 3, 100);//在3前插入3个100
printList(l1);//1 2 5 100 100 100 3 4
list<int> l2;
l2.push_back(29);
l2.push_back(30);
l2.push_back(31);
l1.insert(it, l2.begin(), l2.end());//在3前插入l2
printList(l1);//1 2 5 100 100 100 29 30 31 3 4
l1.remove(100);//删除list中的全部100
printList(l1);//1 2 5 29 30 31 3 4
l1.erase(it, l1.end());//删除3以及之后的数据
printList(l1);//1 2 5 29 30 31
//cout << *it << endl;// 会报错,因为以及删除了元素3,所以3对应的迭代器已经失效
}
void test03()
{
list<int> l1;
l1.push_back(1);
l1.push_back(2);
l1.push_back(3);
l1.push_back(4);// 1 2 3 4
list<int>::const_iterator it = l1.begin();
it++;
it++;// it指向3
list<int>::const_iterator it2 = l1.erase(it);//删除3,并且返回下一个数据的位置
printList(l1);//1 2 4
cout << *it2 << endl; // 4
l1.clear();//清空lis
printList(l1);
}
int main()
{
//test01();
//test02();
test03();
return 0;
}
172 list数据存取
#include<iostream>
#include<list>
#include "MyPrint.h"
using namespace std;
/*
list数据存取
front
back
注意 :
1. list不支持at(0) 访问数据
2. list不支持[]访问数据
3. list的迭代器是双向迭代器,不可以进行跳跃访问,即使 it + 1 也是错误的,因为根本就没有为双向迭代器进行+的运算符
重载
*/
void test01()
{
list<int> l1;
l1.push_back(1);
l1.push_back(2);
l1.push_back(3);
l1.push_back(4);
cout << l1.back() << endl; //4
cout << l1.front() << endl; // 1
list<int>::const_iterator it = l1.begin();
//it = it + 1;
}
int main() {
test01();
return 0;
}
173 list反转和排序
#include<iostream>
#include<list>
#include "MyPrint.h"
using namespace std;
/*
list反转和排序 : 将容器中的元素反转,以及将容器中的数据进行排序
reverse();
sort();
sort(MyCompare)
*/
bool myCompare(int num1, int num2)
{
//降序 就是第一个数 > 第二个数
return num1 > num2;
}
void test01()
{
list<int> l1;
l1.push_back(1);
l1.push_back(5);
l1.push_back(2);
l1.push_back(3);
l1.push_back(16);
l1.push_back(7);
l1.push_back(4);
l1.push_back(8);
l1.push_back(12);
cout << "反转前 : " << endl;
printList(l1);
cout << "反转后 : " << endl;
l1.reverse();
printList(l1);
cout << "排序后 : " << endl;
/*
#include<algorithm>
sort(l1,begin(),l1.end())
是错误的
所有不支持随机访问迭代器的容器,都不可以使用#include<algorithm>的标准算法
不支持随机访问迭代器的容器,内部会提供对应的一些算法
*/
l1.sort(); // 默认排序规则,从小到大
printList(l1);
/*
反转前 :
1 5 2 3 16 7 4 8 12
反转后 :
12 8 4 7 16 3 2 5 1
排序后 :
1 2 3 4 5 7 8 12 16
*/
l1.sort(myCompare);
printList(l1); //16 12 8 7 5 4 3 2 1
}
int main() {
test01();
return 0;
}
174 排序案例
#include<iostream>
#include<list>
#include "MyPrint.h"
using namespace std;
/*
排序案例 :
案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高
排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序
*/
class Person
{
public:
string name;
int age;
int height;
Person(string name, int age, int height)
{
this->age = age;
this->height = height;
this->name = name;
}
};
bool myCompare(Person& p1, Person& p2)
{
if (p1.age == p2.age)
{
return p1.height > p2.height;
}
else
{
return p1.age < p2.age;
}
}
int main() {
Person p1("何佳乐", 18, 191);
Person p2("吴超", 22, 181);
Person p3("曹越", 14, 183);
Person p4("武文强", 22, 175);
Person p5("裴要", 14, 173);
list<Person> l1;
l1.push_back(p1);
l1.push_back(p2);
l1.push_back(p3);
l1.push_back(p4);
l1.push_back(p5);
l1.sort(myCompare);
for (list<Person>::const_iterator it = l1.begin(); it != l1.end(); it++)
{
cout << "name = " << it->name << "\tage = " << it->age << "\theight = " << it->height << endl;
}
/*
name = 曹越 age = 14 height = 183
name = 裴要 age = 14 height = 173
name = 何佳乐 age = 18 height = 191
name = 吴超 age = 22 height = 181
name = 武文强 age = 22 height = 175
*/
return 0;
}
175 set和multiset容器
#include<iostream>
using namespace std;
/*
set和multiset容器
1. set基本概念 : 所有元素都会在插入的时候自动排序
2. 本质 : set/multiset属于关联式容器,底层结构是二叉树实现
3. set和multiset区别 :
1. set不允许容器有重复的元素
2. multiset允许容器有重复的元素
*/
int main() {
return 0;
}
176 set构造和赋值
#include<iostream>
#include<set>
#include "MyPrint.h"
using namespace std;
/*
set构造和赋值
set<T> st;
set(const set& st);
赋值 : 重载等号运算符
*/
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(12);
s1.insert(11);
s1.insert(9);
printSet(s1);//9 10 11 12
set<int> s2 = s1;
set<int> s3(s1);
printSet(s2);//9 10 11 12
printSet(s3);//9 10 11 12
}
int main() {
test01();
return 0;
}
178 set大小和交换
#include<iostream>
#include "MyPrint.h"
using namespace std;
/*
set大小和交换
size
empty
swap(st)
*/
void test01()
{
set<int> s1;
s1.insert(1);
s1.insert(2);
s1.insert(3);
s1.insert(4);
cout << "size = " << s1.size() << endl;//4
cout << "s1 is empty ? " << s1.empty() << endl;//0
set<int> s2;
s2.insert(101);
s2.insert(102);
s2.insert(103);
s2.insert(104);
printSet(s1);//1 2 3 4
printSet(s2);
s1.swap(s2);
printSet(s1);//101 102 103 104
printSet(s2);
}
int main() {
test01();
return 0;
}
179 set插入和删除
#include<iostream>
#include "MyPrint.h"
using namespace std;
/*
set插入和删除
* `insert(elem);` //在容器中插入元素。
* `clear();` //清除所有元素
* `erase(pos);` //删除pos迭代器所指的元素，返回下一个元素的迭代器。
* `erase(beg, end);` //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
* `erase(elem);` //删除容器中值为elem的元素。
*/
void test01()
{
set<int> s1;
//插入
s1.insert(10);
s1.insert(40);
s1.insert(30);
s1.insert(20);
printSet(s1);
//删除
set<int>::iterator it = s1.begin();
it++;
set<int>::iterator it2 = s1.erase(it);//删除it指向的20,并返回下一个元素的迭代器
printSet(s1);//10 30 40
cout << *it2 << endl; //30
set<int>::iterator it3 = s1.begin();
it3++;
s1.erase(it3, s1.end());
printSet(s1);//10
s1.insert(3);
s1.insert(3);//set不允许值重复,所以会只有一个3存入
s1.insert(2);
s1.insert(5);
printSet(s1);//2 3 5 10
s1.erase(3);
printSet(s1);//2 5 10
}
int main() {
test01();
return 0;
}
180 set查找和统计
#include<iostream>
#include "MyPrint.h"
using namespace std;
/*
set查找和统计 : 对set容器进行查找数据以及统计数据
find(key) //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key) //统计key的元素个数（对于set，结果为0或者1）
*/
void test01()
{
set<int> s1;
s1.insert(1);
s1.insert(2);
s1.insert(3);
s1.insert(4);
cout << *s1.find(4) << endl;//4
//cout << *s1.find(5) << endl;//报错,end迭代器指针无法解引用
cout << "the number of 1 is " << s1.count(1) << endl; //1
}
void test02()
{
}
int main() {
test01();
return 0;
}
181 set和multiset的区别
#include<iostream>
#include "MyPrint.h"
using namespace std;
/*
set和multiset的区别
1. set不可以有重复值,multiset可以有
2. set插入数据的同时会返回pair插入结果,表示插入是否成功,而multiset返回的是迭代器
3. multiset不会检测数据,因此可以插入重复数据
*/
void test01()
{
set<int> s1;
pair < set<int>::iterator, bool> ret = s1.insert(10);
if (ret.second)
{
cout << "插入成功" << endl;
}
else
{
cout << "插入失败" << endl;
}
ret = s1.insert(10);
if (ret.second)
{
cout << "插入成功" << endl;
}
else
{
cout << "插入失败" << endl;
}
}
void test02()
{
multiset<int> mset;
//pair<multiset<int>::iterator, bool> ref = mset.insert(10);//报错,因为multiset返回的是迭代器
mset.insert(10);
mset.insert(10);
mset.insert(10);
printMultiset(mset);
}
int main() {
//test01();
test02();
return 0;
}
182 pair对组创建
#include<iostream>
using namespace std;
/*
pair对组创建 :
功能描述 : 成对出现的数据,利用对组可以返回两个数据
两种创建方式 :
* `pair<type, type> p ( value1, value2 );`
* `pair<type, type> p = make_pair( value1, value2 );`
*/
void test01()
{
pair<string, int> p("何佳乐", 18);
/*
注意 : first和second是属性而不是成员函数
*/
cout << "name = " << p.first << endl;
cout << "age = " << p.second << endl;
pair<string, int> p2 = make_pair("zhangsan", 22);
cout << "name = " << p2.first << endl;
cout << "age = " << p2.second << endl;
}
int main() {
test01();
return 0;
}
183 set容器排序
#include<iostream>
#include "MyPrint.h"
using namespace std;
/*
set容器排序
学习目标 : set容器默认排序规则为从小到大,掌握如何改变排序规则
主要技术点 : 利用仿函数,可以改变排序规则
vs2019中,仿函数需要加const
const，即括号后面的 const，它的作用是 使得该函数可以被 const 对象所调用
对于set存储自定义数据类型,必须要自定义排序规则
*/
class myCompare
{
public:
bool operator()(int v1, int v2)const
{
return v1 > v2;
}
};
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->age = age;
this->name = name;
}
};
class comparePerson
{
public:
bool operator()(const Person& p1, const Person& p2)const
{
return p1.age > p2.age;
}
};
//利用仿函数可以指针set容器的排序规则
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(20);
s1.insert(50);
s1.insert(30);
s1.insert(40);
printSet(s1);
//指定排序规则为从大到小
set<int, myCompare> s2;
s2.insert(10);
s2.insert(20);
s2.insert(50);
s2.insert(30);
s2.insert(40);
for (set<int, myCompare>::iterator it = s2.begin(); it != s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//自定义数据类型排序
void test02()
{
//自定义的数据类型,都会指定排序规则,因为comparePerson是在<>中的,传入的应该是参数类型,所以不用加括号
set<Person,comparePerson> s;
Person p1("zhangsan", 18);
Person p2("lisi", 24);
Person p3("zhaosi", 19);
Person p4("wangwu", 11);
s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);
for (set<Person>::iterator it = s.begin(); it != s.end(); it++)
{
cout << "name = " << it->name << "\tage = " << it->age << endl;
}
}
int main() {
//test01();
test02();
return 0;
}
184 map和multimap容器
#include<iostream>
#include<map>
#include "MyPrint.h"
using namespace std;
/*
map和multimap容器
1. map基本概念 :
1. 简介 :
map中所有元素都是pair
pair中第一个元素是key(键值),起到索引作用,第二个值是value(实值)
所有元素都会根据元素的键值自动排序
2. 本质 :
map/multimap属于关联式容器,底层结构是二叉树实现的
3. 优点 :
可以根据key快速找到value
4. 和multimap的区别
1. map不允许容器中的key重复
2. mutlimap允许key重复
*/
//map容器构造和创建
void test01()
{
map<int, int> m;
//将匿名对组放入容器里面
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
m.insert(pair<int, int>(4, 40));
printMap(m);
//=重载
map<int, int> m2 = m;
printMap(m2);
//拷贝构造
map<int, int> m3(m2);
printMap(m3);
}
int main() {
test01();
return 0;
}
185 map
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
map大小和交换
size
empty
swap(m)
map插入(四种插入方式)和删除
- `insert(elem);` //在容器中插入元素。
- `clear();` //清除所有元素
- `erase(pos);` //删除pos迭代器所指的元素，返回下一个元素的迭代器。
- `erase(beg, end);` //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
- `erase(key);` //删除容器中值为key的元素。
map查找和统计
- `find(key);` //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回map.end();
- `count(key);` //统计key的元素个数,对于map,结果为0/1
map容器排序
map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则
利用仿函数，可以改变排序规则
*/
class mycompare
{
public:
bool operator()(int v1, int v2)const
{
return v1 > v2;
}
};
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name = name;
this->age = age;
}
};
class PersonCompare
{
public:
bool operator()(const Person& p1, const Person& p2)const
{
return p1.age > p2.age;
}
};
//大小和交换
void test01()
{
map<int, int> m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
m.insert(pair<int, int>(4, 40));
cout << "size = " << m.size() << endl;
cout << "map is empty ? = " << m.empty() << endl;
map<int, int> m2;
m2.insert(pair<int, int>(5, 50));
cout << "交换前 : " << endl;
printMap(m);
printMap(m2);
cout << "交换后 : " << endl;
m.swap(m2);
printMap(m);
printMap(m2);
}
//插入和删除
void test02()
{
map<int, int> m;
//第一种插入方式
m.insert(pair<int, int>(1, 10));
//第二种插入方式
m.insert(make_pair(2, 20));
//第三种插入方式
m.insert(map<int, int>::value_type(3, 30));
//第四种插入方式,不建议用来插入,可以用来访问,访问的时候要确定存在,否则如果不存在,会自动创建value为0的键值对插入
m[4] = 40;
cout << m[4] << endl;
//m.erase(m.begin());
//m.erase(m.begin(), m.end());
//m.clear();
printMap(m);
}
//查找和统计
void test03()
{
map<int, int> m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
m.insert(pair<int, int>(4, 40));
map<int,int>::iterator it = m.find(4); // 注意,查找的是key是否存在,根据key查找
cout << it->second << endl;
cout << m.count(1) << endl;
}
//map排序
void test04()
{
map<int, int, mycompare> m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
m.insert(pair<int, int>(4, 40));
for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
{
cout << "key = " << it->first << "\tvalue = " << it->second << endl;
}
map<Person, int, PersonCompare> m2;
m2.insert(pair<Person, int>(Person("hejiale", 18), 1));
m2.insert(pair<Person, int>(Person("zhangsan", 20), 1));
m2.insert(pair<Person, int>(Person("zhaosi", 30), 1));
for (map<Person, int>::const_iterator it = m2.begin(); it != m2.end(); it++)
{
cout << "name = " << it->first.name << "\tage = " << it->first.age << "\tvalue = " << it->second << endl;
}
}
int main() {
//test01();
//test02();
//test03();
test04();
return 0;
}
186 案例 - 员工分组
#include<iostream>
#include<ctime>
#include "MyPrint.h"
/*
常量的后面不要加分号; !!!!!
*/
#define MEISHU 1
#define CEHUA 2
#define YANFA 3
using namespace std;
/*
案例 - 员工分组
* 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
* 员工信息有: 姓名 工资组成；部门分为：策划、美术、研发
* 随机给10名员工分配部门和工资
* 通过multimap进行信息的插入 key(部门编号) value(员工)
* 分部门显示员工信息
*/
class Employee
{
public:
string name;
int salary;
Employee() {}
Employee(string name, int salary)
{
this->name = name;
this->salary = salary;
}
};
void createEmployeeVector(vector<Employee>& v)
{
string name_suffix = "ABCDEFGHIJ";
for (int i = 0; i < 10; i++)
{
Employee e;
e.name = "员工";
e.name += name_suffix[i];
e.salary = 0;
v.push_back(e);
}
}
void setGroupAndSalary(multimap<int, Employee>& m,vector<Employee>& v)
{
//首先,随机分配工资
for (vector<Employee>::iterator it = v.begin(); it != v.end(); it++)
{
int salary = rand() % 10000 + 10000; // 100000~19999
it->salary = salary;
}
/*for (vector<Employee>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "name = " << it->name << "\tsalary = " << it->salary << endl;
}*/
//之后,随机分配员工部门
for (int i = 0; i < v.size(); i++)
{
int deptId = rand() % 3 + 1; //1~3
m.insert(pair<int, Employee>(deptId, v[i]));
}
}
void showEmployeeInfo(multimap<int, Employee>& m)
{
multimap<int, Employee>::iterator it = m.begin();
cout << "美术 -- " << m.count(MEISHU) << "人" << endl;
if (m.find(MEISHU)!=m.end())
{
//说明有员工分配到美术部门
int count = m.count(MEISHU);
for (int i = 0; i < count; i++,it++)
{
cout << "deptId = " << it->first << "\tname = " << it->second.name << "\tsalary = " << it->second.salary << endl;
}
cout << endl;
}
cout << "策划 -- " << m.count(CEHUA) << "人" << endl;
if (m.find(CEHUA) != m.end())
{
//说明有员工分配到策划部门
int count = m.count(CEHUA);
for (int i = 0; i < count; i++, it++)
{
cout << "deptId = " << it->first << "\tname = " << it->second.name << "\tsalary = " << it->second.salary << endl;
}
cout << endl;
}
cout << "研发 -- " << m.count(YANFA) << "人" << endl;
if (m.find(YANFA) != m.end())
{
//说明有员工分配到研发部门
int count = m.count(YANFA);
for (int i = 0; i < count; i++, it++)
{
cout << "deptId = " << it->first << "\tname = " << it->second.name << "\tsalary = " << it->second.salary << endl;
}
cout << endl;
}
}
int main() {
srand((unsigned int)time(NULL));
vector<Employee> v;
multimap<int, Employee> m;
//初始化创建10个员工
createEmployeeVector(v);
//给员工指派部门和工资
setGroupAndSalary(m,v);
//分部门输出员工消息
showEmployeeInfo(m);
return 0;
}
187 STL函数对象
#include<iostream>
using namespace std;
/*
STL函数对象:
概念 :
1. 重载函数调用操作符()的类,其对象常称之为函数对象
2. 函数对象使用重载的()的时候,行为类似于函数调用,所以也叫做仿函数
本质 :
函数对象(仿函数)本质是一个类,是一种数据类型,不是一个函数
函数对象的使用特点 :
1. 函数对象在使用的时候,可以像普通函数那样子调用,可以有参数,可以有返回值
2. 函数对象超出了普通函数的概念,函数对象可以有自己的状态
3. 函数对象可以作为参数传递
*/
class myAdd
{
public:
int operator()(int num1, int num2)
{
return num1 + num2;
}
};
//函数对象在使用的时候,可以像普通函数那样子调用,可以有参数,可以有返回值
void test01()
{
myAdd ma;
cout << ma(10, 100) << endl;
}
//函数对象超出普通函数的概念,可以有自己的状态
class MyPrint
{
public:
void operator()(string test)
{
cout << test << endl;
count++;
}
int count;//内部自己的状态,记录operator()调用次数
MyPrint()
{
this->count = 0;
}
};
void test02()
{
MyPrint mp;
mp("hello world");
mp("hello world");
mp("hello world");
mp("hello world");
cout << mp.count << endl;
}
//函数对象可以作为参数传递
void doPrint(MyPrint& mp,string test)
{
mp(test);
}
void test03()
{
MyPrint mp;
doPrint(mp, "c++");
}
int main() {
//test01();
//test02();
test03();
return 0;
}
188 一元谓词
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
谓词
1. 概念 :
返回bool类型的仿函数称之为谓词
如果operator接收一个参数,称之为一元谓词,如果接收两个参数,就是两元谓词
*/
class GreaterFive
{
public:
bool operator()(int val)
{
return val > 5;
}
};
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
//查找容器中大于5的数字
/*
find_if三个参数
1. first
2. last ,last和first负责提供区间
3. 谓词(pred)
GreaterFive()匿名函数对象
*/
vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
if (it == v.end())
{
cout << "未找到" << endl;
}
else
{
cout << "找到了大于5的数字为 : " << *it << endl;
}
}
int main() {
test01();
return 0;
}
189 二元谓词
#include<iostream>
#include "MyPrint.h"
#include<algorithm>
using namespace std;
/*
二元谓词
*/
class myCompare
{
public:
bool operator()(int num1, int num2)
{
return num1 > num2;
}
};
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(4);
v.push_back(2);
v.push_back(3);
v.push_back(5);
sort(v.begin(), v.end());
printVector(v);
//使用函数对象 改变算法策略,变排序规则为降序
sort(v.begin(),v.end(),myCompare());
printVector(v);
}
int main() {
test01();
return 0;
}
190 内建函数对象
#include<iostream>
#include<functional>
using namespace std;
/*
内建函数对象
1. 概念 : STL内建了一些函数对象
2. 分类 :
1. 算术仿函数
2. 关系仿函数
3. 逻辑仿函数
3. 用法 :
1. 这些仿函数产生的对象,用法和一般函数完全相同
2. 使用内建函数对象,需要引入头文件 #include<functional>
算术仿函数
1. 功能 : 实现四则运算,其中negate是一元运算,其他都是二元运算
2. 仿函数原型 :
* `template<class T> T plus<T>` //加法仿函数
* `template<class T> T minus<T>` //减法仿函数
* `template<class T> T multiplies<T>` //乘法仿函数
* `template<class T> T divides<T>` //除法仿函数
* `template<class T> T modulus<T>` //取模仿函数
* `template<class T> T negate<T>` //取反仿函数
*/
//negate一元仿函数 取反仿函数
void test01()
{
negate<int> n;
cout << n(50) << endl;//-50
}
//plus二元仿函数 加法仿函数
void test02()
{
plus<int> p;
cout << p(10, 20) << endl;
}
int main() {
//test01();
test02();
return 0;
}
191 关系仿函数
#include<iostream>
#include<functional>
#include "MyPrint.h"
#include<algorithm>
using namespace std;
/*
关系仿函数
实现关系对比
* `template<class T> bool equal_to<T>` //等于
* `template<class T> bool not_equal_to<T>` //不等于
* `template<class T> bool greater<T>` //大于
* `template<class T> bool greater_equal<T>` //大于等于
* `template<class T> bool less<T>` //小于
* `template<class T> bool less_equal<T>` //小于等于
*/
//大于
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(3);
v.push_back(2);
v.push_back(4);
v.push_back(5);
printVector(v);
//想降序
sort(v.begin(), v.end(), greater<int>());
}
int main() {
test01();
return 0;
}
192 逻辑仿函数
#include<iostream>
#include "MyPrint.h"
#include<algorithm>
#include<functional>
using namespace std;
/*
逻辑仿函数
实现逻辑运算
* `template<class T> bool logical_and<T>` //逻辑与
* `template<class T> bool logical_or<T>` //逻辑或
* `template<class T> bool logical_not<T>` //逻辑非
*/
void test01()
{
vector<bool> v;
v.push_back(true);
v.push_back(false);
v.push_back(true);
v.push_back(false);
printVector(v);
//将容器v搬运到v2中,搬运的同时进行取反操作,比如v1的true到v2变成false,这个时候就需要内建函数对象的逻辑仿函数的逻辑非
vector<bool> v2;
v2.resize(v.size());
transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
printVector(v2);
}
int main() {
test01();
return 0;
}
193 stl常用算法
#include<iostream>
#include "MyPrint.h"
#include<algorithm>
using namespace std;
/*
stl常用算法
1. 概述
* 算法主要是由头文件`<algorithm>` `<functional>` `<numeric>`组成。
* `<algorithm>`是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等
* `<numeric>`体积很小，只包括几个在序列上面进行简单数学运算的模板函数
* `<functional>`定义了一些模板类,用以声明函数对象。
2. 常用遍历算法
for_each 遍历容器
transform 搬运容器到另一个容器中
3. for_each
for_each(iterator beg, iterator end, _func);
// 遍历算法 遍历容器元素
// beg 开始迭代器
// end 结束迭代器
// _func 函数或者函数对象
*/
void print01(int val)
{
cout << val << endl;
}
class print02
{
public:
void operator()(int val)
{
cout << val;
}
};
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
//这里传入print01是函数指针,函数名就是函数指针,所以不需要也不能加括号
for_each(v.begin(), v.end(), print01);
for_each(v.begin(), v.end(), print02());
}
int main() {
test01();
return 0;
}
194 transform容器搬运
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
transform容器搬运
* transform(iterator beg1, iterator end1, iterator beg2, _func);
//beg1 源容器开始迭代器
//end1 源容器结束迭代器
//beg2 目标容器开始迭代器
//_func 函数或者函数对象
*/
class Transfrom
{
public:
//会自动将容器中的元素作为参数传递给operator,所以这里val实参的类型必须和vector的泛型一致
int operator()(int v)
{
return v+100;
}
};
class MyPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
vector<int> vTarget;//目标容器
vTarget.resize(v.size());//目标容器需要提前开辟空间,否则是无法搬运的
transform(v.begin(), v.end(), vTarget.begin(), Transfrom());
for_each(vTarget.begin(), vTarget.end(), MyPrint());
}
int main() {
test01();
return 0;
}
195 find
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
- `find` //查找元素
- `find_if` //按条件查找元素
- `adjacent_find` //查找相邻重复元素
- `binary_search` //二分查找法
- `count` //统计元素个数
- `count_if` //按条件统计元素个数
1. find : 查找指定元素,找到返回指定元素的 迭代器,找不到返回结束迭代器end();
find(iterator beg, iterator end, value);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素
注意 : find函数底层会使用==,所以如果是查找自定义数据类型,就必须针对该数据类型重载运算符==
*/
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name = name;
this->age = age;
}
bool operator==(const Person& p2)
{
if (this->age == p2.age && this->name == p2.name)
{
return true;
}
else {
return false;
}
}
};
//查找内置数据类型
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
vector<int>::iterator it = find(v.begin(), v.end(), 3);
if (it == v.end())
{
cout << "没有找到" << endl;
}
else
{
cout << "找到了" << endl;
}
cout << *it << endl;
}
//查找自定义数据类型
void test02()
{
vector<Person> v;
v.push_back(Person("hejiale", 20));
v.push_back(Person("zhangsan", 11));
v.push_back(Person("lisi", 14));
v.push_back(Person("wangwu", 22));
vector<Person>::iterator it = find(v.begin(), v.end(), Person("hejiale", 20));
if (it == v.end())
{
cout << "没有找到" << endl;
}
else
{
cout << "找到了 name = " << it->name << "\tage = " << it->age << endl;
}
}
int main() {
//test01();
test02();
return 0;
}
196 find_if
#include<iostream>
#include "MyPrint.h"
#include<algorithm>
using namespace std;
/*
find_if : 按条件查找元素
find_if(iterator beg, iterator end, _Pred);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 函数或者谓词（返回bool类型的仿函数）
*/
class GreaterFive
{
public:
bool operator()(int val)
{
return val > 5;
}
};
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name = name;
this->age = age;
}
};
class Greater20
{
public:
bool operator()(const Person& p)
{
return p.age > 20;
}
};
//内置数据类型
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
vector<int>::iterator it = find_if(v.begin(),v.end(),GreaterFive());
if (it == v.end())
{
cout << "没有找到" << endl;
}
else
{
cout << "找到了" << *it << endl;
}
}
//自定义数据类型
void test02()
{
vector<Person> v;
v.push_back(Person("hejiale", 20));
v.push_back(Person("zhangsan", 12));
v.push_back(Person("lisi", 29));
v.push_back(Person("wangwu", 22));
//找年龄大于20的人
vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
if (it == v.end())
{
cout << "没有找到" << endl;
}
else
{
cout << "找到了 name = " << it->name <<"\tage = " << it->age << endl;
}
}
int main() {
//test01();
test02();
return 0;
}
197 adjacent_find
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
adjacent_find : 查找相邻重复元素
adjacent_find(iterator beg, iterator end);
// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器,没有则返回end
// beg 开始迭代器
// end 结束迭代器
*/
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name = name;
this->age = age;
}
bool operator==(const Person& p2)
{
if (this->age == p2.age && this->name == p2.name)
{
return true;
}
else {
return false;
}
}
};
void test01()
{
vector<int> v;
v.push_back(0);
v.push_back(1);
v.push_back(1);
v.push_back(2);
v.push_back(0);
v.push_back(3);
v.push_back(3);
v.push_back(4);
vector<int>::iterator it = adjacent_find(v.begin(), v.end());
if (it == v.end())
{
cout << "没有找到" << endl;
}
else
{
cout << "找到了" << *it << endl;
}
}
void test02()
{
vector<Person> v;
v.push_back(Person("aaa", 18));
v.push_back(Person("aaa", 19));
v.push_back(Person("bbb", 18));
v.push_back(Person("bbb", 19));
v.push_back(Person("bbb", 19));
v.push_back(Person("ccc", 18));
vector<Person>::iterator it = adjacent_find(v.begin(), v.end());
if (it == v.end())
{
cout << "没有找到" << endl;
}
else
{
cout << "找到了 name = " << it->name << "\tage = " << it->age << endl;
}
}
int main() {
//test01();
test02();
return 0;
}
198 binary_search
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
binary_search : 利用二分查找的方式,查找指定元素是否存在
bool binary_search(iterator beg, iterator end, value);
// 查找指定的元素，查到 返回true 否则false
// 注意: 在 无序序列 中不可用**
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素
*/
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
//查找容器中是否有9元素
bool ref = binary_search(v.begin(), v.end(), 9);
cout << ref << endl; // true;
}
//如果查找的是无需序列,虽然不会报错,但是将不能保证查找结果的正确
void test02()
{
vector<int> v;
v.push_back(1);
v.push_back(9);
v.push_back(5);
v.push_back(2);
v.push_back(3);
bool ref = binary_search(v.begin(), v.end(), 9);
cout << ref << endl; // false,返回的结果很明显是错误的
}
int main() {
//test01();
test02();
return 0;
}
199 count
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
count : 统计元素个数
int count(iterator beg, iterator end, value);
// 统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// value 统计的元素
*/
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name = name;
this->age = age;
}
bool operator==(const Person& p)
{
if (this->name == name && this->age == age)
{
return true;
}
else
{
return false;
}
}
};
//内置数据类型
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(40);
v.push_back(30);
v.push_back(40);
v.push_back(20);
v.push_back(40);
cout << count(v.begin(), v.end(), 40) << endl;
}
//自定义数据类型
void test02()
{
vector<Person> v;
v.push_back(Person("hejiale", 20));
v.push_back(Person("hejiale", 20));
v.push_back(Person("hejiale", 20));
v.push_back(Person("hejiale", 20));
v.push_back(Person("hejiale", 20));
v.push_back(Person("hejiale", 20));
v.push_back(Person("hejiale", 20));
cout << count(v.begin(), v.end(), Person("hejiale", 20)) << endl;
}
int main() {
//test01();
test02();
return 0;
}
200 count_if
#include<iostream>
#include "MyPrint.h"
#include<algorithm>
using namespace std;
/*
count_if : 按条件统计元素个数
count_if(iterator beg, iterator end, _Pred);
// 按条件统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词
*/
//内置数据类型
class GreaterTwo
{
public:
bool operator()(int val)
{
return val > 2;
}
};
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(4);
v.push_back(3);
v.push_back(2);
v.push_back(4);
v.push_back(2);
cout << count_if(v.begin(), v.end(), GreaterTwo()) << endl;
}
//自定义数据类型
class Person
{
public:
string name;
int age;
Person(string name,int age)
{
this->name = name;
this->age = age;
}
};
class PersonPred
{
public:
bool operator()(const Person& p)
{
if (p.name == "hejiale" && p.age > 14)
{
return true;
}
return false;
}
};
void test02()
{
vector<Person> v;
v.push_back(Person("hejiale", 18));
v.push_back(Person("zhangsan", 20));
v.push_back(Person("hejiale", 14));
v.push_back(Person("hejiale", 19));
v.push_back(Person("hejiale", 14));
v.push_back(Person("hejiale", 12));
cout << count_if(v.begin(), v.end(), PersonPred()) << endl; // 2
}
int main() {
//test01();
test02();
return 0;
}
201 sort
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
#include<functional>
using namespace std;
/*
排序算法
- `sort` //对容器内元素进行排序
- `random_shuffle` //洗牌 指定范围内的元素随机调整次序
- `merge ` // 容器元素合并，并存储到另一容器中
- `reverse` // 反转指定范围的元素
sort : 对容器内元素进行排序
sort(iterator beg, iterator end, _Pred);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词
*/
void myprint(int val)
{
cout << val << " ";
}
//默认排序-升序
void test01()
{
vector<int> v;
v.push_back(2);
v.push_back(3);
v.push_back(2);
v.push_back(1);
v.push_back(3);
v.push_back(7);
v.push_back(9);
v.push_back(4);
v.push_back(3);
sort(v.begin(),v.end());
for_each(v.begin(), v.end(), myprint);
}
class myPred
{
public:
bool operator()(int num1, int num2)
{
return num1 > num2;
}
};
//降序
void test02()
{
vector<int> v;
v.push_back(4);
v.push_back(3);
v.push_back(1);
v.push_back(5);
v.push_back(7);
v.push_back(2);
v.push_back(6);
//sort(v.begin(), v.end(), myPred());
sort(v.begin(), v.end(), greater<int>());
for_each(v.begin(), v.end(), myprint);
}
int main() {
//test01();
test02();
return 0;
}
202 random_shuffle
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
#include<ctime>
using namespace std;
/*
random_shuffle : 指定范围内的元素随机调整次序
`random_shuffle(iterator beg, iterator end);
// 指定范围内的元素随机调整次序
// beg 开始迭代器
// end 结束迭代器
*/
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
random_shuffle(v.begin(), v.end());
printVector(v);
}
int main() {
srand((unsigned int)time(NULL));
test01();
return 0;
}
203 merge
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
merge : 两个容器元素合并,并存储到另一个容器里面
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 容器元素合并，并存储到另一容器中
// 注意: 两个容器必须是**有序的**
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
注意 :
1. 目标容器需要提前开辟空间
2. 合并的两个容器必须是有序的,合并之后的容器也是有序的
*/
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
v2.push_back(i + 10);
}
// 注意 : 目标容器需要提前开辟空间
vector<int> target;
target.resize(v1.size() + v2.size());
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), target.begin());
printVector(target);
}
int main() {
test01();
return 0;
}
204 reverse
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
reverse : 将容器内元素反转
reverse(iterator beg, iterator end);
// 反转指定范围的元素
// beg 开始迭代器
// end 结束迭代器
*/
void test01()
{
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
reverse(v.begin(), v.end());
printVector(v);
}
int main() {
test01();
return 0;
}
205 copy
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
常用拷贝和替换算法
- `copy` // 容器内指定范围的元素拷贝到另一容器中
- `replace` // 将容器内指定范围的旧元素修改为新元素
- `replace_if ` // 容器内指定范围满足条件的元素替换为新元素
- `swap` // 互换两个容器的元素
copy : 容器内指定范围的元素拷贝到另一个容器里面
copy(iterator beg, iterator end, iterator dest);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// dest 目标起始迭代器
注意 : 目标容器需要提前开辟好空间
*/
void test01()
{
vector<int> v;
vector<int> target;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
target.resize(v.size());
copy(v.begin(), v.end(), target.begin());
printVector(target);
}
int main() {
test01();
return 0;
}
206 replace
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
replace : 将容器内指定范围的旧元素修改为新元素
replace(iterator beg, iterator end, oldvalue, newvalue);
// 将区间内旧元素 替换成 新元素
// beg 开始迭代器
// end 结束迭代器
// oldvalue 旧元素
// newvalue 新元素
*/
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(6);
v.push_back(3);
v.push_back(3);
v.push_back(9);
v.push_back(2);
v.push_back(4);
v.push_back(6);
v.push_back(3);
replace(v.begin(), v.end(), 1, 2);
printVector(v);
}
int main() {
test01();
return 0;
}
207 replace_if
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
replace_if : 将区间内满足条件的元素,替换成指定的元素
函数原型 : replace_if(iterator beg, iterator end, _pred, newvalue);
// 按条件替换元素，满足条件的替换成指定元素
// beg 开始迭代器
// end 结束迭代器
// _pred 谓词
// newvalue 替换的新元素
*/
class Person
{
public:
string name;
int age;
Person(string name, int age)
{
this->name = name;
this->age = age;
}
};
class myPred
{
public:
bool operator()(const Person& p)
{
if (p.name == "hejiale" && p.age == 19)
{
return true;
}
return false;
}
};
void myprint(const Person& p)
{
cout << "name = " << p.name << "\tage = " << p.age << endl;
}
void test01()
{
vector<Person> v;
v.push_back(Person("hejiale", 19));
v.push_back(Person("hejiale", 12));
v.push_back(Person("zhangsan", 21));
v.push_back(Person("lisi", 13));
v.push_back(Person("hejiale", 19));
replace_if(v.begin(), v.end(), myPred(), Person("HJL", 22));
for_each(v.begin(), v.end(), myprint);
/*
name = HJL age = 22
name = hejiale age = 12
name = zhangsan age = 21
name = lisi age = 13
name = HJL age = 22
*/
}
int main() {
test01();
return 0;
}
208 swap
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
swap : 互换两个容器的元素
函数原型 : swap(container c1, container c2);
// 互换两个容器的元素
// c1容器1
// c2容器2
注意 : swap交换容器的时候,注意交换的容器必须要同种类型
*/
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
v2.push_back(i + 10);
}
cout << "交换前 : " << endl;
printVector(v1);
printVector(v2);
cout << "交换后 : " << endl;
swap(v1, v2);
printVector(v1);
printVector(v2);
}
int main() {
test01();
return 0;
}
209 accumulate
#include<iostream>
#include"MyPrint.h"
#include<numeric>
using namespace std;
/*
常用算术生成算法 : 属于小型算法,使用时包含的头文件为 #include<numeric>
算法简介 :
1. accumulate //计算容器内元素累计总和
2. fill //向容器内添加元素
accumulate : 计算容器内元素累计总和
`accumulate(iterator beg, iterator end, value);
// 计算容器元素累计总和
// beg 开始迭代器
// end 结束迭代器
// value 起始值
*/
void test01()
{
vector<int> v;
for (int i = 1; i <= 10; i++)
{
v.push_back(i);
}
cout << accumulate(v.begin(), v.end(), 0) << endl;
}
int main() {
test01();
return 0;
}
210 fill
#include<iostream>
#include<numeric>
#include "MyPrint.h"
using namespace std;
/*
fill : 向容器中填充指定元素
`fill(iterator beg, iterator end, value);
// 向容器中填充元素
// beg 开始迭代器
// end 结束迭代器
// value 填充的值
总结 : 利用fill可以将容器区间内元素填充为 指定的值
*/
void test01()
{
vector<int> v;
v.resize(20);// 记得提前开辟空间
fill(v.begin(), v.end(), 10);
printVector(v);
}
int main() {
test01();
return 0;
}
211 set_intersection
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
常用集合算法 :
- `set_intersection` // 求两个容器的交集
- `set_union` // 求两个容器的并集
- `set_difference ` // 求两个容器的差集
set_intersection : 求两个容器交集
iterator set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的交集
// **注意:两个集合必须是有序序列**
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
总结 :
1. 求交集的两个集合必须的有序序列
2. 目标容器开辟空间需要从**两个容器中取小值**
3. set_intersection返回值既是交集中最后一个元素的位置
*/
void myprint(int val)
{
cout << val << " ";
}
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(6);
v.push_back(10);
v.push_back(13);
v.push_back(19);
v.push_back(22);
v.push_back(24);
v.push_back(26);
v.push_back(33);
vector<int> v2;
v2.push_back(1);
v2.push_back(7);
v2.push_back(8);
v2.push_back(13);
v2.push_back(15);
v2.push_back(17);
v2.push_back(21);
v2.push_back(23);
v2.push_back(30);
v2.push_back(33);
v2.push_back(34);
vector<int> target;
target.resize(min(v.size(), v2.size()));
vector<int>::iterator it = set_intersection(v.begin(), v.end(), v2.begin(), v2.end(), target.begin());
for_each(target.begin(), it, myprint);
cout << endl;
}
int main() {
test01();
return 0;
}
212 set_union
#include<iostream>
#include "MyPrint.h"
#include<algorithm>
using namespace std;
/*
set_union : 求两个集合的并集
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的并集
// **注意:两个集合必须是有序序列**
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
注意 :
- 求并集的两个集合必须是有序序列
- 目标容器开辟空间需要**两个容器相加**
- set_union返回值既是并集中最后一个元素的位置
*/
void myprint(int val)
{
cout << val << " ";
}
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(6);
v.push_back(10);
v.push_back(13);
v.push_back(19);
v.push_back(22);
v.push_back(24);
v.push_back(26);
v.push_back(33);
vector<int> v2;
v2.push_back(1);
v2.push_back(7);
v2.push_back(8);
v2.push_back(13);
v2.push_back(15);
v2.push_back(17);
v2.push_back(21);
v2.push_back(23);
v2.push_back(30);
v2.push_back(33);
v2.push_back(34);
vector<int> target;
target.resize(v.size() + v2.size());
vector<int>::iterator it = set_union(v.begin(), v.end(), v2.begin(), v2.end(), target.begin());
for_each(target.begin(), it, myprint);
}
int main() {
test01();
return 0;
}
213 set_difference
#include<iostream>
#include<algorithm>
#include "MyPrint.h"
using namespace std;
/*
set_difference : 求两个集合的差集
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的差集
// **注意:两个集合必须是有序序列**
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
注意 :
- 求差集的两个集合必须的有序序列
- 目标容器开辟空间需要从**两个容器取较大值**
- set_difference返回值既是差集中最后一个元素的位置
*/
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i + 5);
}
printVector(v1);
printVector(v2);
vector<int> vTarget;
//取两个里面较大的值给目标容器开辟空间
vTarget.resize(max(v1.size(), v2.size()));
//返回目标容器的最后一个元素的迭代器地址
cout << "v1与v2的差集为： " << endl;
vector<int>::iterator itEnd =
set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
cout << "v2与v1的差集为： " << endl;
itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
}
int main() {
test01();
return 0;
}