admin管理员组

文章数量:1600155

本文为学习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++中，类的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

注：

  1. c++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置，即每个空对象也应有一个独一无二的内存地址
  2. 静态成员变量，不属于类对象上
  3. 非静态成员函数，不属于类对象上
  4. 静态成员函数，不属于类的对象上

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个函数

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝构造函数，对属性值进行拷贝
  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 继承中的对象模型

  1. 父类中所有非静态成员属性都会被子类继承下去；
  2. 父类中私有成员属性，被编译器给隐藏了，因此访问不到，但确实是被继承下去了；
  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 同名静态成员处理

  1. 静态成员和非静态成员出现同名，处理方式一致。

  2. 通过类名访问

    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 菱形继承

菱形继承概念：

  • 两个派生类继承同一个基类
  • 又有某个类同时继承两个派生类

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性
  2. 草泥马继承自动物的数据继承了两份，但其实这份数据我们只需继承一份就可以
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++面向对象三大特性之一

多态分为两类：

  1. 静态多态：函数重载和运算符重载属于静态多态，复用函数名
  2. 动态多态：函数重写，派生类和虚函数实现运行时多态

静态多态和动态多态的区别

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
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;
}

总结：

  1. 纯虚析构或虚析构就是用来解决通过父类指针释放子类对象
  2. 如果子类中没有堆区数据，可以不写纯虚析构或虚析构
  3. 拥有纯虚析构函数的类也属于抽象类

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++中对文件操作需要包含头文件====

操作文件的三大类：

  1. ofstream：写操作
  2. ifstream：读操作
  3. fstream：读写操作

1. 文本文件

1.1 写文件

写文件步骤如下：

  1. 包含头文件

    #include

  2. 创建流对象

    ofstream ofs;

  3. 打开文件

    ofs.open(“文件路径”, 打开方式);

  4. 写数据

    ofs << “写入的数据”;

  5. 关闭文件

    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 普通函数与函数模板

  • 普通函数与函数模板的区别

    1. 普通函数调用时可发生自动类型转换（隐式类型转换）
    2. 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
    3. 如果利用显式指定类型的方式，可发生隐式类型转换

    **注：**建议使用显式指定类型的方式，调用函数模板，因为可以自己确定通用类型T

  • 普通函数与函数模板调用规则

    1. 如果函数模板和普通函数都可以实现，优先调用普通函数

    2. 可以通过空模板参数列表来调用函数模板

      myPrint<>(a, b);

    3. 函数模板也可以发生重载

    4. 如果函数模板可以更好的匹配，优先调用函数模板

    **注：**提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

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 类模板和函数模板的区别

  1. 类模板没有自动类型推导的使用方式

  2. 类模板在模板参数列表中可以有默认参数

    template<class NameType, class AgeType = int>
……
void test02()
{
	Person<string> p2("猪八戒", 999);
	p2.showPerson();
}

类模板中成员函数创建时机

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
1.2.3 类模板对象做函数参数

向函数传入类模板类型的参数，一共有三种传入方式：

  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 类模板与继承

当类模板碰到继承时，需要注意以下几点：

  1. 当子类继承的父类是一个模板时，子类在声明的时候，要指定出父类中T的类型

    template<class T>
class Base
{
	T m;
};

//class Son : public Base	//错误，必须要知道父类中T的类型，才能继承给子类
class Son : public Base<int>
{

};

  2. 如果不指定，编译器无法给子类分配内存

  3. 如果想灵活指定出父类中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 类模板与友元
  1. 全局函数类内实现—》直接在类内声明友元即可
  2. 全局函数类外实现—》需提前让编译器知道全局函数的存在

示例：

//提前让编译器知道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 分为六大组件，分别是：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器：

  1. 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据；
  2. 算法：各种常用算法，如sort、find、copy、for_each等；
  3. 迭代器：扮演了容器与算法之间的胶合剂；
  4. 仿函数：行为类似函数，可作为算法的某种策略；
  5. 适配器：一种用来修饰容器或者仿函数或者迭代器接口的东西；
  6. 空间适配器：负责空间的配置与管理。

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个字符为字符串str
  • string& 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个字符C
  • string& 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); //尾部插入元素ele
  • pop_ back(); //删除最后一个元素
  • insert(const_ iterator pos, ele); //迭代器指向位置pos插入元素ele
  • insert(const_ iterator pos, int count,ele); //迭代器指向位置pos插入count个元素ele
  • erase(const_ iterator pos); //删除迭代器指向的元素
  • erase(const_ iterator start, const_ iterator end); //删除迭代器从start到end之间的元素
  • clear(); //删除容器中所有元素
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 时像一片连续的内存空间
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插入元素elem
  • insert(pos, n,ele); //迭代器指向位置pos插入n个元素ele
  • insert(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 容器排序

  1. 内置类型制定排序规则

    利用仿函数，可以改变排序规则

    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;
}

  2. 自定义数据类型指定排序规则

    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://m.elefans.com/dongtai/1728334978a1154696.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。