目录
</pre>
赋值运算符有=，+=，-=，*=，/=，%=<br>作用：例如a+=2相当于a=a+2，其他以此类推
</pre>
<br>
=====比较运算符=====
运算符 含义 例子 结果
== 相等 4==3 0
!= 不相等 4!=3 1
< 小于 4<3 0
> 大于 4>3 1
<= 小于等于 4<=3 0
>= 大于等于 4>=3 1
</pre>
=====逻辑运算符=====
!为逻辑非，例如有事件a，如果a为真，则!a为假（注：在c++中，除了0以为的数字都为真，int a = 10，则!a = 0,!!a = 1）<br>&&为逻辑与，例如有事件a和事件b，如果a和b同时为真，则结果为真<br>||为逻辑或，例如有事件a和事件b，如果a或b为真，则a||b为真
=====程序流程结构=====
c++支持最基本的三种程序结构有三种，分别为顺序结构、选择结构和循环结构<br>1、顺序结构：程序按顺序执行，不发生跳转<br>2、选择结构：依据条件是否满足，有选择的执行相应功能<br>3、循环结构：依据条件是否满足，循环多次执行某个代码
======if语句======
单行格式if语句：if（条件） {条件满足时执行的语句}<br>多行格式if语句：if（条件） {条件满足时执行的语句} else{条件不满足时执行的语句}<br>多条件的if语句<br>嵌套if语句：if条件中再加if语句
//多条件if语句
#include<iostream>
using namespace std;
int main()
{
//输入一个分数，大于等于500分视为考上一本大学，大于等于300分视为考上二本大学，否则视为没有考上大学
int score = 0;
cout << "请输入您的分数" << endl;
cin >> score;
cout << "您输入的分数是" << score << endl;
if (score >= 500)
{
cout << "恭喜您考上一本大学" << endl;
if (score > 700)
{
cout << "您能考入A大学" << endl;
}
else if (score > 650)
{
cout << "您能考入B大学" << endl;
}
else if (score > 600)
{
cout << "您能考入C大学" << endl;
}
}
else if (score >= 300)
{
cout << "恭喜您考上二本大学" << endl;
}
else
{
cout << "很遗憾您没有考上大学" << endl;
}
system("pause");
return 0;
}
获取到一个三位数的个位、十位、百位的方法：<br>#将一个三位数取模于10就得到了这个三位数的个位；<br>#将一个三位数先除以10，再取模于10得到了这个三位数的十位；（在c++中，两个整数相除还是一个整数，小数部分去掉）<br>#将一个三位数除以100就得到了这个三位数的百位。
<br>
查看ASCII值的代码：cout<<(int)变量<<endl;
ASCII值：a对应97，A对应65，依次递推
=====转义字符=====
常用的转义字符：
*\n是换行符<br>*\t是水平制表符<br>*\\是一个反斜线字符“\”
=====三目运算符=====
作用：通过三目运算符实现简单的判断<br>语法：表达式1?表达式2:表达式3（注：在c++中三目运算符返回的变量，可以继续赋值）
//三目运算符
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
(a > b ? a : b) = 100;
cout <<"a="<< a << endl; //a=10
cout << "b=" << b << endl; //b=100
system("pause");
return 0;
}
=====switch语句=====
作用：执行多条件分支语句<br>语法：switch（表达式）<br>{<br>case结果1：执行语句；break；<br>case结果2：执行语句；break；<br>....<br>default：执行语句；break；<br>}
//switch语句的练习
#include<iostream>
using namespace std;
int main() {
//switch语句
int score = 0;
cout << "请给电影进行打分" << endl;
cin >> score;
cout << "您打的分数为：" << score << endl;
switch (score)
{
case 10:
cout << "您认为是经典电影" << endl;
break; //用于退出当前分支
case 9:cout << "您认为是经典电影" << endl; break;
case 7:cout << "您认为电影比较好" << endl; break;
case 6:cout << "您认为电影一般" << endl; break;
case 5:cout << "您认为电影一般" << endl; break;
default:cout << "您认为电影是烂片" << endl; break;
}
system("pause");
return 0;
}
=====循环结构=====
======while循环语句======
语法：<br>while（循环条件）<br>{循环语句}
//while循环语句
#include<iostream>
using namespace std;
int main(){
//while循环语句
int a = 0;
while (a < 10)
{
cout << a << endl;
a++;
}
system("pause");
return 0;
}
======补充小点======
rand（）%100表示0到99的随机数字；rand（）%100+1表示1到100的随机数字
=====do...while循环语句=====
语法：do{执行语句} while（循环条件）;
//do...while语句练习：找出所有的水仙花数
#include<iostream>
using namespace std;
int main()
{
//用do...while循环语句得到全部的水仙花数
//1.打印所有的三位数字
int num = 100;
do
{
//2.从所有的三位数中找到所有的水仙花数
int a = 0; //用于获得三位数的个位
int b = 0; //用于获得三位数的十位
int c = 0; // 用于获得三位数的百位
a = num % 10;
b = num / 10 % 10; //两个整数相除，结果仍未整数，若有小数则小数部分去掉
c = num / 100;
if (a*a*a+b*b*b+c*c*c==num)
{
cout << num << endl;
}
num++;
} while (num < 1000);
system("pause");
return 0;
}
//循环语句练习：设计猜数字游戏
#include<iostream>
using namespace std;
#include<ctime> //time系统时间头文件包含
int main() {
//设计一个猜数字的游戏
srand((unsigned int)time(NULL)); //srand用作添加随机数种子，作用：利用当前系统时间生成随机数，防止每次随机数都一样
int num = rand() % 100 + 1; //rand()%100表示的是从0到99的一个随机数
//cout << num << endl;
int val = 0;
cout << "请输入您猜测的数字" << endl;
while (1)
{
cin >> val;
if (val > num)
{
cout << "猜测过大" << endl;
}
else if (val < num)
{
cout << "猜测过小" << endl;
}
else if(val=num)
{
cout << "恭喜您猜对了" << endl;
break; //break, 利用该关键字退出当前循环
}
}
system("pause");
return 0;
}
=====for循环=====
作用：满足循环条件，执行循环语句
语法：for（起始表达式；条件表达式；末尾循环体）<br>{循环语句}
//for语句练习
#include<iostream>
using namespace std;
int main() {
//for循环语句练习，并包含嵌套结构
for (int i = 1; i <= 100; i++)
{
'''''if (i % 7 ==0||i%10==7||i/10==7)'''''
{
cout << "敲桌子" << endl;
}
else {
cout << i << endl;
}
}
system("pause");
return 0;
}
=====跳转语句=====
1.break<br>2.continue语句<br> 作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一循环<br>3.goto语句<br> 作用：如果标记存在，执行goto语句时，会跳转到标记的位置
=====一维数组数组名=====
一维数组名的用途：<br>1.可以统计整个数组在内存中的长度<br>2.可以获取数组在内存中的首地址<br>//arr[0]用于访问第一个元素；数组中第一个元素地址为（int）&arr[0]；获取首地址：cout<<(int)arr<<endl;
//一维数组的应用一：找到数组中最大的元素
#include<iostream>
using namespace std;
int main() {
//sizeof数组名
int arr[5] = { 300,350,200,400,250 };
int max = 0;
for (int i = 0; i <= 4; i++)
{
if (max < arr[i])
{
max = arr[i];
}
}
cout << "max=" << max << endl;
system("pause");
return 0;
}
//一维数组应用二：数组元素的倒置（利用for语句的嵌套循环）
#include<iostream>
using namespace std;
int main() {
//实现数组元素的逆置
int arr[5] = { 1,3,2,5,4 };
cout << "逆置前的数组元素：" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i]<<" ";
}
int start = 0;
int end = sizeof(arr) / sizeof(arr[0]) - 1;
while (start < end)
{
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
cout << endl;
cout << "逆置后的数组元素:" << endl;
for (int j = 0; j < 5; j++)
{
cout << arr[j] << " ";
}
system("pause");
return 0;
}
=====冒泡排序=====
作用：最常用的排序算法，对数组内元素进行排序<br>1、比较相邻的元素，如果第一个比第二个大，就交换他们两个//内循环，每次外循环进行的内循环次数：总元素个数-外循环次数-1<br>2、对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值//外循环次数：总元素个数-1<br>3、重复以上的步骤，每次比较的次数-1
//冒泡排序练习：将一组数字从大到小排序
#include<iostream>
using namespace std;
int main() {
int arr[9] = { 4,2,8,0,5,7,1,3,9 };
for (int a = 0; a < 9; a++)
{
cout << arr[a] << " ";
}
cout << endl;
//外部循环，总共排序轮数为总元素个数-1
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]) - 1; i++)
{
//内部循环 对比次数：元素个数-当前轮数-1
for (int j = 0; j < sizeof(arr) / sizeof(arr[0]) - i - 1;j ++ )
{
if (arr[j] < arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//打印排序后的结果
cout << "排序后的结果为" << endl;
for (int b = 0; b < 9; b++)
{
cout << arr[b] << " ";
}
cout << endl;
system("pause");
return 0;
}
=====二维数组=====
矩阵可以用嵌套循环打印：<br>二维数组定义方式：<br>1、数据类型 数组名[行数][列数]，然后逐个写，比如arr[0][0] = 3;<br>2、数据类型 数组名[行数][列数]={{数据1，数据2}，{数据3，数数据4}}<br>3、数据类型 数组名[行数][列数]={数据1，数据2，数据3，数据4}<br>4、数据类型 数组名[][列数]={数据1，数据2，数据3，数据4}
//二位数组名的作用
#include<iostream>
using namespace std;
int main() {
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
//1、查看占用内存空间大小
cout << "二维数组占用的内存空间大小为 " << sizeof(arr) << endl;
cout << "二维数组第一行占用的内存空间大小为 " << sizeof(arr[0]) << endl;
cout << "二维数组的第一个元素所占用的内存空间大小为 " << sizeof(arr[0][0]) << endl;
cout << "二维数组的行数为 " << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组的列数为 " << sizeof(arr[0]) / sizeof(arr[0][0])<<endl;
//2、查看二维数组的首地址
cout << "二维数组的首地址为 " << (int)arr << endl;
cout << "二维数组第一行的首地址为 " <<(int) arr[0] << endl;
system("pause");
return 0;
}
=====函数=====
作用：将一段经常使用的代码封装起来，减少重复代码<br>一个较大的程序一般分为若干个程序块，每个模块实现特定的功能
======函数的定义与调用======
1、返回值类型<br>2、函数名<br>3、参数列表<br>4、函数体语句<br>5、return表达式
语法：
返回值类型 函数名（参数列表）
{
函数体语句
return表达式
}
//函数的定义与调用
#include<iostream>
using namespace std;
//定义一个加法函数
//函数定义的时候，num1和num2并没有真实数据，它们只是形式上的参数，简称形参
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
int main() {
//调用定义的加法函数
int a = 10;
int b = 20;
int c = add(a, b); //a和b为实际参数，简称实参 当调用函数的时候，实参的值会传递给形参
cout << " c = " << c << endl;
system("pause"); //打印“按任意键继续”
return 0;
}
======值传递======
所谓值传递，就是函数调用时实参将值传入给形参<br>//值传递时，如果形参发生改变，并不会影响实参<br>总结：值传递时，形参是修饰不了实参的
函数的常见样式<br>1、无参无返<br>2、有参无返<br>3、无参有返<br>4、有参有返
//值传递
#include<iostream>
using namespace std;
//值传递：定义函数，实现两个数字进行交换
void swap(int num1, int num2) //如果函数不需要返回值，声明的时候可以写void
{
cout << "交换前： " << endl;
cout << "num1= " << num1 << endl;
cout << "num2= " << num2 << endl;
int temp = num1;
num1 = num2;
num2 = temp;
cout << "交换后： " << endl;
cout << "num1= " << num1 << endl;
cout << "num2= " << num2 << endl;
return; //返回值不需要的时候，可以不写return
}
int main() {
int a = 10;
int b = 20;
cout << "a= " << a << " " << "b= " << b << endl;
swap(a, b);
cout << "a= " << a << " " << "b= " << b << endl;
//做值传递的时候，函数的形参发生改变，并不会影响实参
system("pause");
return 0;
}
======函数的声明======
函数定义在main函数之后出现，要先在main函数进行函数声明<br>声明的使用：返回值类型 函数名（参数列表）<br>注：声明可以写多次，但定义只能有一次
======函数的分文件编写======
作用：让代码结构更加清晰<br>函数分文件编写一般有4个步骤<br>1.创建一个.h的头文件<br>2、创建一个.cpp的源文件<br>3、在头文件中写函数的声明<br>4、在源文件中写函数的定义
=====指针=====
作用：通过指针间接访问内存
可以通过指针来保存一个地址
指针定义的语法：数据类型 * 指针变量名 int * p;
int a = 10; 让指针记录变量a的地址 p = &a (&为取址符号） //int * p = &a;
//指针和数组
#include<iostream>
using namespace std;
int main() {
int a = 10;
int b = 20;
//1、const修饰指针，称为常量指针 此时，指针的指向可以修改，指针指向的值不可以修改
const int* p1 = &a;
cout << "*p1= " << *p1 << endl;
//*p = 20错误
p1 = &b;
cout << "*p1= " << *p1 << endl;
//2、const修饰常量，称为指针常量 此时，指针的指向不可以修改，指针指向的值可以修改
int* const p2 = &a;
cout << "*p2= " << *p2 << endl;
*p2 = 20;
//p = &b;错误
cout << "*p2= " << *p2 << endl;
//3、const既修饰指针也修饰变量
const int* const p3 = &a;
//指针的指向不可以修改，指针指向的值也不可以修改
system("pause");
return 0;
}
=====指针的使用=====
可以通过解引用的方式来找到指针指向的内存
指针前加*代表解引用找到指针指向的内存中的数据 *p
在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型，在64位操作系统中，指针是占8个字节空间大小
=====空指针和野指针=====
空指针：指针变量指向内存中编号为0的空间 int * p = NULL;（0到255之间的内存编号是系统占用的，因此不可以访问）
作用：初始化内存变量
注意：空指针指向的内存是不可以访问的
野指针：指针变量指向非法的内存空间
=====const修饰指针=====
const修饰指针，称为常量指针
int a = 10; int b = 20;
const int * p = &a;常量指针
特点：指针的指向可以修改，但是指针指向的值不可以改 *p = 20,错误； p = &b,正确
const修饰常量 指针常量 int * const p = &a;
特点：指针的指向不可以修改，但是指针指向的值可以修改 *p = 20,正确； p = &b,错误
const既修饰指针，又修饰常量
特点：指针的指向和指针指向的值都不可以修改
const int * const p = &a; *p = 20,错误； p = &b,错误
=====指针和数组=====
用指针指向数组
//指针和数组
#include<iostream>
using namespace std;
int main() {
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "第一个元素 " << arr[0] << endl;
int* p = arr; //指向数组的指针
cout << "用指针访问第一个元素" << *p << endl;
int* p2 = arr;
for (int i = 0; i < 10; i++)
{
cout << "用指针读取数组 " << *p2 << endl;
p2++;
}
system("pause");
return 0;
}
=====地址传递=====
地址传递，可以修饰实参 用指针写函数的参数列表
//指针 冒泡排序和数组
#include<iostream>
using namespace std;
//冒泡排序 参数1 数组首元素 参数2 数组长度
void bubbleSort(int* arr, int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
void printArray(int* arr, int len)
{
for (int a = 0; a < len; a++)
{
cout << arr[a] << endl;
}
}
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);
system("pause");
return 0;
}
=====内存分区存放=====
c++程序在执行时，将内存大方向分为4个区域。<br>
代码区：存放函数的二进制代码，由操作系统进行管理的<br>
全局区：存放全局变量和静态变量以及常量<br>
栈区：由编译器自动分配释放，存放函数的参数值，局部变量等<br>
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收<br>
内存四区的意义：不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程<br>
======程序运行前======
在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域<br>
代码区：<br>
存放CPU执行的机器指令<br>
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可<br>
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令<br>
全局区：<br>
全局变量和静态变量存放在此<br>
全局区还包含了常量区，字符串常量和其他常量也存放在此<br>
该区域的数据在程序结束后由操作系统释放<br>全局变量、常量和静态变量都存放在全局区中，局部变量存放在其他区中<br>
//全局变量
#include<iostream>
using namespace std;
//创建全局变量
int g_a = 10;
int g_b = 20;
//const修饰的全局变量，即全局常量
const int c_g_a = 10;
const int c_g_b = 20;
int main()
{
//全局区 全局变量 常量 静态变量
//创建普通的局部变量
int a = 10;
int b = 20;
cout << "局部变量a的地址： " << (int)&a << endl;
cout << "局部变量b的地址： " << (int)&b << endl;
cout << "全局变量g_a的地址： " << (int)&g_a << endl;
cout << "全局变量g_b的地址： " << (int)&g_b << endl;
//静态变量 在普通变量前面加一个static，属于静态变量
static int s_a = 10;
static int s_b = 20;
cout << "静态变量s_a的地址： " << (int)&s_a << endl;
cout << "静态变量s_b的地址： " << (int)&s_b << endl;
//常量
//字符串常量
cout << "字符串常量的地址： " << (int)&"hello world" << endl;
//const修饰的变量
//const修饰的全局变量，const修饰的局部变量
cout << "全局常量量c_g_a的地址： " << (int)&c_g_a << endl;
cout << "全局常量量c_g_b的地址： " << (int)&c_g_b << endl;
const int c_l_a = 10;
const int c_l_b = 20;
cout << "局局常量c_l_a的地址： " << (int)&c_l_a << endl;
cout << "局局常量c_l_b的地址： " << (int)&c_l_b << endl;
system("pause");
return 0;
}
总结：<br>
c++中在程序运行前分为全局区和代码区<br>
代码区特点是共享和只读<br>
全局区总存放全局变量、静态变量、常量<br>
常量中存放const修饰的全局常量和字符串常量
<br>
======程序运行后======
栈区： <br>
由编译器自动分配释放，存放函数的参数值（包括形参）、局部变量等<br>
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放<br>堆区：<br>
由程序员分配释放，若程序员不释放，程序结束时由操作系统回收<br>
在c++中主要用new在堆区开辟内存<br>
//类型
#include<iostream>
using namespace std;
int* func()
{
int* p = new int(10);
}
int main() {
//利用new关键字，可以将数据开辟到堆区
//指针 本质也是局部变量，指针保存的数据是放在堆区
int* p = func();
cout << *p << endl;
system("pause");
return 0;
}
======new操作符======
c++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
语法：new 数据类型
利用new创建的数据，会返回该数据对应的指针
在堆区利用new开辟数组
viod func()
{
int* arr = new int[10]; //10代表数组有10个元素
for(int i = 0;i<10;i++)
{
arr[i] = i;
}
}
delete[] arr; //释放数组的时候，要加[]才可以
int * func()
{
int * p = new int(10);
return p;
}
delete p; //释放堆区内存=====结构体=====
定义：属于自定义的数据类型，允许用户储存不同的数据类型
语法：struct 结构体名（结构体成员列表）
<br>
通过结构体创建变量的方式有三种
</pre>
1、struct 结构体名 变量名
2、struct 结构体名 变量名= {成员1值，成员2值...}
3、定义结构体时顺便创建变量
//结构体的定义和使用
#include<iostream>
#include<string>
using namespace std;
struct Student
{
string name;
int score;
int age;
}s3; //3、在创建结构体的时候顺便创建变量
int main() {
struct Student s1;
//1、struct 结构体名 变量名；(struct结构体创建变量时可以省略）
//给s1属性赋值，通过“.”访问结构体变量中的属性
s1.name = "张三";
s1.score = 100;
s1.age = 18;
cout << "姓名： " << s1.name << " 分数 " << s1.score << " 年龄 " << s1.age << endl;
//2、struct 结构体名 变量名 = {成员1值，成员2值...}
struct Student s2 = { "李四",80,23 };
cout << "姓名： " << s2.name << " 分数 " << s2.score << " 年龄 " << s2.age << endl;
s3.name = "王五";
s3.score = 50;
s3.age = 24;
cout << "姓名： " << s3.name << " 分数 " << s3.score << " 年龄 " << s3.age << endl;
system("pause");
return 0;
}
======结构体数组======
作用：将定义的结构体放入到数组中方便维护
语法：struct 结构体名 数组名[元素个数] = { {}，{}，{}，
//结构体数组
#include<iostream>
#include<string>
using namespace std;
struct Student
{
string name;
int age;
int score;
};
int main()
{
struct Student stuArray[3] =
{
{"张三",18,100},
{"李四",23,99},
{"王五",24,66}
};
stuArray[2].name = "赵六";
stuArray[2].age = 20;
stuArray[2].score = 88;
for (int i = 0; i < 3; i++)
{
cout << "姓名： " <<stuArray[i].name << " 年龄 " << stuArray[i].age << " 分数 " <<stuArray[i].score << endl;
}
system("pause");
return 0;
}
======结构体指针======
作用：通过指针访问结构中的成员
利用操作符“->”可以通过结构体指针访问结构体属性
struct student s = {"张三",18,100};
struct student *p = &s;
用指针访问结构体属性： p->name; p->age; p->score=======结构体嵌套结构体======
在结构体的定义中，可以利用另一个结构体作为本结构体中的一个成员
//结构体嵌套结构体
#include<iostream>
#include<string>
using namespace std;
struct student
{
string name;
int age;
int score;
};
//结构体嵌套结构体
struct teacher
{
int id;
string name;
struct student stu;
};
int main() {
teacher t;
t.id = 140403;
t.name = "老王";
t.stu.name = "李四";
t.stu.age = 18;
t.stu.score = 100;
cout << "老师的姓名 " << t.name << " 老师的职工编号 " << t.id << " 老师辅导的学生姓名 " << t.stu.name << endl;
cout << "学生成绩 " << t.stu.score << " 学生年龄 " << t.stu.age << endl;
system("pause");
return 0;
}
=======结构体做函数参数======
值传递和地址传递
//结构体指针的值传递和地址传递
#include<iostream>
#include<string>
using namespace std;
struct student
{
string name;
int age;
int score;
};
void printstudent1(struct student s)
{
cout << "姓名： " << s.name << " 分数 " << s.score << " 年龄 " << s.age << endl;
}
void printstudent2(struct student* p)
{
cout << "姓名： " << p->name << " 分数 " << p->score << " 年龄 " << p->age << endl;
}
int main() {
student s;
s.name = "李四";
s.age = 23;
s.score = 100;
printstudent1(s); //值传递，形参修饰不了实参
printstudent2(&s); //地址传递，形参能修饰实参
system("pause");
return 0;
}
======结构体中const使用场景======
作用：用const来防止误操作
const student 限定结构体，不能进行更改
=====引用=====
作用：给变量起别名<br>
语法：数据类型 &别名 = 原名<br>
int a = 10;<br>
int &b = a;<br>
修改a或b其中一个的值，另外一个的值也会改变<br>
引用的注意事项<br>
引用必须初始化<br>
引用在初始化后，就不可以进行更改<br>
//引用传递
#include<iostream>
using namespace std;
void mySwap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
int main() {
int a = 10;
int b = 20;
mySwap(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
======引用做函数参数======
作用：函数传递时，可以利用引用的技术让形参修饰实参<br>
优点：可以简化指针修改实参<br>
引用传递：形参可以修饰实参<br>
======引用做函数返回值======
作用：引用是可以作为函数返回值存在的<br>
注意：不要返回局部变量引用<br>
用法：函数用作为左值<br>
//引用做函数返回值
#include<iostream>
using namespace std;
//返回静态变量的引用
int& test1()
{
static int a = 10;
return a;
}
int main() {
//函数做左值，则必须返回引用
int& b = test1(); //b=10
test1() = 1000; //b=1000
system("pause");
return 0;
}
======常量引用======
作用：常量引用主要用来修饰形参，防止误操作<br>
在函数形参列表中，可以加const修饰形参，防止形参改变实参<br>
const int & ref = 10; 加上const之后，编译器将代码修改为 int temp = 10; int & ref = temp;<br>
const int & ref ,用const修饰之后，ref的值是不可以修改的<br>
=====函数默认参数=====
在c++中，函数的形参列表中的形参可以有默认值的<br>
语法：返回值类型 函数名 （参数 = 默认值） { }<br>
如果我们在实参中传入数据，就用我们传入的数据，如果没有，那么用默认值<br>
如果某个位置已经有了默认值，那么从这个位置往后，从左到右有必须有默认值<br>
如果函数声明有默认参数，函数实现就不能有默认参数。函数声明和函数定义只能有一个有默认参数<br>
=====函数占位参数=====
c++中函数的形参列表中可以有占位参数，用来做占位，调用函数时填补该位置<br>
语法：返回值类型 函数名（数据类型） { }<br>
占位参数可以有默认参数<br>
=====函数重载=====
作用：函数名可以相同，提高复用性<br>
函数重载满足条件：<br>
同一个作用域下，
函数名称相同
函数参数类型不同或者个数不同或者顺序不同
注意事项：<br>
引用作为重载条件<br>
函数重载碰到函数默认参数<br>=====类和对象=====
c++面向对象的三大特性为：封装、继承、多态
======封装======
封装的意义：
将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制
//封装的意义
#include<iostream>
using namespace std;
const double PI = 3.14;
class circle //定义一个类，使用class
{
/*
访问权限
公共权限
*/
public:
/*
属性
半径
*/
double m_r;
/*
行为（行为通常为一个函数）
获取圆的周长
*/
double calculateZC()
{
return 2 * PI * m_r;
}
};
int main() {
//通过圆类，创建具体的圆（对象）
circle c1;
//给圆对象的属性进行赋值
c1.m_r = 5.20;
cout << "圆c1的周长为： " << c1.calculateZC() << endl;
system("pause");
return 0;
}
封装的意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制<br>
访问权限有三种：<br>
1、public 公共权限 类内可以访问，类外可以访问<br>
2、protected 保护权限 类内可以访问，类外不可以访问 儿子可以访问父亲中的保护内容<br>
3、private 私有权限 类内可以访问，类外不可以访问 儿子不可以访问父亲的私有内容<br>
#include<iostream>
using namespace std;
class student {
public:
string name;
int ID;
void print() {
cout << "学生的姓名： " << name << endl;
cout << "学生的学号： " << ID << endl;
}
};
int main() {
student s1;
s1.name = "张三";
s1.ID = 173962;
s1.print();
student s2;
s2.name = "李四";
s2.ID = 174615;
s2.print();
system("pause");
return 0;
}
======struct和class的区别======
在c++中 struct和class唯一的区别在于默认的访问权限不同<br>
struct默认权限为公共<br>
class默认权限为私有<br>
======成员属性设置为私有======
优点：将所有成员属性设置为私有，可以自己控制读写权限。对于写权限，我们可以检测数据的有效性 <br>
将成员属性放在private下，想改动属性，则将相应的函数放在public下<br>
=====对象的初始化和清理=====
构造函数和析构函数：初始化和清理<br>
如果我们不提供构造和析构，编译器会提供编译器自动调动。编译器提供的构造函数和析构函数时空实现<br>
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用<br>
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作<br>
构造函数语法：类名（）{ }<br>
1、构造函数，没有返回值也不写void<br>
2、函数名称与类名相同<br>
3、构造函数可以有参数，因此可以发生重载<br>
4、程序在调用对象时候会自动调用构造函数，无需手动调用，而且只会调用一次<br>
析构函数语法：~类名（）{ }<br>
1、析构函数没有返回值也不写void<br>
2、函数名称与类名相同，在名称前加~<br>
3、析构函数不可以有参数，因此不可以发生重载<br>
4、程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次<br>=====构造函数的分类及调用=====
两种分类方式：<br>
按参数分为：有参构造和无参构造<br>
按类型分为：普通构造和拷贝构造<br>
class person
{
public:
person( )
{
cout<<"person的无参构造函数调用"<<endl;
}
person( int a)
{
cout<<"person的有参构造函数调用"<<endl;
age = a;
}
person( const person &p)
{
age = p.age; //将传入的人身上的所有属性拷贝到我身上
}
~person( )
{
cout<<"person的析构函数调用"<<endl;
}
int age;
};
三种调用方式：括号法 显示法 隐式转换法
调用：
void test1( )
{
//1、括号法
person p1; //默认构造函数调用，调用无参构造函数 注意事项： 调用默认构造函数的时候，不要加（）；不要利用拷贝函数来初始化匿名对象
person p2(10); //调用有参构造函数
person p3(p2); //调用拷贝构造函数
//2、显示法
person p1; //调用无参构造
person p2 = person(10); //调用有参构造
person p3 = person(p3); //调用拷贝构造
匿名对象 ，如person(10 ) 特点：当前行执行结构后，系统会立即回收掉匿名对象
//3、隐式转换法
person p4 = 10; // 相当于写了 person p4 = person(10); 调用有参构造函数
person p5 = p4; // 调用拷贝构造函数
}=====STL的基本概念=====
STL（standard template library，标准模板库）<br>
STL从广义上分为：容器（container）、算法（algorithm）、迭代器（iterator）<br>
容器和算法之间通过迭代器进行无缝衔接<br>
STL几乎所有的代码都采用了模板类和模板函数<br>
======STL六大组件======
分别为容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器<br>
1、容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据<br>
2、算法：各种常用的算法，如sort、find、copy、for_each等<br>
3、迭代器：扮演了容器和算法之间的胶合剂<br>
4、仿函数：行为类似函数，可作为算法的某种策略<br>
5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西<br>
6、空间配置器：负责空间的配置与管理<br>
======容器算法迭代器======
=======vector存放内置数据类型=======
容器：vector<br>
算法：for_each<br>
迭代器：vector<int>::iterator<br>
//用vector容器存放数据并实现数据的遍历
#include<iostream>
using namespace std;
#include<vector>
//第一种遍历方式
void test1()
{
//创建一个vector容器，把容器看作一个数组数组
vector<int> v;
//向容器中插入数据
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
//通过迭代器访问容器中的数据
vector<int>::iterator itBegin = v.begin(); //v.begin（）为起始迭代器，指向容器第一个元素
vector<int>::iterator itEnd = v.end(); //v.end()为结束迭代器，指向容器中最后一个元素的下一个位置
while (itBegin != itEnd)
{
cout << *itBegin << endl;
itBegin++;
}
//第二种遍历方式
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << endl;
}
}
int main() {
test1();
system("pause");
return 0;
}
=====拷贝构造=====
拷贝构造函数调用时机通常有三种：
1、使用一个已经创建完成的对象来初始化一个对象
2、值传递的方式给函数参数传值
3、以值方式返回局部对象
//拷贝构造函数调用时机
#include<iostream>
using namespace std;
class person {
public:
person()
{
cout << "person的无参构造函数调用" << endl;
}
person(int age)
{
m_age = age;
cout << "有参构造函数的调用" << endl;
}
person(const person & p)
{
m_age = p.m_age;
cout << "拷贝构造函数调用" << endl;
}
~person()
{
cout << "person析构函数调用" << endl;
}
private:
int m_age;
};
int main() {
//情况一
person p1(10);
person p2(p1);
system("pause");
return 0;
}
=====构造函数调用规则=====
默认情况下，c++编译器至少给一个类添加3个函数<br>
1、默认构造函数（无参，函数体为空）<br>
2、默认析构函数（无参，函数体为空）<br>
3、默认拷贝构造函数，对属性进行值拷贝<br>
构造函数调用规则如下：<br>
如果用户定义有参构造函数，c++不再提供无参构造，但是会提供默认拷贝构造<br>
如果用户定义拷贝构造函数，c++不会再提供其他构造函数<br>
=====深拷贝和浅拷贝=====
浅拷贝：简单的赋值拷贝操作<br>
深拷贝：在堆区重新申请空间，进行拷贝操作<br>
浅拷贝带来的问题就是堆区的内存重复释放，浅拷贝的问题要利用深拷贝来解决<br>
//用深拷贝解决浅拷贝的问题
#include<iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "Person默认构造函数调用" << endl;
}
Person(int age, int height)
{
m_age = age;
m_height = new int(height); //用new操作符在堆区开辟数据
cout << "Person有参构造函数的调用" << 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);
}
~Person() //析构函数，将堆区开辟的数据局做释放操作
{
if (m_height != NULL)
{
delete m_height;
m_height = NULL; // 防止野指针的出现
}
cout << "Person析构函数调用" << endl;
}
int m_age;
int *m_height; //用new操作符在堆区开辟数据，用指针进行数据的接收
};
void test01()
{
Person p1(10, 160);
cout << "p1的年龄为： " << p1.m_age << " p1的体重为： " << *p1.m_height << endl; //用指针接收堆区的返回值
Person p2(p1);
cout << "p1的年龄为： " << p1.m_age << " p1的体重为： " << *p1.m_height << endl;
}
int main() {
test01();
system("pause");
return 0;
}
=====初始化列表=====
作用：c++提供了初始化列表语法，用来初始化属性<br>
语法：构造函数（）：属性1（值1），属性2（值2）...{ }<br>
//
#include<iostream>
using namespace std;
class Person {
public:
//初始化列表初始化属性
Person(int a,int b,int c) :m_A(a), m_B(b), m_C(c)
{
}
int m_A;
int m_B;
int m_C;
};
void test01()
{
Person p(10,20,30);
cout << "A为： " << p.m_A<<endl;
cout << "B为： " << p.m_B << endl;
cout << "C为： " << p.m_C << endl;
}
int main() {
system("pause");
return 0;
}
=====c++对象模型和this指针=====
成员变量和成员函数分开存储<br>
在c++中，类内的成员变量和成员函数分开存储<br>
只有非静态成员变量才属于类的对象上<br>
c++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置。每个空对象也应该有一个独一无二的内存地址<br>
======this指针概念======
成员变量和成员指针是分开存储的，这一块代码的区分调用是通过this指针完成的。this指针指向被调用的成员函数所属的对象<br>
this指针是隐含每一个非静态成员函数内的一种指针<br>
this指针不需要定义，直接使用即可<br>
this指针的用处：当形参和成员变量同名时，可用this指针来区分；在类的非静态成员函数中返回对象本身，可使用return*this<br>
//this指针的使用两种情况
#include<iostream>
using namespace std;
class Person {
public:
Person(int age)
{
this->age = age; //this指针指向被调用的成员函数所属的对象
}
Person& PersonAddAge(Person p)
{
this->age += p.age;
return *this; //this指向p2的指针，而*this指向的就是p2这个对象本体
}
int age;
};
//1、解决名称冲突问题
void test1()
{
Person p1(18);
std::cout << "p1的年龄： " << p1.age << std::endl;
}
//2、返回对象本身用*this
void test2()
{
Person p1(5);
Person p2(3);
p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
cout << "p2 的年龄： " <<p2.age<< endl;
}
int main() {
test1();
test2();
system("pause");
return 0;
}
=====空指针调用成员函数=====
c++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针<br>
如果用到this指针，需要加以判断保证代码的健壮性<br>
=====const修饰成员函数=====
常函数：<br>
成员函数后加const后我们称这个函数为常函数<br>
常函数内不可以修改成员属性<br>
成员属性声明时加关键字mutable后，在常函数中依然可以修改<br>
常对象：<br>
声明对象前加const称该对象为常对象<br>
常对象只能调用常函数<br>
=====友元=====
友元的目的就是让一个函数或者类访问另外一个类中私有成员<br>
友元的关键字 friend<br>
友元的三种实现方式：全局函数做友元 类做友元 成员函数做友元<br>
//友元friend 在类中写入成员变量和成员函数之前写入
#include<iostream>
using namespace std;
class Building {
friend void person1(Building* building);
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
string m_SittingRoom;
private:
string m_BedRoom;
};
void person1(Building *building)
{
cout << "一个人正在访问 " << building->m_SittingRoom << endl;
cout << "一个人正在访问 " << building->m_BedRoom << endl;
}
void test1() {
Building building;
person1(&building);
}
int main() {
test1();
system("pause");
return 0;
}
=====继承=====
//继承的基本语法
#include<iostream>
using namespace std;
class BasePage
{
public:
void header()
{
cout << "首页、公开课" << endl;
}
void footer()
{
cout << "帮助中心、交流合作" << endl;
}
void left()
{
cout << "学习内容" << endl;
}
};
//继承的基本语法
class Java : public BasePage //Jave页面
{
public:
void content()
{
cout << "Java学科视频" << endl;
}
};
//Python页面
class Python : public BasePage
{
public:
void content()
{
cout << "Python学习视频" << endl;
}
};
//c++页面
class Cpp: public BasePage
{
public:
void content()
{
cout << "c++学习资料" << endl;
}
};
void test01()
{
cout << "Java页面如下 " << endl;
Java ja;
ja.header();
ja.content();
ja.left();
ja.footer();
cout << "--------------" << endl;
}
void test02()
{
cout << "Python页面如下 " << endl;
Python py;
py.header();
py.content();
py.left();
py.footer();
cout << "--------------" << endl;
}
void test03()
{
cout << "c++页面如下 " << endl;
Cpp cpp;
cpp.header();
cpp.content();
cpp.left();
cpp.footer();
cout << "--------------" << endl;
}
int main() {
test01();
test02();
test03();
system("pause");
return 0;
}
=====继承方式=====
继承的语法： class 子类 ： 继承方式 父类<br>
继承方式一共有三种：公共继承 保护继承 私有继承<br>
<gallery>
继承方式区别.jpg
</gallery>
子类也称为派生类，父类也称为基类<br>
父类中的私有成员在子类中无法访问，但是私有成员只是被隐藏了，还是会继承下去<br>
=====继承中的对象模型=====
父类中所有非静态成员属性都会被子类继承下去<br>
父类中私有成员属性是被编译器给隐藏了，因此是访问不到的，但是确实被继承下去了<br>
=====继承中的构造和析构顺序=====
先构造父类，再构造子类；析构的顺序与构造正好相反<br>
=====继承同名成员处理方式=====
访问子类同名成员，直接访问即可<br>
访问父类同名成员，需要加作用域（：： 即双冒号）<br>
//同名函数处理，访问父类同名成员时需要加作用域
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
m_A = 100;
}
int m_A;
void func(int a)
{
cout << "Base func 调用" << endl;
}
};
class Son : public Base
{
public:
Son() {
m_A = 200;
}
int m_A;
void func()
{
cout << "Son func 调用" << endl;
}
};
//同名成员属性的处理方式
void test01()
{
Son s;
cout << "Son 下 m_A = " << s.m_A << endl;
cout << "Base 下 m_A = " << s.Base::m_A << endl; //如果通过子类对象访问父类中同名成员，需要加作用域
}
//同名成员函数处理
void teat02()
{
Son s;
s.func(); //直接调用，调用的是子类中的同名成员
/*s.Base::func(); */ // 加作用域调用父类中的同名函数
//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏父类中所有同名成员函数
//如果想访问父类中被隐藏的同名成员函数，需要加作用域
s.Base::func(100);
}
int main()
{
test01();
system("pause");
return 0;
}
=====继承中同名静态成员处理方式=====
访问子类同名成员，直接访问即可<br>
访问父类同名成员，需要加作用域<br>
=====多继承语法=====
c++允许一个类继承多个类<br>
语法：class 子类 ： 继承方式 父类1 ， 继承方式 父类2 ， ............<br>
多继承可能会引发父类中有同名成员出现，需要加作用域区分<br>
c++实际开发中不建议用多继承<br>
=====菱形继承（钻石继承）=====
菱形继承的概念：<br>
两个派生类继承同一个基类<br>
又有某个类同时继承两个派生类<br>
//菱形继承
#include<iostream>
using namespace std;
class Animal
{
public:
int m_Age;
};
//利用虚继承解决菱形继承的问题
//继承之前加上关键字virtual变为虚继承
//Animal类称为虚基类
class Sheep : virtual public Animal{};
class Tuo : virtual public Animal{};
class SheepTuo : public Sheep,public Tuo{};
void test1()
{
SheepTuo st;
//当菱形继承，；两个父类拥有相同数据，需要加以作用域区分
st.Sheep::m_Age = 10;
st.Tuo::m_Age = 12;
cout << "羊的年龄 " << st.Sheep::m_Age << endl;
cout << "坨的年龄 " << st.Tuo::m_Age << endl;
}
int main()
{
test1();
system("pause");
return 0;
}
=====多态=====
静态多态：函数重载和运算符重载属于静态多态 复用函数名<br>
动态多态：派生类和虚函数（函数前加上virtual关键字成为虚函数）实现时多态<br>
静态多态额动态多态的区别：1、静态多态的函数地址早绑定-编译阶段确定函数地址 2、动态多态的函数地址晚绑定-运行阶段确定函数地址<br>
多态满足条件：1、有继承关系 2、子类重写父类中的虚函数<br>
多态使用条件：1、父类指针或引用指向子类对象<br>
重写：函数返回值类型 函数名 参数列表 完全一致称为重写<br>
//多态的基本语法
#include<iostream>
using namespace std;
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;
}
};
void doSpeak(Animal &animal) //地址早绑定 在编译阶段确定函数地址。如果想执行让猫说话，那么这个函数地址不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
{
animal.speak();
}
void test1()
{
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
int main()
{
test1();
system("pause");
return 0;
}
======纯虚函数和抽象类======
父类中的虚函数没有实际意义，所以将父类中的虚函数改为纯虚函数<br>
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0；<br>
当类中有了纯虚函数，这个类也称为抽象类<br>
抽象类特点：1、无法实例化对象 2、子类必须重写抽象类中的纯虚函数，否则也属于抽象类<br>
例如：在父类中有一个成员函数为 virtual void func() = 0; 父类中存在纯虚函数，则在子类中必须重写抽象类中的纯虚函数 即virtual void func() {....}<br>
======虚析构和纯虚析构======
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码<br>
解决方式：将父类中的析构函数改为虚析构或者纯虚析构<br>
虚析构和纯虚析构共性：1、可以解决父类指针释放子类对象 2、都需要有具体的函数实现<br>
虚析构和纯虚析构区别：如果是纯虚虚构，该类属于抽象类，无法实例化对象<br>
//虚析构和纯虚析构
#include<iostream>
using namespace std;
#include<string>
class Animal
{
public:
virtual void speak() = 0;
Animal()
{
cout << "animal的构造函数调用" << endl;
}
virtual ~Animal() //利用虚析构解决堆区释放不干净的问题
{
cout << "animal的析构函数调用" << endl;
}
};
class Dog : public Animal
{
public:
Dog(string name)
{
cout << "dog的构造函数调用" << endl;
m_Name = new string(name);
}
virtual void speak()
{
cout <<*m_Name<< "小狗在说话" << endl;
}
~Dog()
{
cout << "dog的析构函数调用" << endl;
if (m_Name != NULL)
{
delete m_Name;
m_Name = NULL;
}
}
string *m_Name;
};
void test2()
{
Animal* animal = new Dog("Tim");
animal->speak();
//父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄露
delete animal;
}
int main()
{
test2();
system("pause");
return 0;
}
虚析构：在父类析构函数前加virtual<br>
纯虚析构：在父类中，令虚析构函数 = 0改为纯虚析构。<br>
纯虚析构需要在父类中进行声明，也需要有具体实现<br>
例如：父类为<br>
class Animal{
public:
virtual ~Animal() = 0; //纯虚析构
};
//具体实现
Animal::~Animal()
{
cout<<"Animal纯虚析构函数的调用"<<endl;
}
=====文件操作=====
程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放<br>
通过文件可以将数据持久化<br>
c++中对文件操作需要包含头文件<fstream><br>
文件类型分为两种：<br>
1、文本文件：文件以文本的ASCII码形式存储在计算机中<br>
2、二进制文件：文件以文本的二进制形式存储在计算机中，用户一般不能直接读它们<br>
操作文件的三大类：1、ofstream：写操作（o代表output） 2、ifstream：读操作（i代表input） 3、fstream：读写操作<br>
======文本文件======
=======写文件=======
1、包含头文件 #include<fstream><br>
2、创建流对象 ofstream ofs；<br>
3、打开文件 ofs.open("文件路径",打开方式);<br>
4、写数据 ofs<<"写入的数据";<br>
5、关闭文件 ofs.close();<br>
文件打开方式<br>
ios::in 为读文件而打开文件<br>
ios::out 为写文件而打开文件<br>
ios::ate 初始位置：文件尾<br>
ios::app 追加方式写文件<br>
ios::trunc 如果文件存在先删除，再创建<br>
ios::binary 二进制方式<br>
注意：文件打开方式可以配合使用，利用 | 操作符<br>
//文本文件 写文件
#include<iostream>
using namespace std;
#include<fstream>
//文本文件 写文件
void test01()
{
//1、包含头文件fstream
//2、创建流对象
ofstream ofs;
//3、打开文件
ofs.open("test.txt", ios::out);
//4、写数据
ofs << "姓名：张三" << endl;
ofs << "性别：男" << endl;
//5.关闭文件
ofs.close();
}
int main()
{
test01();
system("pause");
return 0;
}
总结：<br>
1、文件操作必须包含头文件fstream<br>
2、写文件可以利用ofstream，或者fstream<br>
3、打开文件时候需要操作文件的路径，以及打开方式<br>
4、利用<<可以向文件中写数据<br>
5、操作完毕，要关闭文件<br>=======读文件=======
1、包含头文件 #include<fstream><br>
2、创建流对象 ifstream ifs；<br>
3、打开文件并判断打开是否成功 ifs.open("文件路径",打开方式);<br>
4、读数据 四种方式读取<br>
5、关闭文件 ifs.close();<br>
///文本文件 读文件
#include<iostream>
#include<fstream>
using namespace std;
#include<string>
//文本文件 读文件
void test02()
{
//1、包含头文件
//2、创建流对象
ifstream ifs;
//3、打开文件，判断文件打开是否成功
ifs.open("test.txt", ios::in);
if (!ifs.is_open())
{
cout << "文件打开失败" << endl;
return;
}
//4、读文件
//4.1第一种方式读文件
char buf[1024] = { 0 };
while (ifs >> buf)
{
cout << buf << endl;
}
//4.2第二种方式读文件
char buf[1024] = { 0 };
while (ifs.getline(buf,sizeof(buf)))
{
cout << buf << endl;
}
//4.3第三种方式读文件
string buf;
while (getline(ifs, buf)) //getline表示得到一行，把ifs中的一行写入buf
{
cout << buf << endl;
}
//4.4第四种方式读文件
char c;
while ((c = ifs.get()) != EOF) //EOF : end of file
{
cout << c;
}
//5、关闭文件
ifs.close();
}
int main()
{
test02();
system("pause");
return 0;
}
总结：<br>
1、读文件可以利用ifstream，或者fstream<br>
2、利用is_open函数可以判断文件是否打开成功<br>
3、close关闭文件<br>
======二进制文件======
以二进制的方式对文件进行读写操作<br>
打开方式要制定为ios::binary<br>
=======写文件=======
二进制方式写文件主要利用流对象调用成员函数write<br>
函数原型：ostream& write(const char * buffer,int len);<br>
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数<br>
//二进制文件 写文件
#include<iostream>
#include<fstream>
using namespace std;
class Person
{
public:
char m_Name[64];
int m_Age;
};
void test1()
{
ofstream ofs;
ofs.open("person.txt", ios::binary | ios::out);
Person p = { "张三",18 };
ofs.write((const char*)&p, sizeof(Person));
ofs.close();
}
int main()
{
test1();
system("pause");
return 0;
}
=======读文件=======
二进制方式读文件主要利用流对象调用成员函数read<br>
函数原型： istream& read(char *buffer,int len);<br>
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数<br>
//二进制文件 读文件
#include<iostream>
#include<fstream>
using namespace std;
class Person
{
public:
char m_Name[64];
int m_Age;
};
void test2()
{
ifstream ifs;
ifs.open("Person.txt", ios::binary|ios::in);
if (!ifs.is_open())
{
cout << "文件打开失败" << endl;
}
Person p;
ifs.read((char*)&p, sizeof(Person));
ifs.close();
}
int main()
{
test2();
system("pause");
return 0;
}
</source >
</pre>
=====vector容器中存放自定义的数据类型=====
</pre>
<source lang="cpp" >
//=vector容器中存放自定义的数据类型
#include<iostream>
using namespace std;
#include<vector>
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name; this->m_Age = age;
}
string m_Name;
int m_Age;
};
void test1()
{
/*vector<Person>v;
Person p1("张三", 19);
Person p2("李四", 56);
Person p3("王五", 49);
Person p4("赵六", 29);*/
//v.push_back(p1);
向容器中添加数据
//v.push_back(p2);
//v.push_back(p3);
//v.push_back(p4);
//遍历容器中的数据
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "姓名:" << (*it).m_Name << " 年龄：" << (*it).m_Age << endl; //it相当于一个指针，指向<>中的数据类型，*it为解引用操作，解出来的是Person数据类型
//解引用再.出Person的属性，或者it指针指向Person的属性也可以，即it->m_Age
}
}
//向vector容器中存放自定义数据类型的指针
void test2()
{
vector<Person*> v;
Person p1("张三", 19);
Person p2("李四", 56);
Person p3("王五", 49);
Person p4("赵六", 29);
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "姓名： " << (*it)->m_Name << " 年龄： " << (*it)->m_Age << endl;
}
}
int main()
{
test2();
system("pause");
return 0;
}
=====vector容器嵌套容器=====
//
#include<iostream>
using namespace std;
#include<vector>
//容器嵌套容器
void test3()
{
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);
v1.push_back(i + 2);
v1.push_back(i + 3);
v1.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++)
{
//(*it) 就是小容器vector<int>
for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
{
cout << *vit << " ";
}
cout << endl;
}
}
int main()
{
test3();
system("pause");
return 0;
}
=====string=====
本质：string是c++风格的字符串，而string本质上是一个类<br>
string和char*的区别：char*是一个指针；string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器<br>
特点：string类内部封装了很多成员方法。例如：查找find，拷贝copy，删除delete，替换replace，插入insert； string管理char*分配的内存，不用担心赋值越界和取址越界等，由类内部进行负责<br>
=====string构造函数=====
构造函数原型：<br>
string(); //创建一个空的字符串，例如：string str；<br>
string(const char* s); //使用字符串s初始化<br>
string(const string& str); //使用一个string对象初始化另一个string对象<br>
string(int n,char c); //使用n个字符c初始化<br>
//
#include<iostream>
using namespace std;
void test01()
{
string s1; //默认构造函数
const char* str = "hello world"; //c语言风格的字符串类型
string s2(str); //有参构造函数
cout << "s2= "<<s2 << endl;
string s3(s2); //拷贝构造函数
cout << "s3= " << s3 << endl;
string s4(10,'a');
cout << "s4= " << s4 << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
=====string赋值操作=====
赋值的函数原型<br>
string& operator=(const char* s); //char*类型字符串 赋值给当前的字符串<br>
string& operator=(const string &s); //把字符串s赋值给当前的字符串<br>
string& operator=(char c); //字符赋值给当前的字符串<br>
string& assign(const char* s); //把字符串s赋值给当前的字符串<br>
string& assign(const char* s,int n); //把字符串s的前n个字符赋值给当前的字符串<br>
string& assign(const string &s); //把字符串s赋给当前字符串<br>
string& assign(int n,char c); //用n个字符c赋给当前字符串<br>
=====字符串拼接=====
//字符串拼接 append（ ， ） 参数1为拼接内容，参数2为取前几个字符
#include<iostream>
using namespace std;
void test01()
{
string str1 = "我";
str1 += "爱科研";
cout << "str1= " << str1 << endl;
str1 += '!';
cout << "str1= " << str1 << endl;
string str2 = "UE c++";
str1 += str2;
cout << "str1= " << str1 << endl;
string str3 = "I ";
str3.append("love ");
cout << "str3= " << str3 << endl;
str3.append("ccc xxx sss", 4); //取前四个字符，空格也算一个字符
cout << "str3= " << str3 << endl;
str3.append(str2);
cout << "str3= " << str3 << endl;
str3.append(str2, 0, 2); //拼接str2,参数1是拼接的对象，参数2是拼接截取的起始位置，参数3是截取的字符个数
cout << "str3= " << str3 << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
=====字符串的查找与替换=====
//字符串的查找
#include<iostream>
using namespace std;
//字符串的查找
void test1()
{
string str1 = "lxkcxs";
int pos = str1.find('c');
if (pos == -1)
{
cout << "未找到相关内容" << endl;
}
else
{
cout << "找到相关内容 pos= " << pos << endl;
}
int pos2 = str1.rfind('x'); //rfind是查询内容的最后出现位置
cout << "pos2= " << pos2 << endl;
}
//字符串的替换
void test2()
{
string str2 = "aaabbbccc";
str2.replace(2, 2, "1111"); //参数1是替换起始位置，参数2是替换字符个数，参数3是要替换的内容，内容都会替换进去
cout << "str2= " << str2 << endl;
}
int main()
{
test1();
test2();
system("pause");
return 0;
}
=====字符串比较=====
功能描述：字符串之间的比较<br>
比较方式：字符串比较是按字符的ASCII码进行对比<br>
=返回 0；>返回 1；<返回-1<br>
函数原型：<br>
int compare(const string &s) const; //与字符串s比较<br>
int compare(const char *s) const; //与字符串s比较<br>
//字符串的比较
#include<iostream>
using namespace std;
void test()
{
string str1 = "lxk";
string str2 = "cxk";
if (str1.compare(str2) == 0)
{
cout << "str1 等于 str2" << endl;
}
else if (str1.compare(str2) > 0)
{
cout << "str1 大于 str2" << endl;
}
else if (str1.compare(str2) < 0)
{
cout << "str1 小于 str2" << endl;
}
}
int main()
{
test();
system("pause");
return 0;
}
=====string字符存取=====
string中单个字符存取方式有两种<br>
char& operator[ ](int n); //通过[]方式取字符<br>
char& at(int n); //通过at方法获取字符<br>
//字符串存取
#include<iostream>
using namespace std;
void test()
{
string str = "hello";
//通过[]访问单个字符
for (int i = 0; i < str.size(); i++)
{
cout << str[i] << " " << endl;
}
//通过at方式访问单个字符
for (int i = 0; i < str.size(); i++)
{
cout << str.at(i) << endl;
}
//修改单个字符
str[0] = 'x';
str.at(1) = 'x';
}
int main()
{
test();
system("pause");
return 0;
}
=====string插入和删除=====
//string插入和删除
#include<iostream>
using namespace std;
void test()
{
string str = "hello";
//插入
str.insert(1, "111"); //insert函数的参数1是插入位置，参数2是插入内容
cout << "str= " << str << endl;
//删除
str.erase(1, 3); //erase函数的参数1是删除开始位置，参数2是删除的字符个数
}
int main()
{
test();
system("pause");
return 0;
}
=====string子串=====
功能描述：从字符串中获得想要的子串<br>
函数原型：string substr(int pos = 0,int n = npos) const; //返回由pos开始的n个字符组成的字符串<br>
//string子串
include<iostream>
using namespace std;
void test()
{
string str = "asdfgh";
string subStr = str.substr(1, 3); //substr函数的参数1是子串截取起始位置，参数2是截取的字符个数
cout << "subStr= " << subStr << endl;
}
//实用操作
void email()
{
string email = "xk_li@bupt.edu.cn";
int pos = email.find('@');
string Name = email.substr(0, pos);
cout << "邮箱的主人是 " << Name << endl;
}
int main()
{
test();
email();
system("pause");
return 0;
}
=====vector容器=====
vector基本概念<br>
功能：vector数据结构和数组非常相似，也称为单端数组<br>
vector与普通数组区别：不同之处在于数组是静态空间，而vector可以动态扩展<br>
动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间<br>
======vector构造函数======
函数原型：<br>
vector<T> v; //采用模板实现类实现，默认构造函数<br>
vector(v.begin( ), v.end( ) ); // 将v[begin(),end())区间中的元素拷贝给本身<br>
vector(n, elem); //构造函数将n个elem拷贝给本身<br>
vector(const vector &vec); //拷贝构造函数<br>
//vector容器构造函数
#include<iostream>
using namespace std;
#include<vector>
void printVector(vector<int> &v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " " ;
}
cout << endl;
}
void test01()
{
vector<int> v1; //默认构造 无参构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
vector<int> v2(v1.begin(), v1.end()); //通过区间方式进行构造
vector<int> v3(10, 100); //n个elem方式构造,参数1是插入内容，参数2是个数
vector<int> v4(v3); //拷贝构造函数
printVector(v1);
printVector(v2);
printVector(v3);
printVector(v4);
}
int main()
{
test01();
system("pause");
return 0;
}
======vector赋值操作======
给vector容器进行赋值<br>
函数原型<br>
vector& operator=( const vector &vec); //重载等号操作符<br>
assign(beg,end); //将[beg,end）区间中的数据拷贝赋值给本身<br>
assign(n,elem); //将n个elem拷贝给本身<br>
//vector容器赋值操作
#include<iostream>
using namespace std;
#include<vector>
void printVector(vector<int>& v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
vector<int> v1; //默认构造 无参构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
//直接等号赋值
vector<int> v2;
v2 = v1;
printVector(v2);
//assign
vector<int> v3;
v3.assign(v1.begin(), v1.end());
printVector(v3);
//n个elem方式赋值
vector<int> v4;
v4.assign(10, 100);
printVector(v4);
}
int main()
{
test01();
system("pause");
return 0;
}
======vector容量和大小======
函数原型<br>
empty(); //判断容器是否为空 <br>
capacity(); //容器的容量<br>
size(); //返回容器中元素的个数<br>
resize(int num); //重新制定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除<br>
resize(int num,elem); //重新制定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除<br>
======vector的插入与删除======
函数原型：<br>
push_back(ele); //尾部插入ele<br>
pop_back(); //删除最后一个元素<br>
insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele<br>
insert(const_iterator pos,int count,ele); //迭代器指向位置pos插入count个元素ele<br>
erase(const_iterator pos); //删除迭代器指向元素<br>
erase(const_iterator start,const_iterator end); //删除迭代器从start到end之间的元素<br>
clear(); //删除容器中所有元素<br>
======vector数据存取======
函数原型：<br>
at(int idx); //返回索引idx所指的数据<br>
operator[]; //返回索引idx所指的数据<br>
front(); //返回容器中第一个数据元素<br>
back(); //返回容器中最后一个数据元素<br>
//vector数据存取
#include<iostream>
using namespace std;
#include<vector>
void printVector(vector<int>&v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " " ;
}
cout << endl;
}
void test01()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i + 2);
}
printVector(v1);
//利用[]方式访问数组中的元素
for (int j = 0; j < v1.size(); j++)
{
cout << v1[j] << " ";
}
cout << endl;
//利用at方式访问元素
for (int k = 0; k < v1.size(); k++)
{
cout << v1.at(k) << " ";
}
cout << endl;
//获取第一个元素
cout << "第一个元素为：" << v1.front() << endl;
//获取最后一个元素
cout << "最后一个元素为：" << v1.back() << endl;
}
int main()
{
test01();
system("pause");
return 0;
======vector互换容器======
函数原型：<br>
swap（vec）； //将vec与本身的元素互换<br>
v1.swap(v2); //v1和v2元素互换<br>
巧用swap收缩内存 vector<int>(v).swap(v);v
======vector预留空间======
功能描述：减少vector在动态扩展容量时的扩展次数<br>
函数原型： reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问<br>
=====deque容器=====
： 双端数组，可以对头端进行插入删除操作<br>
deque容器的迭代器也是支持随机访问的<br>
（函数接口基本同vector容器的构造函数）<br>
======deque构造函数======
函数原型：<br>
deque<T>deqT; //默认构造形式<br>
deque(beg,end); //构造函数将[beg,end]区间中的元素拷贝给本身<br>
deque(n,elem); //构造函数将n个elem拷贝给本身<br>
deque(const deque &deq); //拷贝构造函数<br>
======deque赋值操作======
函数原型：<br>
deque& operator=(const deque &deq); //重载等号操作符<br>
assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给本身<br>
assign(n,elem); //将n个elem拷贝赋值给本身<br>
//deque构造函数
#include<iostream>
using namespace std;
#include<deque>
void printDeque(const deque<int> &d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
//等号赋值
deque<int> d2;
d2 = d1;
printDeque(d2);
//assign赋值
deque<int> d3;
d3.assign(d1.begin(), d1.end());
printDeque(d3);
//n个elem赋值
deque<int> d4;
d4.assign(10, 100);
printDeque(d4);
}
int main()
{
test01();
system("pause");
return 0;
}
======deque大小操作======
函数原型：<br>
deque.empty(); //判断容器是否为空 <br>
deque.size(); //容器的容量<br>
deque.resize(num); //重新制定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除<br>
deque.resize(num,elem); //重新制定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除<br>
======deque插入和删除======
函数原型：<br>
push_back(elem); //在容器尾部添加一个数据<br>
push_front(elem); //在容器头部插入一个数据<br>
pop_back(); //删除容器最后一个数据<br>
pop_front(); //删除容器第一个数据<br>
指定位置操作： <br>
insert（pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置<br>
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值<br>
insert(pos,beg,end); //在pos位置插入[beg,end]区间的数据，无返回值<br>
clear(); //清空容器的所有数据<br>
erase(beg,end); //删除[beg,end]区间的数据，返回下一个数据的位置<br>
erase(pos); //删除pos位置的数据，返回下一个数据的位置<br>
======deque数据存取======
函数原型：<br>
at(int idx); //返回索引idx所指的数据<br>
operator[]; //返回索引idx所指的数据<br>
front(); //返回容器中第一个数据元素<br>
back(); //返回容器中最后一个数据元素<br>
======deque排序======
sort(d.begin(),d.end()); 使用算法sort需要包含algorithm头文件 默认排序规则从小到大的升序
//sort排序
#include<iostream>
using namespace std;
#include<deque>
#include<algorithm> //标准算法头文件
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test1()
{
deque<int> d1;
d1.push_back(10);
d1.push_back(20);
d1.push_back(30);
d1.push_front(100);
d1.push_front(300);
d1.push_front(200);
cout << "排序前： " << endl;
printDeque(d1);
cout << "排序后： " << endl;
sort(d1.begin(), d1.end()); //排序 默认排序规则从小到大的升序
}
int main()
{
test1();
system("pause");
return 0;
}
====stack容器=====
stack是一种先进后出的数据结构，它只有一个出口<br>
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为<br>
栈中进入数据为——入栈push<br>
栈中弹出数据为——出栈pop<br>
栈可以判断容器是否为空吗？可以 empty()<br>
栈可以返回元素个数吗？ 可以 size()<br>
======stack常用接口======
构造函数：<br>
stack<T> stk; //stack采用模板类实现，stack对象的默认构造形式<br>
stack(const stack &stk); //拷贝构造函数<br>
赋值操作：stack& operator= (const stack &stk); //重载等号操作符<br>
数据存取：<br>
push(elem); //向栈顶添加元素<br>
pop(); //从栈顶移除第一个元素（出栈）<br>
top(); //返回栈顶元素<br>
大小操作：<br>
empty(); //判断堆栈是否为空<br>
size(); //返回栈的大小<br>
//stack容器常用接口的使用
#include<iostream>
using namespace std;
#include<stack>
void test01()
{
stack<int> s;
s.push(10);
s.push(20);
s.push(30);
s.push(40);
while (!s.empty())
{
cout << "栈顶的元素为： " << s.top() << endl; //查看栈顶元素
s.pop(); //出栈
}
cout <<"栈的大小 "<< s.size() << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
=====queue容器=====
概念：queue是一种先进先出的数据结构，它有两个出口<br>
队列容器允许从一端新增元素，从另一端移除元素<br>
队列中只有对头和队尾才可以被外界使用，因此队列不允许有遍历行为<br>
队列中进数据称为 入队push<br>
队列出数据称为 出队pop<br>
queue只有队头和队尾能被外界访问，所以不允许有遍历行为<br>
======queue常用接口======
构造函数：<br>
queue<T> que; //queue采用模板类实现，queue对象的默认构造形式<br>
queue(const queue &que); //拷贝构造函数<br>
赋值操作：<br>
queue& operator= (const queue &que); //重载等号操作符<br>
数据存取：<br>
push(elem); //往队尾添加元素<br>
pop(); //从队头移除第一个元素<br>
back(); //返回最后一个元素<br>
front(); //返回第一个元素<br>
大小操作：<br>
empty(); //判断堆栈是否为空<br>
size(); //返回栈的大小<br>
//queue容器常用接口
#include<iostream>
using namespace std;
#include<queue>
class Person
{
public:
Person(string name,int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
void test01()
{
queue<Person> q;
Person p1("张三", 30);
Person p2("李四", 36);
Person p3("王五", 22);
Person p4("赵六", 20);
q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);
while (!q.empty())
{
//查看队头元素
cout <<"队头数据元素------姓名： " << q.front().m_Name <<" "<<"年龄： "<<q.front().m_Age<< endl;
//查看队尾元素
cout << "队尾数据元素-------姓名： " << q.back().m_Name << " " << "年龄： " << q.back().m_Age << endl;
q.pop();
}
cout << "队列大小： " << q.size() << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
=====list容器=====
功能：将数据进行链式存储<br>
链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的<br>
链表是由一系列结点组成的<br>
结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点的指针域<br>
优点：可以对任意位置进行快速插入和删除元素<br>
缺点：容器的遍历速度没有数组快，占用空间比数组大<br>
STL中的链表是一个双向循环链表<br>
======list构造函数======
//list构造函数
#include<iostream>
using namespace std;
#include<list>
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test1()
{
list<int>L1; //默认构造
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);
list<int> L2(L1.begin(), L1.end());
printList(L2);
list<int>L3(10, 100);
printList(L3);
list<int> L4(L3);
printList(L4);
}
int main()
{
test1();
system("pause");
return 0;
}
======list赋值和交换======
等号赋值<br>
assign函数<br>
swap函数进行交换<br>
</pr赋值和交换操作
//类型
#include<iostream>
using namespace std;
#include<list>
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test1()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
list<int>L2;
L2 = L1; //等号赋值
list<int>L3;
L3.assign(L2.begin(), L2.end());
list<int> L4;
L4.assign(10,100);
printList(L1);
printList(L2);
printList(L3);
printList(L4);
}
void test2()
{
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);
L1.swap(L2);
printList(L1);
printList(L2);
}
int main()
{
test1();
test2();
system("pause");
return 0;
}
======list大小操作======
list.empty(); //判断容器是否为空 <br>
list.size(); //容器的容量<br>
list.resize(num); //重新制定容器的长度为num，若容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除<br>
list.resize(num,elem); //重新制定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除<br>
======list插入和删除======
push_back(elem); //在容器尾部加入一个元素<br>
pop_back(); //删除容器中最后一个元素<br>
push_front(); //在容器开头插入一个元素<br>
pop_front(); //从容器开头移除一个元素<br>
insert(pos,elem); //在pos位置插入elem元素的拷贝，返回新数据的位置<br>
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值<br>
insert(pos,beg,end); //在pos位置插入[beg,end]区间的数据，无返回值<br>
clear(); //移除容器的所有数据<br>
erase(beg,end); //删除[beg,end]区间的数据，返回下一个数据的位置<br>
erase(pos); //删除pos位置的数据，返回下一个数据的位置<br>
remove(elem); //删除容器中所有与elem值匹配的元素<br>
======list数据存取======
函数原型：<br>
front(); //返回第一个元素<br>
back(); //返回最后一个元素<br>
======list反转和排序======
函数原型:<br>
reverse(); //反转链表<br>
sort(); //链表排序<br>
//list反转和排序
#include<iostream>
using namespace std;
#include<list>
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
//反转
list<int>L1;
L1.push_back(20);
L1.push_back(5);
L1.push_back(55);
L1.push_back(40);
cout << "反转前：" << endl;
printList(L1);
L1.reverse();
cout << "反转后：" << endl;
printList(L1);
}
bool myCompare(int v1,int v2)
{
//降序，就让第一个数>第二个数
return v1 > v2;
}
void test02()
{
//排序
list<int>L1;
L1.push_back(20);
L1.push_back(5);
L1.push_back(55);
L1.push_back(40);
cout << "排序前：" << endl;
printList(L1);
/*
所有不支持随机访问迭代器的容器，不可以用标准算法
不支持随机访问迭代器的容器，内部会提供对应一些算法
*/
L1.sort(); //默认排序规则 从小到大 升序
cout << "排序后：" << endl;
printList(L1);
L1.sort(myCompare); //降序操作
printList(L1);
}
int main()
{
test01();
system("pause");
return 0;
}
=====set/mutliset容器=====
所有元素都会在插入时自动排序<br>
本质：set/mutliset是属于关联式容器，地层结构是用二叉树实现<br>
======set和mutliset的区别======
set不允许容器中有重复的元素<br>
mutliset允许容器中有重复的元素<br>
======构造======
set<T> st; //默认构造函数<br>
set(const set &st); //拷贝构造函数<br>
======赋值======
set& operator=(const set &st); //重载等号操作符<br>
插入数据只有insert()方式<br>
======set大小和交换======
size(); //返回容器中元素的数目<br>
empty(); //判断容器是否为空<br>
swap(st); //交换两个集合容器<br>
======set插入和删除======
函数原型：<br>
insert(elem); //在容器中插入元素<br>
clear(); //清除所有数据<br>
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器<br>
erase(beg,end); //删除区间[beg,end]的所有元素，返回下一个元素的迭代器<br>
erase(elem); //删除容器中值为elem的元素<br>
======set查找和统计======
函数原型：<br>
find(key); //查找key是否存在，若存在，返回该键的迭代器；若不存在，返回set.end();<br>
count(key); //统计key的元素个数<br>
//查找和统计
#include<iostream>
using namespace std;
#include<set>
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test1()
{
//查找
set<int> s1;
s1.insert(20);
s1.insert(30);
s1.insert(10);
s1.insert(50);
printSet(s1);
set<int>::iterator pos = s1.find(30);
if (pos != s1.end())
{
cout << "找到元素：" <<* pos << endl;
}
else {
cout << "未找到元素：" << *pos << endl;
}
}
void test2()
{
//统计
set<int> s1;
s1.insert(20);
s1.insert(30);
s1.insert(10);
s1.insert(50);
int num = s1.count(30);
cout << "num= " << num << endl;
}
int main()
{
test1();
test2();
system("pause");
return 0;
}
======pair对组创建======
功能描述：成对出现的数据，利用对组可以返回两个数据<br>
两种创建方式：<br>
pair<type,type> p (value1,value2); <br>
pair<type,type> p =make_pair(value1,value2);<br>
//pair对组创建
#include<iostream>
using namespace std;
void test1()
{
//第一种方式创建对组
pair<string, int>p("Tom", 22);
//第二种方式创建对组
pair<string, int>p2 = make_pair("Tim", 33);
cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;
}
int main()
{
test1();
system("pause");
return 0;
}
======set容器排序======
利用仿函数可以改变排序规则<br>
//存放内置数据类型
#include<iostream>
using namespace std;
#include<set>
void printSet(set<int>& s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
class myCompare //创建一个类，返回一个数大于另一个数为真
{
public:
bool operator()(int v1, int v2) //仿函数
{
return v1 > v2;
}
};
void test1()
{
set<int> s1;
s1.insert(20);
s1.insert(40);
s1.insert(10);
s1.insert(30);
printSet(s1);
set<int> s2; //指定排序规则为从大到小
s2.insert(20);
s2.insert(40);
s2.insert(10);
s2.insert(30);
for (set<int, myCompare>::iterator it = s2.begin(); it != s2.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//存放自定义数据类型
#include<iostream>
using namespace std;
#include<set>
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
class comparePerson
{
public:
bool operator()(const Person& p1, const Person& p2)const
{
return p1.m_Age > p2.m_Age;
}
};
void test1()
{
//自定义数据类型 都会指定排序规则
set<Person,comparePerson>s;
Person p1("刘备", 25);
Person p2("关羽", 23);
Person p3("张飞", 22);
Person p4("赵云", 26);
s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);
for (set<Person,comparePerson>::iterator it = s.begin(); it != s.end(); it++)
{
cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age <<endl ;
}
}
int main()
{
test1();
system("pause");
return 0;
}
=====map/mutlimap容器=====
map容器中所有元素都是pair<br>
pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）<br>
所有元素都会根据元素的键值自动排序<br>
map/mutlimap属于关联式容器，底层结构是用二叉树实现<br>
优点：可以根据key值快速找到value值<br>
======map和mutlimap区别：======
map不允许容器中有重复key值元素<br>
mutlimap允许有重复key值元素<br>
======map构造和赋值======
函数原型：<br>
构造：<br>
map<T1,T2>map; //map默认构造函数<br>
map(const map &mp); //拷贝构造函数<br>
赋值：<br>
map& operator=(const map &mp); //重载符号操作符<br>
//map容器构造和赋值
#include<iostream>
using namespace std;
#include<map>
void printMap(map<int,int> &m)
{
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
{
cout <<"key= "<< (*it).first << " value= "<<it->second<<endl;
}
cout << endl;
}
void test()
{
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;
m3 = m2;
printMap(m3);
}
int main()
{
test();
system("pause");
return 0;
}
======map大小和交换======
函数原型：<br>
size(); //返回容器中元素的数目<br>
empty(); //判断容器是否为空<br>
swap(mp); //交换两个集合容器<br>
======map插入和删除======
函数原型：<br>
insert(elem); //在容器中插入元素<br>
clear(); //清除所有元素<br>
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器<br>
erase(beg,end); //删除区间[beg,end]的所有元素，返回下一个元素的迭代器<br>
erase(key); //删除容器中值为key的元素<br>
//插入和删除
#include<iostream>
using namespace std;
#include<map>
void printMap(map<int, int>& m)
{
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
{
cout << "key= " << (*it).first << " value= " << it->second << endl;
}
cout << endl;
}
void test01()
{
map<int, int> m1;
//插入 第一种
m1.insert(pair<int, int>(1, 10));
//插入 第二种
m1.insert(make_pair(2, 20));
//插入 第三种
m1.insert(map<int, int>::value_type(3, 30));
//插入 第四种
m1[4] = (40);
printMap(m1);
//删除
m1.erase(m1.begin());
m1.erase(3);
m1.erase(m1.begin(), m1.end());
m1.clear();
}
int main()
{
test01();
system("pause");
return 0;
}
======map查找和统计======
函数原型：<br>
find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();<br>
count(key); //统计key的元素个数<br>
//查找和统计
#include<iostream>
using namespace std;
#include<map>
void test01()
{
map<int, int> m;
m.insert(make_pair(1, 10));
m.insert(make_pair(2, 20));
m.insert(make_pair(3, 30));
m.insert(make_pair(4, 40));
map<int, int>::iterator pos = m.find(3);
if (pos != m.end())
{
cout << "查到了元素key= " << pos->first << " value= " << pos->second << endl;
}
else {
cout << " 未查到元素" << endl;
}
int num = m.count(2);
cout << "num= " << num << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
======map排序======
默认从小到大排序<br>
利用仿函数，可以改变排序规则<br>
//排序 利用仿函数实现从大到小排序
#include<iostream>
using namespace std;
#include<map>
class MyCompare
{
public:
bool operator()(int v1, int v2)
{
return v1 > v2;
}
};
void test()
{
map<int, int,MyCompare> m;
m.insert(make_pair(1, 10));
m.insert(make_pair(2, 20));
m.insert(make_pair(3, 30));
m.insert(make_pair(4, 40));
cout << "排序前" << endl;
for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++)
{
cout << "key= " << (*it).first << " value= " << it->second << endl;
}
cout << endl;
}
int main()
{
test();
system("pause");
return 0;
}
=====STL-函数对象=====
函数对象：重载函数调用操作符的类，其对象称为函数对象；函数对象使用重载的（）时，行为类似函数调用，也叫仿函数<br>
本质：函数对象（仿函数）是一个类，不是一个函数<br>
函数对象使用：<br>
特点：<br>
函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值<br>
函数对象超出普通函数的概念，函数对象有自己的状态<br>
函数对象可以作为参数传递<br>
=====谓词=====
返回bool类型的仿函数称为谓词<br>
如果operator()接受一个参数，那么叫做一元谓词<br>
//仿函数返回bool类型，参数为1是一元谓词
#include<iostream>
using namespace std;
#include<vector>
class GeaterFive
{
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的数字
vector<int>::iterator it = find_if(v.begin(), v.end(), GeaterFive()); //GeaterFive()匿名函数对象
if (it == v.end())
{
cout << "未找到" << endl;
}
else {
cout << "找到了大于5的数" << *it << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}
如果operator()接受两个参数，那么叫做二元谓词
//仿函数参数为2则为二元谓词
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class MyCompare
{
public:
bool operator()(int val1, int val2) //两个参数为二元谓词
{
return val1 > val2;
}
};
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
sort(v.begin(), v.end());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
//使用函数对象 改变算法策略 变为排序顺序为从大到小
sort(v.begin(), v.end(), MyCompare());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
=====泛型编程 模板=====
模板就是建立通用的模具，大大提高复用性<br>
模板的特点：<br>
模板不可以直接使用，它只是一个框架<br>
模板的通用并不是万能的<br>
c++另一种编程的思想称为泛型编程，主要利用的技术就是模板<br>
c++提供两种模板机制：函数模板和类模板<br>
======函数的模板语法======
函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表<br>
语法：<br>
template<typename T><br>
函数声明或定义<br>
template --声明创建模板<br>
typename --表面其后面的符号是一种数据类型，可以用class代替<br>
T --通用的数据类型，名称可以替换，通常为大写字母<br>
注意事项：<br>
自动类型推导，必须推导出一致的数据类型T，才可以使用<br>
模板必须要确定出T的数据类型，才可以使用<br>
//函数模板
#include<iostream>
using namespace std;
//函数模板
template<typename T> //声明一个模板，T是一个通用的函数模板
void Swap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 10;
int b = 20;
//利用函数模板进行交换
//两种方式使用函数模板
//1、自动类型推导
Swap(a, b);
cout << "a=" << a << " b=" << b << endl;
//2、显示指定类型
Swap<int>(a, b);
cout << "a=" << a << " b=" << b << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
======普通函数和函数模板的调用规则======
1、如果函数模板和普通函数都可以实现，优先调用普通函数<br>
2、可以通过空模板参数列表来强制调用函数模板<br>
3、函数模板也可以发生重载<br>
4.如果函数模板可以产生更好的匹配，优先调用函数模板<br>
======类模板======
类模板对象做函数参数<br>
一共有三种：<br>
1、指定传入的类型 --直接显示对象的数据类型<br>
2、参数模板化 ----将对象中的参数变为模板进行传递<br>
3、整个类模板化 ----将这个对象类型 模板化进行传递<br>
//类模板
#include<iostream>
using namespace std;
template<class NameType,class AgeType>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
void test01()
{
Person<string,int> p1("张三",22);
p1.showPerson();
}
int main()
{
test01();
system("pause");
return 0;
}
======类模板与继承======
当子类继承的父类是一个模板时，子类在声明的时候，要指定出父类中T的类型<br>
如果不指定，编译器无法给子类分配内存<br>
如果想灵活指定出父类中T的类型，子类也需变为类模板<br>
======类模板成员函数的类外实现======
//类模板的类外实现
#include<iostream>
#include<string>
using namespace std;
//类模板
template<class T1,class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPerson();
T1 m_Name;
T2 m_Age;
};
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
void test01()
{
Person<string, int> p1("张飒", 21);
p1.showPerson();
}
int main()
{
test01();
system("pause");
return 0;
}
======类模板的分文件编写======
分文件编写时包括头文件.h和源文件.cpp，调用标准库时include用< >，调用自己定义的库时include用“”
<br>
4723
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
