admin管理员组文章数量:1600302
本文为学习C++时做的笔记,参考视频为bilibili的黑马程序员的C++入门教程
一、面向对象
1. 对象的初始化和清理
1.1 深拷贝浅拷贝
**浅拷贝:**简单的拷贝赋值操作
- **带来的问题:**堆区内存重复释放
**深拷贝:**在堆区重新申请空间,进行拷贝操作
class Person {
public:
Person()
{
cout << "Person 默认构造函数调用" << endl;
}
Person(int age, int height)
{
m_Age = age;
//属性m_Height在堆区开辟
m_Height = new int(height);
cout << "Person 有参构造函数调用" << endl;
}
Person(const Person& p)
{
m_Age = p.m_Age;
m_Height = new int(*p.m_Height);
cout << "Person 拷贝构造函数调用" << endl;
}
~Person()
{
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "Person 析构函数调用" << endl;
}
int m_Age;
int* m_Height;
};
void test01()
{
Person p1(18, 160);
cout << "p1的年龄:" << p1.m_Age << "p1身高为:" << *p1.m_Height << endl;
Person p2(p1);
cout << "p2的年龄:" << p2.m_Age << "p2身高为:" << *p2.m_Height << endl;
}
**总结:**如果属性有在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题
1.2 初始化列表
**作用:**C++提供了初始化列表语法,用来初始化属性
class Person {
public:
//初始化列表属性
Person(int a, int b, int c):m_A(a),m_B(b),m_C(c)
{
cout << "Person 有参构造函数调用" << endl;
}
int m_A;
int m_B;
int m_C;
};
void test01()
{
Person p(10, 20, 30);
}
1.3 类对象作为类成员
类中的成员可以是另一个类的对象
class A {}
class B
{
A a;
}
B类中有对象A作为成员,A作为对象成员。
先构造A,再构造B。析构与构造顺序相反
1.4 静态成员
静态成员分为:
- 静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明,类外初始化
- 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量(不能访问非静态成员变量,无法区分到底是哪个对象的变量)
class Person
{
public:
//1.所有对象都共享同一份数据
//2.编译阶段就分配内存
//3.类内声明,类外初始化操作
static int m_A;
//静态成员变量也是有访问权限的
private:
static int m_B;
};
int Person::m_A = 100;
int Person::m_B = 200;
void test01()
{
Person p;
cout << p.m_A << endl;
Person p2;
p2.m_A = 200;
cout << p.m_A << endl;
}
void test02()
{
//静态成员变量不属于某个对象上,所有对象都共享同一份数据
//1.通过对象进行访问
Person p;
cout << p.m_A << endl;
//2.通过类名进行访问
cout << Person::m_A << endl;
}
2. C++对象模型和this指针
2.1 成员变量和成员函数分开存储
在c++中,类的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上
注:
- c++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置,即每个空对象也应有一个独一无二的内存地址
- 静态成员变量,不属于类对象上
- 非静态成员函数,不属于类对象上
- 静态成员函数,不属于类的对象上
2.1 this指针概念
**this指针的作用:**指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义,直接使用即可
this指针的用途:
- 当形参和成员变量同名时,可用this指针来区分
- 在类的非静态成员函数中返回对象本身,可使用
return *this
class Person
{
public:
Person(int age)
{
this->age = age;
}
Person& PersonAddAge(Person &p)
{
this->age += p.age;
//this指向p2的指针,而*this指向的就是p2这个对象本体
return *this;
}
int age;
};
void test01()
{
Person p = Person(18);
cout << "p1的年龄为:" << p.age << endl;
}
void test02()
{
Person p1(10);
Person p2(10);
//链式编程思想
p2.PersonAddAge(p1).PersonAddAge(p1);
cout << "p2的年龄为:" << p2.age << endl;
}
2.2 空指针访问成员函数
C++中空指针也是可以调用成员函数的,但要注意有没有用到this指针
如果用到this指针,需要加以判断保证代码的健壮性
class Person
{
public:
void showClassName()
{
cout << "this is Person class" << endl;
}
void showPersonAge()
{
if (this == NULL)
return;
//报错原因是因为传入的指针为NULL
cout << "age = " << this->m_Age << endl;
}
int m_Age;
};
void test01()
{
Person* p = NULL;
//p->showClassName();
p->showPersonAge();
}
2.3 const 修饰成员函数
常函数:
- 成员函数后加const后我们称这个函数为常函数
- 常函数内不可以修改成员属性
- 成员属性声明时加关键字mutable后,在常函数中依然可以修改
常对象:
- 声明对象前加 const称该对象为常对象
- 常对象只能调用常函数
#include<iostream>
using namespace std;
class Person
{
public:
//this指针的本质是指针常量,指针的指向是不可以修改的
//在成员函数后面加const,修饰的是this指向,让指针指向的值也不可以修改
void showPerson() const
{
this->m_Age = 100; //不可修改
this->m_B = 100;
}
void func()
{
}
int m_Age;
mutable int m_B; //加了关键字mutable之后,即使在常函数中,也可以修改这个值
};
//常对象
void test02()
{
const Person p; //在对象前加const,变为常对象
//p.m_Age = 100;
p.m_B = 100; //m_B是特殊值,在常对象下也可以修改
p.func(); //常对象 不可以调用普通成员函数,因为普通成员函数可以修改属性
}
3. 友元
友元关键字为friend
友元的三种实现
- 全局函数做友元
- 类做友元
- 成员函数做友元
3.1 全局函数做友元
class Building
{
//goodGay全局函数是Building的朋友,可以访问Building中私有成员
friend void goodGay(Building* building);
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//全局函数
void goodGay(Building *building)
{
cout << "好基友全局函数正在访问:" << building->m_SittingRoom << endl;
cout << "好基友全局函数正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
Building building;
goodGay(&building);
}
3.2 类做友元
class Building;
class GoodGay
{
public:
GoodGay();
void visit(); //参观函数,访问Building种的属性
Building* building;
};
class Building
{
friend class GoodGay;
public:
Building();
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//类外写成员函数
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
building = new Building;
}
void GoodGay::visit()
{
cout << "好基友正在访问:" << building->m_SittingRoom << endl;
cout << "好基友正在访问:" << building->m_BedRoom << endl;
}
void test01()
{
GoodGay gg;
gg.visit();
}
3.3 成员函数做友元
class GoodGay
{
public:
GoodGay();
void visit(); //让visit函数可以访问Building中私有成员
void visit2(); //让visit函数不可以访问Building中私有成员
Building* building;
};
class Building
{
//Goodgay类下的visit成员函数作为本类的好朋友,可以访问私有成员
friend void GoodGay::visit();
public:
Building();
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//类外写成员函数
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
building = new Building;
}
void GoodGay::visit()
{
cout << "好基友正在访问:" << building->m_SittingRoom << endl;
cout << "好基友正在访问:" << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
cout << "好基友正在访问:" << building->m_SittingRoom << endl;
//cout << "好基友正在访问:" << building->m_BedRoom << endl;
}
4.运算符重载
运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
4.1 加号运算符重载
作用:实现两个自定义数据类型相加的运算
class Person
{
public:
//1、成员函数重载+号
/*Person operator+(Person& p)
{
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}*/
int m_A;
int m_B;
};
//2、全局函数重载+号
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;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
//成员函数重载本质调用
//Person p3 = p1.operator+(p2);
// 全局函数重载本质调用
//Person p3 = operator+(p1, p2);
Person p3 = p1 + p2;
//运算符重载也可以发生函数重载
Person p4 = p1 + 10;
cout << "p3.m_A = " << p3.m_A << endl;
cout << "p3.m_B = " << p3.m_B << endl;
}
- 总结1:对于内置数据类型的表达式的运算符是不可能改变的
- 总结2:不要滥用运算符重载
4.2 左移运算符的重载
class Person
{
friend ostream& operator<<(ostream& cout, Person p);
public:
Person(int a, int b)
{
m_A = a;
m_B = b;
}
private:
//利用成员函数重载,返回左移运算符
//一般不会利用成员函数来重载<<,因为无法实现cout在左侧
int m_A;
int m_B;
};
//只能利用全局函数重载左移运算符
ostream & operator<<(ostream &cout, Person p) //本质 operator<<(cout, p),简化cout << p
{
cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
return cout;
}
void test01()
{
Person p(10, 10);
cout << p << endl;
}
- 总结:重载左移运算符配合友元可以实现输出自定义数据类型
4.3 递增运算符重载
**作用:**通过重载递增运算符,实现自己的整形数据
class myInteger
{
friend ostream& operator<<(ostream& cout, myInteger myint);
public:
myInteger()
{
m_Num = 0;
}
//重载前置++运算符,返回引用为了一直对一个数据进行递增操作
myInteger& operator++()
{
m_Num++;
return *this;
}
//重载后置++运算符,int代表站位参数,可以用于区分前置和后置递增
myInteger operator++(int)
{
myInteger temp = *this;
m_Num++;
return temp;
}
private:
int m_Num;
};
ostream& operator<<(ostream& cout, myInteger myint)
{
cout << myint.m_Num;
return cout;
}
- **注:**前置递增返回引用,后置递增返回值
4.4 赋值运算符重载
C++编译器至少给一个类添加4个函数
- 默认构造函数(无参,函数体为空)
- 默认析构函数(无参,函数体为空)
- 默认拷贝构造函数,对属性值进行拷贝
- 赋值运算符 operator=,对属性值进行拷贝
如果类中有属性指向堆区,做赋值操作时也会出现深浅拷贝问题
class Person
{
public:
Person(int age)
{
m_Age = new int(age);
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
//重载赋值运算符
Person& operator=(Person &p)
{
//编译器提供浅拷贝
//m_Age = p.m_Age;
//应该先判断是否有属性在堆区,如果有先释放干净,然后再深拷贝
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
m_Age = new int(*p.m_Age);
//返回对象本身
return *this;
}
int* m_Age;
};
void test01()
{
Person p1(18);
Person p2(20);
Person p3(30);
p3 = p2 = p1;
cout << "p1的年龄为:" << *p1.m_Age << endl;
cout << "p2的年龄为:" << *p2.m_Age << endl;
cout << "p3的年龄为:" << *p3.m_Age << endl;
}
4.5 关系运算符重载
**作用:**重载关系运算符,可以让两个自定义类型对象进行对比操作
class Person
{
public:
Person(string name, int age)
{
m_Name = name;
m_Age = age;
}
bool operator==(Person p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
return false;
}
bool operator!=(Person p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return false;
}
return true;
}
string m_Name;
int m_Age;
};
4.6 函数调用运算符重载
- 函数调用运算符 () 也可以重载
- 由于重载后使用的方式非常像函数的调用,因此成为仿函数
- 仿函数没有固定写法,非常灵活
class MyPrint
{
public:
void operator()(string text)
{
cout << text << endl;
}
};
void test01()
{
MyPrint myPrint;
myPrint("Hello world"); //由于使用起来非常类似于函数调用,因此成为仿函数
//匿名函数对象
cout << MyAdd()(100, 100) << endl;
}
5 继承
5.1 继承的基本语法
class BasePage
{
public:
void header()
{
cout << "首页、公开课、登录、注册……(公共头部)" << endl;
}
};
//语法:class 子类 : 继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类
class Java : public BasePage
{
public:
void content()
{
cout << "Java学科视频" << endl;
}
};
class CPP : public BasePage
{
public:
void content()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
cout << "Java下载视频页面如下:" << endl;
Java ja;
ja.header();
ja.content();
cout << "------------------" << endl;
cout << "c++下载视频页面如下:" << endl;
CPP cpp;
cpp.header();
cpp.content();
}
5.2 继承的方式
- **public: **
- 父类中的公共权限成员,到子类中依然是公共权限
- 父类中的保护权限成员,到子类中依然是保护权限
- 父类中的私有权限成员,子类访问不到
- **protected: **
- 父类中的公共权限成员和保护权限成员,到子类中变为保护权限
- 父类中的私有权限成员,子类访问不到
- **private: **
- 父类中的公共权限成员和保护权限成员,到子类中变为私有权限
- 父类中的私有权限成员,子类访问不到
5.3 继承中的对象模型
- 父类中所有非静态成员属性都会被子类继承下去;
- 父类中私有成员属性,被编译器给隐藏了,因此访问不到,但确实是被继承下去了;
- 利用开发人员命令提示工具查看对象模型:跳转文件路径 cd
c l / d 1 r e p o r t S i n g l e C l a s s L a y o u t 类名 " 文件名 " cl /d1 reportSingleClassLayout类名 "文件名" cl/d1reportSingleClassLayout类名"文件名"
5.4 继承同名成员处理方式
情景:当子类与父类出现同名的成员,如何通过子类对象,访问到子类或者父类中同名的数据呢?
- 访问子类同名成员,直接访问即可
- 访问父类同名成员,需要加作用域
class Base
{
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "Base - func" << endl;
}
void func(int a)
{
cout << "Base - func(int a)" << endl;
}
int m_A;
};
class Son : public Base
{
public:
Son()
{
m_A = 200;
}
void func()
{
cout << "Son - func" << endl;
}
int m_A;
};
void test01()
{
Son s;
cout << "Son 下 m_A = " << s.m_A << endl;
//如果通过子类对象访问到父类中同名成员,需要加作用域
cout << "Base 下 m_A = " << s.Base::m_A << endl;
}
void test02()
{
Son s;
s.func(); //直接调用,调用是子类中的同名成员
s.Base::func();
//如果子类中出现和父类同名成员函数,子类的同名成员函数,会隐藏掉父类中所有同名成员函数
s.Base::func(100);
}
5.5 同名静态成员处理
-
静态成员和非静态成员出现同名,处理方式一致。
-
通过类名访问
cout << "Son 下m_A = " << Son::m_A << endl; //第一个双冒号代表通过类名方式访问 第二个双冒号代表访问父类作用域下 cout << "Base 下m_A = " << Son::Base::m_A << endl;
5.6 多继承语法
C++允许一个类继承多个类
语法: c l a s s 子类 : 继承方式父类 1 , 继承方式父类 2 … class 子类 : 继承方式 父类1 , 继承方式 父类2 … class子类:继承方式父类1,继承方式父类2…
多继承可能会引发父类中有同名成员出现,需要加作用域区分
C++实际开发中不建议使用多继承
class Base1
{
public:
Base1()
{
m_A = 100;
}
int m_A;
};
class Base2
{
public:
Base2()
{
m_A = 200;
}
int m_A;
};
class Son : public Base1, public Base2
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test1()
{
Son s;
cout << "sizeof Son = " << sizeof(s) << endl;
//当父类出现同名成员,需要加作用域区分
cout << "m_A = " << s.Base1::m_A << endl;
cout << "m_A = " << s.Base2::m_A << endl;
}
5.7 菱形继承
菱形继承概念:
- 两个派生类继承同一个基类
- 又有某个类同时继承两个派生类
菱形继承问题:
- 羊继承了动物的数据,驼同样继承了动物的数据,当草泥马使用数据时,就会产生二义性
- 草泥马继承自动物的数据继承了两份,但其实这份数据我们只需继承一份就可以
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 = 18;
st.Tuo::m_Age = 28;
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
cout << "st.m_Age = " << st.m_Age << endl;
}
6 多态
6.1 多态的基本概念
多态是C++面向对象三大特性之一
多态分为两类:
- 静态多态:函数重载和运算符重载属于静态多态,复用函数名
- 动态多态:函数重写,派生类和虚函数实现运行时多态
静态多态和动态多态的区别
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
class Animal
{
public:
virtual void speak()
{
cout << "动物在说话" << endl;
}
};
class Cat : public Animal
{
public:
void speak()
{
cout << "小猫在说话" << endl;
}
};
//如果想执行让猫说话,这个函数地址就不能提前绑定,需要在运行阶段进行绑定,地址晚绑定
//动态多态满足条件
//1、有继承关系
//2、子类重写父类的虚函数
//动态多态使用
//父类的指针或者引用,指向子类对象
void doSpeak(Animal &animal) //Animal &animal = cat;
{
animal.speak();
}
void test01()
{
Cat cat;
doSpeak(cat);
}
总结:
多态满足条件:
- 有继承关系
- 子类重写父类中的虚函数
多态使用条件:
- 父类指针或引用指向子类对象
重写:子类函数返回值类型、函数名、参数列表与父类函数完全一致成为重写
6.2 纯虚函数和抽象类
在多态中,通常父类中虚函数的视线是毫无意义的,主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法:virtual 返回值类型 函数名(参数列表) = 0;
当类中有了纯虚函数,这个类也被称为抽象类
抽象类特点:
- 无法实例化对象
- 子类必须才重写抽象类中的纯虚函数,否则也属于抽象类
class Base
{
public:
virtual void func() = 0;
};
class Son :public Base
{
public:
virtual void func() {};
};
void test01()
{
//Son s; //子类必须要重写父类中的纯虚函数,否则无法实例化对象
Base* base = new Son;
base->func();
}
6.4 示例------->制作饮品
class AbstractDrinking
{
public:
virtual void Boil() = 0;
virtual void Brew() = 0;
virtual void PourInCup() = 0;
virtual void PutSomething() = 0;
void makeDrink()
{
Boil();
Brew();
PourInCup();
PutSomething();
}
};
//制作咖啡
class Coffee :public AbstractDrinking
{
virtual void Boil()
{
cout << "煮水" << endl;
}
virtual void Brew()
{
cout << "冲泡咖啡" << endl;
}
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
virtual void PutSomething()
{
cout << "加入糖和牛奶" << endl;
}
};
//制作茶叶
class Tea :public AbstractDrinking
{
virtual void Boil()
{
cout << "煮山泉水" << endl;
}
virtual void Brew()
{
cout << "冲泡茶叶" << endl;
}
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
virtual void PutSomething()
{
cout << "加入枸杞" << endl;
}
};
void doWork(AbstractDrinking* abs)
{
abs->makeDrink();
delete abs; //释放在堆区new的数据
}
void test01()
{
//制作咖啡
doWork(new Coffee);
cout << "-------------------------" << endl;
AbstractDrinking* tea = new Tea;
doWork(tea);
}
6.5 虚析构和纯虚析构
多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码
解决方式:将父类中的析构函数改为虚析构或纯虚析构
虚析构和纯虚析构共性:
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构区别:
- 如果是纯虚析构,该类属于抽象类,无法实例化对象
虚析构语法:virtual ~类名(){}
纯虚析构语法:virtual ~类名() = 0
类名::~类名(){}
class Animal
{
public:
Animal()
{
cout << "Animal的构造函数的调用" << endl;
}
//利用虚析构可以解决父类指针释放子类对象不干净的问题
/*virtual ~Animal()
{
cout << "Animal的析构函数的调用" << endl;
}*/
//纯虚析构,需要声明也需要实现
virtual ~Animal() = 0;
virtual void speak() = 0;
};
Animal::~Animal()
{
cout << "Animal的纯析构函数的调用" << endl;
}
class Cat : public Animal
{
public:
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;
}
}
string *m_Name;
};
void test01()
{
Animal* animal = new Cat("Tom");
animal->speak();
//父类指针在析构的时候,不会调用子类中析构函数,导致子类如果有堆区属性,出现内存泄漏
delete animal;
}
总结:
- 纯虚析构或虚析构就是用来解决通过父类指针释放子类对象
- 如果子类中没有堆区数据,可以不写纯虚析构或虚析构
- 拥有纯虚析构函数的类也属于抽象类
6.6 多态案例--------->电脑组装
class CPU
{
public:
virtual void caculate() = 0;
};
class VideoCard
{
public:
virtual void display() = 0;
};
class Memory
{
public:
virtual void stroage() = 0;
};
class Computer
{
public:
Computer(CPU* cpu, VideoCard* vc, Memory* mem)
{
m_cpu = cpu;
m_vc = vc;
m_mem = mem;
}
void work()
{
m_cpu->caculate();
m_vc->display();
m_mem->stroage();
}
~Computer()
{
if (m_cpu != NULL)
{
delete m_cpu;
m_cpu = NULL;
}
if (m_vc != NULL)
{
delete m_cpu;
m_vc = NULL;
}
if (m_mem != NULL)
{
delete m_cpu;
m_mem = NULL;
}
}
private:
CPU* m_cpu;
VideoCard* m_vc;
Memory* m_mem;
};
class IntelCPU : public CPU
{
public:
virtual void caculate()
{
cout << "Intel 的CPU开始计算了" << endl;
}
};
class IntelVideoCard : public VideoCard
{
public:
virtual void display()
{
cout << "Intel 的显卡开始显示了" << endl;
}
};
class IntelMemory : public Memory
{
public:
virtual void stroage()
{
cout << "Intel 的内存条开始存储了" << endl;
}
};
class LenovoCPU : public CPU
{
public:
virtual void caculate()
{
cout << "Lenovo的CPU开始计算了" << endl;
}
};
class LenovoVideoCard : public VideoCard
{
public:
virtual void display()
{
cout << "Lenovo的显卡开始显示了" << endl;
}
};
class LenovoMemory : public Memory
{
public:
virtual void stroage()
{
cout << "Lenovo的内存条开始存储了" << endl;
}
};
void test01()
{
CPU* intelCPU = new IntelCPU;
VideoCard* intelCard = new IntelVideoCard;
Memory* intelMem = new IntelMemory;
Computer* computer1 = new Computer(intelCPU, intelCard, intelMem);
computer1->work();
delete computer1;
cout << "---------------------" << endl;
cout << "第二台电脑开始工作" << endl;
Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
computer2->work();
delete computer2;
}
二、文件操作
C++中对文件操作需要包含头文件====
操作文件的三大类:
- ofstream:写操作
- ifstream:读操作
- fstream:读写操作
1. 文本文件
1.1 写文件
写文件步骤如下:
-
包含头文件
#include
-
创建流对象
ofstream ofs;
-
打开文件
ofs.open(“文件路径”, 打开方式);
-
写数据
ofs << “写入的数据”;
-
关闭文件
ofs.close();
文件打开方式:
打开方式 | 解释 |
---|---|
ios::in | 为读文件而打开文件 |
ios::out | 为写文件而打开文件 |
ios::ate | 初始位置:文件尾 |
ios::app | 追加方式写文件 |
ios::trunc | 如果文件存在:先删除,再创建 |
ios::binary | 二进制方式 |
**注:**文件打开方式可以配合使用,利用 | 操作符
**如:**用二进制方式写文件ios::binary | ios::out
void test01()
{
ofstream ofs;
ofs.open("test.txt", ios::out);
ofs << "This is a test";
ofs.close();
}
总结:
- 读文件可以利用
ofstream
,或者fstream
- 打开文件时候需要制定操作文件路径,以及打开方式
- 利用
<<
可以向文件中写数据 - 操作完毕,要关闭文件流
1.2 读文件
四种方式读取文本文件:
void test01()
{
ifstream ifs;
ifs.open("test.txt", ios::in);
if (!ifs.is_open())
{
cout << "File is open fail!" << endl;
return;
}
//第一种
/*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)
{
cout << c ;
}
ifs.close();
}
2. 二进制文件
以二进制的方式对文件进行读写操作,打开方式要指定为ios::binary
2.1 写文件
二进制方式写文件主要利用流对象调用成员函数write
函数原型:ostream& write(const cher* buffer, int len)
参数解释:字符指针buffer 指向内存中一段存储空间。len 是读写的字节数
示例:
class Person
{
public:
char m_Name[64];
int m_Age;
};
void test01()
{
ofstream ofs("Person.txt", ios::binary | ios::out);
//ofs.open("Person.txt", ios::binary | ios::out);
Person p = { "张三", 18 };
ofs.write((const char*)&p, sizeof(Person));
ofs.close();
}
2.2 读文件
二进制方式写文件主要利用流对象调用成员函数read
函数原型:ostream& read(const cher* buffer, int len);
参数解释:字符指针buffer 指向内存中一段存储空间。len 是读写的字节数
示例:
void test01()
{
ifstream ifs;
ifs.open("Person.txt", ios::binary | ios::in);
if (!ifs.is_open())
{
cout << "The file is open fail!" << endl;
return;
}
Person p;
ifs.read((char*)&p, sizeof(Person));
cout << "姓名:" << p.m_Name << " 年龄:" << p.m_Age << endl;
ifs.close();
}
三、C++提高编程
1. 模版
- C++提供两种模板机制:函数模板和类模板
1.1 函数模板
1.1.1 函数模板语法
函数模板的作用:
建立一个通用函数,其函数返回值类型和形参类型可以不具体制定,用一个虚拟的类型来代表
语法
template<typename T>
函数声明或定义
template – 声明创建模板
typename – 表明其后面的符号是一种数据类型,可以用class代替
T – 通用的数据类型,名称可以替换,通常为大写字母
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 1;
int b = 2;
//利用函数模板交换
//两种方式使用函数模板
//1. 自动类型推导
//mySwap(a, b);
//2. 显示指定类型
mySwap<int>(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
注意事项:
- 自动类型推导,必须推导出一致的数据类型T,才可以使用
- 模板必须要确定T的数据类型,才可以使用
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';
//1、 自动类型推导
//自动类型推导,必须推导出一致的数据类型T,才可以使用
//mySwap(a, c); //错误,推导不出一致的T类型
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
template<typename T>
void func()
{
cout << "func 的调用" << endl;
}
//2、模板必须要确定T的数据类型,才可以使用
void test02()
{
//func();
func<int>();
}
1.1.2 普通函数与函数模板
-
普通函数与函数模板的区别
- 普通函数调用时可发生自动类型转换(隐式类型转换)
- 函数模板调用时,如果利用自动类型推导,不会发生隐式类型转换
- 如果利用显式指定类型的方式,可发生隐式类型转换
**注:**建议使用显式指定类型的方式,调用函数模板,因为可以自己确定通用类型T
-
普通函数与函数模板调用规则
-
如果函数模板和普通函数都可以实现,优先调用普通函数
-
可以通过空模板参数列表来调用函数模板
myPrint<>(a, b);
-
函数模板也可以发生重载
-
如果函数模板可以更好的匹配,优先调用函数模板
**注:**提供了函数模板,最好就不要提供普通函数,否则容易出现二义性
-
1.1.3 模板的局限性
template<class T>
void f(T a, T b)
{
a = b;
}
在上述的赋值操作,如果传入的a和b是一个数组,就无法实现了
C++为了解决这种问题,提供模板重载,可以为特定类型提供具体化的模板
class Person
{
public:
Person(string Name, int Age)
{
this->m_Age = Age;
this->m_Name = Name;
}
string m_Name;
int m_Age;
};
template<typename T>
bool myCompare(T& a, T& b)
{
if (a == b)
return true;
else
return false;
}
//利用具体化的Person的版本实现代码,具体化优先调用
template<>bool myCompare(Person& p1, Person& p2)
{
if (p1.m_Age == p2.m_Age && p1.m_Name == p2.m_Name)
return true;
else
return false;
}
总结:
- 利用具体化的模板,可以解决自定义类型的通用化
- 学习模板并不是为了写模板,而是在STL能够运用系统提供的模板
1.2 类模板
1.2.1 类模板语法
类模板作用:
- 建立一个通用类,类中的成员、数据类型可以不具体制定,用一个虚拟的类型来代表。
语法:
template<typename T>
类
示例:
template<class NameType, class AgeType>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->m_Age = age;
this->m_Name = name;
}
void showPerson()
{
cout << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
void test01()
{
Person<string, int> p1("张三",999);
p1.showPerson();
}
1.2.2 类模板和函数模板的区别
-
类模板没有自动类型推导的使用方式
-
类模板在模板参数列表中可以有默认参数
template<class NameType, class AgeType = int> …… void test02() { Person<string> p2("猪八戒", 999); p2.showPerson(); }
类模板中成员函数创建时机
- 普通类中的成员函数一开始就可以创建
- 类模板中的成员函数在调用时才创建
1.2.3 类模板对象做函数参数
向函数传入类模板类型的参数,一共有三种传入方式:
- 制定传入类型 —直接显示对象的数据类型
- 参数模板化 —将对象中的参数变为模板进行传递
- 整个类模板化 —将这个对象类型模板化进行传递
//类模板对象做函数参数
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->m_Age = age;
this->m_Name = name;
}
void showPerson()
{
cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//1、指定传入类型
void printPerson(Person<string, int>& p)
{
p.showPerson();
}
void test01()
{
Person<string, int> p1("孙悟空", 999);
p1.showPerson();
}
//2、参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>& p)
{
p.showPerson();
cout << "T1的类型为:" << typeid(T1).name() << endl;
}
void test02()
{
Person<string, int> p2("猪八戒", 1000);
printPerson2(p2);
}
//3、整个类模板化
template<class T>
void printPerson3(T& p)
{
p.showPerson();
cout << "T的类型为:" << typeid(T).name() << endl;
}
void test03()
{
Person<string, int> p3("唐僧", 30);
printPerson3(p3);
}
1.2.4 类模板与继承
当类模板碰到继承时,需要注意以下几点:
-
当子类继承的父类是一个模板时,子类在声明的时候,要指定出父类中T的类型
template<class T> class Base { T m; }; //class Son : public Base //错误,必须要知道父类中T的类型,才能继承给子类 class Son : public Base<int> { };
-
如果不指定,编译器无法给子类分配内存
-
如果想灵活指定出父类中T的类型,子类也需变为类模板
template<class T> class Base { T m; }; template<class T1, class T2> class Son2 :public Base<T2> //指定Base中的模板类型为T2 { T1 obj; };
**总结:**如果父类是模板,子类需要制定出父类中T的数据类型
1.2.5 类模板成员的类外实现
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>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_Age = age;
this->m_Name = name;
}
//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}
1.2.6 类模板分文件编写
问题:
- 类模板中成员函数创建时机是在调用阶段,导致分文件编写时链接不到
解决:
-
解决方式1:直接包含
.cpp
源文件#include "Person.cpp" //直接包含.cpp void test01() { Person<string, int>p("Jerry", 18); p.showPerson(); }
-
解决方式2:将声明和实现写到同一个文件中,并更改后缀名为
.hpp
,.hpp
是约定的名称,并不是强制
示例:
person.hpp中的代码:
#pragma once
#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>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_Age = age;
this->m_Name = name;
}
//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名:" << this->m_Name << " 年龄:" << this->m_Age << endl;
}
mian.cpp中的代码
#include "Person.hpp"
void test01()
{
Person<string, int>p("Jerry", 18);
p.showPerson();
}
1.2.7 类模板与友元
- 全局函数类内实现—》直接在类内声明友元即可
- 全局函数类外实现—》需提前让编译器知道全局函数的存在
示例:
//提前让编译器知道Person类的存在
template<class T1, class T2>
class Person;
//全局函数在类外实现
template<class T1, class T2>
void showPerson2(Person<T1, T2> p)
{
cout << "姓名:" << p.m_Name << " 年龄:" << p.m_Age << endl;
}
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->m_Age = age;
this->m_Name = name;
}
//全局函数类内实现,直接在类内声明友元即可
/*friend void showPerson(Person<T1, T2> p)
{
cout << "姓名:" << p.m_Name << " 年龄:" << p.m_Age << endl;
}*/
//全局函数,类外实现
//加空模板的参数列表
//如果全局函数类外实现,需提前让编译器知道全局函数的存在
friend void showPerson2<>(Person<T1, T2> p);
private:
T1 m_Name;
T2 m_Age;
};
void test01()
{
Person<string, int>p("Tom", 20);
showPerson2(p);
}
1.2.8 类模板案例
实现一个通用的数组类,要求如下:
- 可以对内置数据类型以及自定义数据类型的数据进行存储
- 将数组中的数据存储到堆区
- 构造函数中可以传入数组的容量
- 提供对应的拷贝构造函数以及operator=防止浅拷贝问题
- 提供尾插法和尾删法对数组中的数据进行增加和删除
- 可以通过下标的方式访问数组中的元素
- 可以获取数组中当前元素个数和数组的容量
2. STL初识
2.1 STL 基本概念
- STL 从广义上分为:容器(container),算法(algorithm),迭代器(iterator);
- 容器和算法之间通过迭代器进行无缝连接;
- STL 几乎所有代码都采用了模板类或者模板函数。
2.2 STL 六大组件
STL 分为六大组件,分别是:容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器:
- 容器:各种数据结构,如vector、list、deque、set、map等,用来存放数据;
- 算法:各种常用算法,如sort、find、copy、for_each等;
- 迭代器:扮演了容器与算法之间的胶合剂;
- 仿函数:行为类似函数,可作为算法的某种策略;
- 适配器:一种用来修饰容器或者仿函数或者迭代器接口的东西;
- 空间适配器:负责空间的配置与管理。
2.3 容器、算法、迭代器
容器:
STL 容器就是将运用最广泛的一些数据结构实现出来
常用的数据结构:数组、链表、树、栈、队列、集合、映射表等
这些容器分为序列式容器和关联式容器两种:
**序列式容器:**强调值的排序,序列式容器中的每个元素均有固定的位置。
**关联式容器:**二叉树结构,各元素之间没有严格的物理上的顺序关系
**算法:**问题之解法也
有限的步骤,解决逻辑或者数学上的问题,这一门学科我们叫做算法(Algorithms)
算法分为:质变算法和非质变算法。
质变算法:指运算过程中会更改区间内的元素的内容,例如拷贝、替换、删除等
非质变算法:指运算过程中不会更改区间内的元素的内容,如查找、便利、计数等
**迭代器:**容器和算法之间粘合剂
提供一种方法,使之能够依序号寻访某个容器所含的各个元素,而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器
迭代器差不多类似于指针,初学者可以把其当作指针来用
迭代器种类:
种类 | 功能 | 支持运算 |
---|---|---|
输入迭代器 | 对数据的只读访问 | 只读,支持++、==、!= |
输出迭代器 | 对数据的只写访问 | 只写,支持++ |
前向迭代器 | 读写操作,并能向前推进迭代器 | 读写,支持++、==、!= |
双向迭代器 | 读写操作,并能向前向后操作 | 读写,支持++、– |
随机访问迭代器 | 读写操作,可以以跳跃的方式访问任意数据,功能最强的迭代器 | 读写,支持++、==、[n]、-n、<、<=、>、>= |
常用的容器中迭代器种类为双向迭代器和随机访问迭代器
2.4 容器嵌套容器
示例:
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 ix = (*it).begin(); ix != (*it).end(); ix++)
{
cout << *ix << " ";
}
cout << endl;
}
}
3. STL 常用容器
3.1 string 容器
本质:
- string本质上是一个类
string和**char ***区别:
- char * 是一个指针
- string 是一个类,类内部封装了char *,管理这个字符串,是一个char * 型的容器
**特点:**string 管理char * 所分配的内存,不用担心赋值越界和取值越界等,由类内部进行负责
3.1.1 string 构造函数
构造函数原型:
-
string():
创建一个空的字符串,例如string str;string(const char* s)
使用字符串s 初始化 -
string(const string &str)
使用一个string 对象初始化另一个string 对象 -
string(int n, char c)
//使用n 个字符c 串初始化
3.1.2 string 赋值操作
赋值的函数原型:
string& operator=(const char* s):
char* 类型字符串,赋值给当前字符串string& operator=(const string &s):
把字符串s 赋给当前字符串string& operator=(char c):
把字符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";
string str2;
str2 = str1;
string str4;
str4.assign("hello C++");
string str5;
str5.assign("hello C++", 5);
string str6;
str6.assign(str5);
string str7;
str7.assign(10, 'w');
}
3.1.3 字符串拼接
string str1 = "我";
str1 += "爱玩游戏";
str1 += ':';
string str2 = "LOL DNF";
str1 += str2;
string str3 = "I";
str3.append(" love "); //把参数内的字符串拼接到str3末尾
str3.append("game aaaa", 4);把参数内的字符串的前4个字符拼接到str3末尾
//str3.append(str2);//str2拼接到str3当末尾
str3.append(str2,4,3);//从字符串str2的第四个字符开始,截取3个字符拼接到str3末尾
3.1.4 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个字符为字符串strstring& replace(int pos, int n,const char* s);
//替换从pos开始的n个字符为字符串s
//从1号位置起3个字符串替换为 1111
str1.replace(1, 3, "1111");
3.1.5 string 字符串比较
-
字符串是按照字符串的ASCII 码进行比较
=
返回 0>
返回 1<
返回 -1
函数原型:
int compare(const string &s)const;
与字符串s 比较int compare(const char *s)const;
与字符串s 比较
3.1.6 string 字符存取
char& operator[](int n);
;通过[] 方式获取字符char& at(int n);
通过at 方法获取字符
string str1 = "abcdefg";
for (int i = 0; i < str1.size(); i++)
{
cout << str1[i] << " ";
}
cout << endl;
for (int i = 0; i < str1.size(); i++)
{
cout << str1.at(i) << " ";
}
cout << endl;
3.1.7 string 插入和删除
函数原型:
string& insert(int pos, const char* s);
//插入字符串string& insert(int pos, const string& str);
//插入字符串string& insert(int pos, int n, char c);
//在指定位置插入n个字符Cstring& erase(int pos, int n = npos);
//删除从Pos开始的n个字符
3.1.8 string 获取子串
函数原型:
string substr(int pos = 0, int n = npos) const;
返回由pos 开始的n 个字符组成的字符串
3.2 vector 容器
3.2.1 vector 基本概念
功能:与数组类似,也被称为单端数组,与普通数组的区别在于vector 可以动态扩展
**动态扩展:**并不是在原空间之后接续新空间,而是找更大的内存空间,然后将原数据拷贝新空间,释放原空间
- vector 容器的迭代器是支持随机访问的迭代器
3.2.2 vector 构造函数
函数原型:
vector<T> v;
//采用模板实现类实现,默认构造函数vector(v.begin(), v.end());
//将[v.begin(), v.end())区间的元素拷贝给本身vector(n, elem);
//构造函数将n个elem 拷贝给本身vector(const vector &vec);
//拷贝构造函数
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
//通过区间方式进行构造
vector<int>v2(v1.begin(), v1.end());
//n个elem方式构造
vector<int>v3(10, 100);
//拷贝构造
vector<int>v4(v3);
3.2.3 vector 赋值操作
函数原型:
vector& operator=(const vector &vec);
//重载等号操作符assign(beg,end);
//将[beg,end)区间中的数据拷贝赋值给本身assign(n,elem);
//将n个elem拷贝赋值给本身
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
vector<int>v2;
v2 = v1;
vector<int>v3;
v3.assign(v1.begin(), v1.end());
vector<int>v4;
v4.assign(10, 100);
3.2.4 vector 容量和大小
函数原型:
empty();
//判断容器是否为空capacity();
//容器的容量size();
//返回容器中元素的个数resize(int num);
//重新指定容器的长度为mun,若容器变长,则以默认值填充新位置
//如果容器变短,则末尾超出容器长度的元素被删除resize(int num, elem);
//重新指定容器的长度为mun,若容器变长,则以elem填充新位置
//如果容器变短,则末尾超出容器长度的元素被删除
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
if (v1.empty())
cout << "v1为空" << endl;
else
{
cout << "v1不为空" << endl;
cout << "v1的容量为:" << v1.capacity() << endl;
cout << "v1的大小为:" << v1.size() << endl;
}
//v1.resize(15);
v1.resize(15, 1);
3.2.5 vector 插入和删除
函数原型:
push_ back(ele);
//尾部插入元素elepop_ back();
//删除最后一个元素insert(const_ iterator pos, ele);
//迭代器指向位置pos插入元素eleinsert(const_ iterator pos, int count,ele);
//迭代器指向位置pos插入count个元素eleerase(const_ iterator pos);
//删除迭代器指向的元素erase(const_ iterator start, const_ iterator end);
//删除迭代器从start到end之间的元素clear();
//删除容器中所有元素
vector<int>v1;
for (int i = 0; i < 5; i++)
{
v1.push_back(i * 10 + 10);
}
v1.pop_back();
v1.insert(v1.begin(), 100); //开头位置插入100
v1.insert(v1.begin(), 2, 1000); //在头部插入两个1000
v1.erase(v1.begin()); //删除头部的第一个元素
v1.erase(v1.begin(), v1.end());
3.2.6 vector 数据存取
函数原型:
at(int idx);
//返回索引 idx所指的数据operator[];
//返回索引 idx所指的数据front();
//返回容器中第一个数据元素back();
//返回容器中最后一个数据元素
3.2.7 vector 互换容器
函数原型:
swap(vec);
//将vec 与本身的元素互换
v1.swap(v2);
//使用swap收缩内存
//vector<int>(v) 匿名对象,使用拷贝构造函数创建了一个新的对象
//会按照v的元素个数初始化这个匿名对象,故容量和元素个数都一致
vector<int>(v).swap(v);
- swap 可以使两个容器互换,可以达到实用的收缩内存效果
3.2.8 vector 预留空间
功能描述:
- 减少vector 在动态扩展内存时的扩展次数
函数原型:
reserve(int len);
//容器预留len 个元素长度,预留位置不初始化,元素不可访问
vector<int>v1;
v1.reserve(100000);
int num = 0;
int* p = nullptr;
for (int i = 0; i < 100000; i++)
{
v1.push_back(i);
if (p != &v1[0])
{
p = &v1[0];
num++;
}
}
cout << "num = " << num << endl;
3.3 deque 容器
3.3.1 deque 容器基本概念
**功能:**双端数组,可以对头端进行插入删除操作
deque 与 vector 的区别:
- vector 对于头部的插入删除效率较低,数据量越大,效率越低
- deque 相对于而言,对头部的插入删除速度会比vector快
- vector 访问元素时的速度回比deque 快,这和两者的内部实现有关
- deque 提供了头部和尾部的插入和删除的接口(
pushu_font()、push_back()
) - deque 内部工作原理:
- deque 内部有个**中控器,**维护每段缓冲区的内容,缓冲区内存放真实数据
- 中控器维护的是每个缓冲区的地址,使得使用deque 时像一片连续的内存空间
- deque 提供了头部和尾部的插入和删除的接口(
3.3.2 deque 构造函数
函数原型:
deque<T>
deqT //默认构造形式deque(beg, end);
//构造函数将[beg, end)区间中的元素拷贝给本身deque(n, elem);
//构造函数将n个elem拷贝给本身deque(const deque &deq);
//拷贝构造函数
const_iterator
只读迭代器
void printDeque(const deque<int>& de)
{
for (deque<int>::const_iterator it = de.begin(); it != de.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(d1.begin(), d1.end());
printDeque(d2);
deque<int>d3(10, 100);
printDeque(d3);
deque<int>d4(d3);
}
3.3.3 deque 赋值操作
函数原型:
deque& operator=(const deque &deq);
//重载等号操作符assign(beg, end);
//将[beg, end) 区间中的数据拷贝赋值给本身asign(n, elem);
//将n个elem拷贝赋值给本身
3.3.4 deque大小操作
函数原型:
deque.empty();
//判断容器是否为空deque.size();
//返回容器中元素的个数deque.resize(num);
//重新指定容器的长度为num,若容器变长,则以默认值填充新位置deque.resize(num,elem);
//重新指定容器的长度为num,若容器变长,则以elem填充新位置
3.3.5 deque 插入和删除
函数原型:
两端插入操作:
push_back(elem);
//在容器尾部添加一个数据push_front(elem);
//在容器头部插入一个数据pop_back();
//删除容器最后一个数据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位置的数据,返回下一个数据的位置
void test01()
{
deque<int>d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
deque<int>d2;
d2.push_back(10);
d2.push_back(20);
d2.push_back(30);
//在d1头部插入d2
d1.insert(d1.begin(), d2.begin(), d2.end());
//删除d1第2个元素
deque<int>::iterator it = d1.begin();
it++;
d1.erase(it);
//清空d1
d1.erase(d1.begin(), d1.end());
}
3.3.6 deque 数据存取
函数原型:
at(int idx);
//返回索引 idx所指的数据operator[idx];
//返回索引idx所指的数据front();
//返回容器中第一个数据元素back();
//返回容器中最后一个数据元素
3.4 stack 容器
- stack 容器是一种后进先出的数据结构,它只有一个出口
- 栈中只有顶端元素才可以被外界使用,因此栈不允许有遍历行为
stack 常用接口
构造函数:
stack<T> stk;
//stack采用模板类实现,stack对象的默认构造形式stack(const stack &stk);
//拷贝构造函数
赋值操作:
stack operator=(const stack &stk);
//重载等号赋值操作
数据存取:
push(elem);
//向栈顶添加元素pop(elem);
//从栈顶移除一个元素top();
//返回栈顶元素
大小操作
size();
//返回栈的大小empty();
//判断栈是否为空
3.5 queue 容器
Queue 是一种先进先出的数据结构,它有两个出口
- 队列允许从一端新增元素,从另一端移除元素
- 队列只有队头队尾可以被外界使用,因此队列不允许遍历行为
构造函数:
queue<T> que;
//queue采用模板类实现,queue对象的默认构造形式queue(const queue &que);
//拷贝构造函数
数据存取:
push(elem);
//向队尾添加元素pop(elem);
//从队头移除一个元素back();
//返回最后一个元素front();
//返回第一个元素
大小操作
size();
//返回队列的大小empty();
//判断队列是否为空
3.6 list 容器(链表)
概念:链表是一种物理存储单元上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接实现的;链表由一系列结点组成
**优点:**可以对任意位置进行快速插入或删除元素;采用动态分配内存,不会造成内存浪费和溢出
**缺点:**容器遍历速度没有数组快,占用空间比数组大
**注:**STL 中的链表是一个双向循环链表
3.6.1 list 构造函数
函数原型:
list<T> lst;
//list采用类模板实现,对象的默认构造形式list(beg,end);
//构造函数将[beg, end)区间中的元素拷贝给本身list(n,elem);
//构造函数将n个elem拷贝给本身list(const list &lst);
//拷贝构造函数
3.6.2 list 赋值和交换
函数原型:
list& operator=(const list &lst);
//重载等号操作符assign(beg, end);
//将[beg, end) 区间中的数据拷贝赋值给本身asign(n, elem);
//将n个elem拷贝赋值给本身swap(lst);
//将lst 与本身的元素互换
void test01()
{
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);
}
3.6.3 list 大小操作
函数原型:
empty();
//判断容器是否为空size();
//返回容器中元素的个数resize(int num);
//重新指定容器的长度为mun,若容器变长,则以默认值填充新位置
//如果容器变短,则末尾超出容器长度的元素被删除resize(int num, elem);
//重新指定容器的长度为mun,若容器变长,则以elem填充新位置
//如果容器变短,则末尾超出容器长度的元素被删除
3.6.4 list 插入和删除
函数原型:
push_back(elem);
//在容器尾部添加一个元素push_front(elem);
//在容器头部插入一个元素pop_back();
//删除容器最后一个元素pop_front();
//删除容器第一个元素insert(pos, elem);
//迭代器指向位置pos插入元素eleminsert(pos, n,ele);
//迭代器指向位置pos插入n个元素eleinsert(pos,beg,end);
//在pos位置插入[beg, end)区间的数据,无返回值erase(pos);
//删除pos位置的数据,返回下一个数据的位置erase(beg, end);
//删除迭代器[beg, end)的元素clear();
//删除容器中所有元素remove(elem);
//删除容器中所有与elem值匹配的元素
数据存取:
front();
//返回第一个元素back();
//返回最后一个元素
3.6.5 list 排序和反转
**注:**所有不支持随机访问迭代器的容器,不可以用标准算法。不支持随机访问迭代器的容器,内部会提供对应一些算法
函数原型:
sort();
reverse();
bool myCompare(int v1, int v2)
{
return v1 > v2;
}
void test01()
{
list<int> L1;
L1.push_back(3);
L1.push_back(2);
L1.push_back(6);
L1.push_back(1);
L1.sort();
L1.reverse();
L1.sort(myCompare); //降序,myCompare为自定义规则
}
3.7 set/ multiset容器
3.7.1 set 基本概念
- 所有元素都会在插入时自动被排序
本质:
- set/ multiset属于关联式容器,底层结构是用二叉树实现
set和 multiset区别:
- set不允许容器中有重复的元素
- multiset 允许容器中有重复的元素
3.7.2 set构造和赋值
构造:
set<T> st;
//默认构造函数set(const set &st);
//拷贝构造函数
赋值:
set& operator=(const set &st);
//重载等号操作符
set<int>s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
//拷贝构造
set<int>s2(s1);
set<int>s3;
s3 = s2;
3.7.3 set 容器常用接口
大小和交换:
size();
//返回容器中元素的数目empty();
//判断容器是否为空swap(st);
//交换两个集合容器
插入和删除:
insert(elem);
//在容器中插入元素clear();
//清除所有元素erase(pos);
//删除pos迭代器所指的元素,返回下一个元素的迭代器erase(beg, end);
//删除区间[beg, end)的所有元素,返回下一个元素的迭代器erase(elem);
//删除容器中值为elem的元素
set<int>s1;
s1.erase(s1.begin());
s1.erase(30);
s1.erase(s1.begin(), s1.end());
查找和统计
find(key);
//查找key是否存在,若存在,返回该键的元素的迭代器,若不存在,返回set.end();count(key);
//统计key的元素个数
3.7.4 pair 对组的创建
**功能:**成对出现的数据,利用对租可以返回两个数据
创建方式:
pair<type, type> p (value1, value2);
pair<type, type> p = make_pair(value1, value2);
3.7.5 set 容器排序
-
内置类型制定排序规则
利用仿函数,可以改变排序规则
class MyCompare { public: bool operator()(int v1, int v2) const { return v1 > v2; // 修改为 v1 > v2 表示降序排序 } }; void test01() { set<int, MyCompare> s1; // 降序排序,默认为升序排序 s1.insert(10); s1.insert(30); s1.insert(20); s1.insert(40); for (set<int, MyCompare>::const_iterator it = s1.begin(); it != s1.end(); it++) { cout << *it << " "; } cout << endl; }
-
自定义数据类型指定排序规则
class Person { public: Person(string name, int age) { this->m_Age = age; this->m_Name = name; } int m_Age; string m_Name; }; class comparePerson { public: bool operator()(const Person& p1, const Person& p2) { return p1.m_Age > p2.m_Age; } }; void test01() { //自定义数据类型,指定排序规则 set<Person, comparePerson> s; Person p1("刘备", 35); Person p2("关羽", 33); Person p3("张飞", 31); Person p4("赵云", 30); s.insert(p1); s.insert(p2); s.insert(p3); s.insert(p4); }
3.8 map 容器
3.8.1 map 容器基本概念
简介:
- map 中所有元素都是pair
- pair 中第一个元素为key(键值),起到索引作用,第二个元素为value(实值)
- 所有元素都会根据元素的键值自动排序
本质:
- map/multimap 属于关联式容器,底层结构是用二叉树实现
优点:
- 可以根据key值快速找到value值
map和multimap 的区别:
- map不允许容器中有重复key值元素
- multimap允许容器中有重复key值元素
map赋值和构造
map<int, int>m;
m.insert(pair<int, int>(1,10));
m.insert(make_pair(2,20));
3.8.2 map 常用接口
map 大小和交换
size();
//返回容器中元素个数empty();
//判断容器是否为空swap();
//交换两个集合容器
插入和删除:
insert(elem);
//在容器中插入元素clear();
//清除所有元素erase(pos);
//删除pos迭代器所指的元素,返回下一个元素的迭代器erase(beg, end);
//删除区间[beg, end)的所有元素,返回下一个元素的迭代器erase(key);
//删除容器中值为key的元素
查找和统计
find(key);
//查找key是否存在,若存在,返回该键元素的迭代器;若不存在,返回set.end();count(key);
//统计key的元素个数
3.8.3 map 容器排序
- map 容器默认排序规则为:按照key值进行从小到大排序
- 也可以像set 容器那样,利用仿函数,改变排序规则
class MyCompare
{
public:
bool operator()(int v1, int v2) const
{
return v1 > v2; // 修改为 v1 > v2 表示降序排序
}
};
4. STL 函数对象
4.1 函数对象
概念:
- 重载函数调用操作符的类,其对象称为函数对象
- 函数对象使用重载的() 时,行为类似函数调用,也叫仿函数
本质:
函数对象(仿函数)是一个类,不是一个函数
4.1.1 函数对象的使用
-
函数对象在使用时,可以像普通函数那样使用,可以有参数,可以有返回值
class MyAdd { public: int operator()(int v1, int v2) { return v1 + v2; } }; void test01() { MyAdd myAdd; myAdd(10, 10); //返回结果为 10 + 10 = 20 cout << myAdd(10, 10) << endl; }
-
函数对象超出普通函数的概念,函数对象可以有自己的状态
class MyPrint { public: MyPrint() { this->count = 0; } void operator()(string test) { cout << test << endl; this->count++; } int count; //内部自己状态 }; void test02() { MyPrint myPrint; myPrint("hello world"); myPrint("hello world"); cout << myPrint.count << endl; //2次 }
-
函数对象可以作为参数传递
void doPrint(MyPrint& mp, string test) { mp(test); } void test03() { MyPrint myPrint; doPrint(myPrint, "Hello C++"); }
4.2 谓词
概念:
- 返回bool 类型的仿函数称为谓词
- 如果operator() 接受一个参数,那么叫做一元谓词
- 如果operator() 接受两个参数,那么叫做二元谓词
4.2.1 一元谓词例子
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的数字
//GreaterFive() 匿名函数对象
vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
if (it == v.end())
{
cout << "未找到" << endl;
}
else
{
cout << "找到了大于5的数字为:"<< *it << endl;
}
}
4.2.1 二元谓词例子
class MyCompare
{
public:
bool operator()(int val1, int val2)
{
return val1 > val2;
}
};
void test01()
{
vector<int> v;
v.push_back(2);
v.push_back(1);
v.push_back(5);
v.push_back(3);
v.push_back(4);
//使用函数对象,改变算法策略,变为排序规则为从大到小
sort(v.begin(), v.end(), MyCompare());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
4.3 内建仿函数对象
**概念:**STL 内建了一些函数对象
分类:
- 算术仿函数
- 关系仿函数
- 逻辑仿函数
用法:
- 这些仿函数所产生的对象,用法和一般仿函数相同
- 使用内建仿函数对象,需要引入头文件
#include <functional>
4.3.1 算术仿函数
功能描述:
- 实现四则运算
- 其中
negate
是一元运算,其他都是二元运算
仿函数原型:
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>
//取反仿函数
示例:
void test01()
{
//取反仿函数
negate<int>n;
cout << n(50) << endl;
//plus 加法仿函数
plus<int>p;
cout << p(10, 20) << endl;
}
4.3.2 关系仿函数
template<class T> bool equal_to<T>
//等于template<class T> bool no_equal_to<T>
//不等于template<class T> bool grater<T>
//大于template<class T> bool grater_equal<T>
//大于等于template<class T> bool less<T>
//小于template<class T> bool less_equal<T>
//小于等于
void test01()
{
vector<int>v;
v.push_back(10);
v.push_back(30);
v.push_back(40);
v.push_back(50);
v.push_back(20);
//降序
sort(v.begin(), v.end(), greater<int>());
}
4.3.3 逻辑仿函数
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);
vector<int>v2;
//利用逻辑非,将容器v搬运到v2中,并执行取反操作
v2.resize(v.size());
transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
}
5 STL 常用算法
- 算法主要是由头文件
functional
algorithm
numeric
组成 functional
:定义了一些模板类,用以生命函数对象algorithm
:是所有STL 头文件中最大的一个,范围涉及到比较、交换、查找、遍历操作、复制和修改等numeric
:只包括几个在序列上面进行简单数学运算的模板函数
5.1 常用遍历算法
5.1.1 for_each
**作用:**遍历容器
函数原型:
-
for_each(iterator beg, iterator end, _func);
//beg 开始迭代器
//end 结束迭代器
//_func 函数或者函数对象
void print01(int val)
{
cout << val << " ";
}
//仿函数
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);
}
for_each(v.begin(), v.end(), print01);
cout << endl;
for_each(v.begin(), v.end(), print02());
cout << endl;
}
5.1.2 transform
**作用:**搬运容器到另一个容器中
函数原型:transform(iterator beg1, iterator end1,iterator beg2,_func)
//beg1 源容器开始迭代器
//end1 源容器结束迭代器
//beg2 目标容器开始迭代器
//_func 函数或者函数对象
class Transform
{
public:
int operator()(int v)
{
return v + 100;
}
};
void print01(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(), Transform());
for_each(vTarget.begin(), vTarget.end(), print01);
cout << endl;
}
5.2 常用查找算法
find
//查找元素find_if
//按条件查找元素adjacent_find
//查找相邻重复元素binary_search
//二分查找count
//统计元素个数count_if
//按条件统计元素个数
5.2.1 find
**功能:**查找指定元素,找到返回指定元素的迭代器,找不到返回结束迭代器end()
函数原型:find(iterator beg, iterator end, value);
//beg 开始迭代器
//end 结束迭代器
//value 查找的元素
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(), 5);
if (it != v.end())
cout << "找到:" << *it << endl;
else
cout << "没有找到!" << endl;
}
/*自定义数据类型*/
class Person
{
public:
Person(int age, string name)
{
this->m_Age = age;
this->m_Name = name;
}
//重载==,让底层find知道如何对比Person数据类型
bool operator==(const Person& p)
{
if (this->m_Age == p.m_Age && this->m_Name == p.m_Name)
return true;
else
return false;
}
int m_Age;
string m_Name;
};
void test02()
{
vector<Person>v;
Person p1(10, "aaa");
Person p2(20, "bbb");
Person p3(30, "ccc");
Person p4(40, "ddd");
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
Person pp(20, "bbb");
vector<Person>::iterator it = find(v.begin(), v.end(), pp);
if (it != v.end())
cout << "找到元素 姓名:" << it->m_Name << " 年龄:" << it->m_Age << endl;
else
cout << "没有找到!" << endl;
}
5.2.2 find_if
**功能:**按条件查找元素
函数原型:find_if(iterator beg, iterator end, _Pred);
//按值查找元素,找到返回指定位置迭代器,找不到返回结束迭代器位置
//beg 开始迭代器
//end 结束迭代器
//_Pred 函数或者谓词(返回bool 类型的仿函数)
示例:
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);
}
vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
if (it != v.end())
cout << "找到:" << *it << endl;
else
cout << "没有找到!" << endl;
}
5.2.3 adjacent_find
**功能:**查找相邻重复元素
函数原型:find(iterator beg, iterator end);
//查找相邻重复元素,返回相邻重复元素第一个位置的迭代器
//beg 开始迭代器
//end 结束迭代器
void test01()
{
vector<int>v;
v.push_back(1);
v.push_back(2);
v.push_back(2);
v.push_back(3);
vector<int>::iterator it = adjacent_find(v.begin(), v.end());
if (it != v.end())
cout << "找到相邻重复元素:" << *it << endl;
else
cout << "没有找到!" << endl;
}
5.2.4 binary_search
**功能:**查找指定元素是否存在
函数原型:bool binary_search(iterator beg, iterator end, value);
//查找指定的元素,查到返回true,否则返回false
//在无序序列中不可用
//beg 开始迭代器
//end 结束迭代器
//value 查找的元素
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
bool result = binary_search(v.begin(), v.end(), 4);
if (result)
cout << "找到!" << endl;
else
cout << "未找到!!" << endl;
5.2.5 count
**功能:**统计元素个数
函数原型:count(iterator beg, iterator end, value);
//beg 开始迭代器
//end 结束迭代器
//value 统计的元素
class Person
{
public:
Person(int age, string name)
{
this->m_Age = age;
this->m_Name = name;
}
bool operator==(const Person& p)
{
if (this->m_Age == p.m_Age)
return true;
else
return false;
}
string m_Name;
int m_Age;
};
void test02()
{
vector<Person>v;
Person p1(10, "aaa");
Person p2(20, "bbb");
Person p3(20, "ccc");
Person p4(40, "ddd");
Person p(20, "eee");
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
int num = count(v.begin(), v.end(), p);
cout << "和p年龄相同的人有:" << num << "个!" << endl;
}
5.2.6 count_if
**功能:**按条件统计元素个数
函数原型:count_if(iterator beg, iterator end, _Pred);
//beg 开始迭代器
//end 结束迭代器
//_Pred 谓词
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);
}
int num = count_if(v.begin(), v.end(), GreaterFive());
cout << num << endl;
}
5.3 常用排序算法
sort
//对容器内元素进行排序random_shuffle
//洗牌,指定范围内的元素随机调整次序merge
//容器元素合并,并存储到另一容器中reverse
//反转指定范围的元素
5.3.1 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(4);
v.push_back(1);
v.push_back(3);
sort(v.begin(), v.end(), greater<int>());
for_each(v.begin(), v.end(), Myprint);
cout << endl;
}
5.3.2 random_shuffle
**功能:**洗牌,指定范围内的元素随机调整次序
函数原型:random_shuffle(iterator beg, iterator end)
//beg 开始迭代器
//end 结束迭代器
void test01()
{
srand((unsigned int)time(NULL));
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
random_shuffle(v.begin(), v.end());
for_each(v.begin(), v.end(), Myprint);
cout << endl;
}
5.3.3 merge
**功能:**两个容器元素合并,并存储到另一个容器中
函数原型:
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
//两个容器必须是有序的
//beg1 容器1开始迭代器
//end1 容器1结束迭代器
//beg2 容器2开始迭代器
//end 容器2结束迭代器
//dest 目标容器开始迭代器
void test01()
{
vector<int>v;
vector<int>v2;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
v.push_back(i + 1);
}
vector<int>vTarget;
vTarget.resize(v.size() + v2.size());
merge(v.begin(), v.end(), v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), vTarget.end(), Myprint);
cout << endl;
}
5.3.4 reverse
**功能:**将容器内元素进行反转
函数原型:reverse(iterator beg, iterator end);
//beg 开始迭代器
//end 结束迭代器
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
reverse(v.begin(), v.end());
5.4 常用拷贝和替换算法
copy
//容器内指定范围的元素拷贝到另一容器中replace
//将容器内指定范围的旧元素修改为新元素replace_if
//容器内指定范围满足条件的元素替换为新元素swap
//互换两个容器的元素
5.4.1 copy
**功能:**容器内指定范围的元素拷贝到另一容器中
函数原型:copy(iterator beg, iterator end, iterator dest)
//beg 开始迭代器
//end 结束迭代器
//dest 目标起始迭代器
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
vector<int>v1;
v1.resize(v.size());
copy(v.begin(), v.end(), v1.begin());
for_each(v1.begin(), v1.end(), Myprint);
cout << endl;
5.4.2 replace
**功能:**将容器内指定范围的旧元素修改为新元素
函数原型:replace(iterator beg, iterator end, oldvalue, newvalue);
void test01()
{
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
//0替换为1
replace(v.begin(), v.end(), 0, 1);
for_each(v.begin(), v.end(), Myprint);
cout << endl;
}
5.4.3 replace_if
**功能:**容器内指定范围满足条件的元素替换为新元素
函数原型:replace_if(iterator beg, iterator end, _Pred, newvalue);
//beg 开始迭代器
//end 结束迭代器
//_Pred 谓词
//newvalue 替换的新元素
class GreaterFive
{
public:
bool operator()(int val)
{
return val > 5;
}
};
void Myprint(int val)
{
cout << val << " ";
}
void test01()
{
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
//大于5的元素替换为10
replace_if(v.begin(),v.end(), GreaterFive(), 10);
for_each(v.begin(), v.end(), Myprint);
cout << endl;
}
5.4.4 swap
**功能:**互换两个容器的元素
函数原型:swap(container c1, container c2);
//c1 容器1
//c2 容器2
5.5 常用算术生成算法
使用时包含头文件为#include<numeric>
accumulate
//计算容器元素累计总和fill
//向容器中添加元素
5.5.1 accumulate
**功能:**计算区间内 容器元素累计总和
函数原型:accumulate(iterator beg, iterator end, value);
//beg 开始迭代器
//end 结束迭代器
//value 起始累加值
vector<int>v;
for (int i = 0; i <= 100; i++)
{
v.push_back(i);
}
int total = accumulate(v.begin(), v.end(), 0);
cout << "total = " << total << endl;
5.5.2 fill
**功能:**向容器中添加元素
函数原型:fill(iterator beg, iterator end, value);
//beg 开始迭代器
//end 结束迭代器
//value 填充的值
vector<int>v;
v.resize(10); //默认填充为0
//后期重新填充
fill(v.begin(), v.end(), 10);
5.6 常用集合算法
set_intersection
//求两个容器的交集set_union
//求两个容器的并集set_difference
//求两个容器的差集
5.6.1 set_intersection
**功能:**求两个容器的交集
注:两个集合必须是有序序列
函数原型:
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iteratior dest);
void test01()
{
vector<int>v;
vector<int>v2;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
v2.push_back(i + 5);
}
vector<int>vTarget;
vTarget.resize(min(v.size(), v2.size()));
vector<int>::iterator itEnd = set_intersection(v.begin(), v.end(),
v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, Myprint);
cout << endl;
}
5.6.2 set_union
**功能:**求两个集合的并集
注:两个集合必须是有序序列
函数原型:
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iteratior dest);
void test01()
{
vector<int>v;
vector<int>v2;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
v2.push_back(i + 5);
}
vector<int>vTarget;
vTarget.resize(v.size() + v2.size());
vector<int>::iterator itEnd = set_union(v.begin(), v.end(), v2.begin(), v2.end(),
vTarget.begin());
for_each(vTarget.begin(), itEnd, Myprint);
cout << endl;
}
5.6.3 set_difference
函数原型:
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iteratior dest);
void test01()
{
vector<int>v;
vector<int>v2;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
v2.push_back(i + 5);
}
vector<int>vTarget;
vTarget.resize(max(v.size(), v2.size()));
cout << "v和v2的差集为:" << endl;
vector<int>::iterator itEnd = set_difference(v.begin(), v.end(), v2.begin(), v2.end(),
vTarget.begin());
for_each(vTarget.begin(), itEnd, Myprint);
cout << endl;
}
本文标签: 学习笔记
版权声明:本文标题:C++学习笔记 内容由热心网友自发贡献,该文观点仅代表作者本人, 转载请联系作者并注明出处:https://www.elefans.com/dongtai/1728334978a1154696.html, 本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容,一经查实,本站将立刻删除。
发表评论