C++提高程式設計

農碼一生發表於2022-02-22

C++程式設計

本階段主要針對C++泛型程式設計和STL技術做詳細講解，探討C++更深層的使用

1 模板

1.1 模板的概念

模板就是建立通用的模具，大大提高複用性

例如生活中的模板

一寸照片模板：

PPT模板：

模板的特點：

模板不可以直接使用，它只是一個框架
模板的通用並不是萬能的

1.2 函式模板

C++另一種程式設計思想稱為泛型程式設計，主要利用的技術就是模板
C++提供兩種模板機制:函式模板和類别範本

1.2.1 函式模板語法

函式模板作用：

建立一個通用函式，其函式返回值型別和形參型別可以不具體制定，用一個虛擬的型別來代表。

語法：

template<typename T>
函式宣告或定義

解釋：

template --- 宣告建立模板

typename --- 表面其後面的符號是一種資料型別，可以用class代替

T --- 通用的資料型別，名稱可以替換，通常為大寫字母

示例：

//交換整型函式
void swapInt(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}

//交換浮點型函式
void swapDouble(double& a, double& b) {
	double temp = a;
	a = b;
	b = temp;
}

//利用模板提供通用的交換函式
template<typename T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	
	//swapInt(a, b);

	//利用模板實現交換
	//1、自動型別推導
	mySwap(a, b);

	//2、顯示指定型別
	mySwap<int>(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

函式模板利用關鍵字 template
使用函式模板有兩種方式：自動型別推導、顯示指定型別
模板的目的是為了提高複用性，將型別引數化

1.2.2 函式模板注意事項

注意事項：

自動型別推導，必須推匯出一致的資料型別T,才可以使用
模板必須要確定出T的資料型別，才可以使用

示例：

//利用模板提供通用的交換函式
template<class T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}


// 1、自動型別推導，必須推匯出一致的資料型別T,才可以使用
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';

	mySwap(a, b); // 正確，可以推匯出一致的T
	//mySwap(a, c); // 錯誤，推導不出一致的T型別
}


// 2、模板必須要確定出T的資料型別，才可以使用
template<class T>
void func()
{
	cout << "func 呼叫" << endl;
}

void test02()
{
	//func(); //錯誤，模板不能獨立使用，必須確定出T的型別
	func<int>(); //利用顯示指定型別的方式，給T一個型別，才可以使用該模板
}

int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

總結：

使用模板時必須確定出通用資料型別T，並且能夠推匯出一致的型別

1.2.3 函式模板案例

案例描述：

利用函式模板封裝一個排序的函式，可以對不同資料型別陣列進行排序
排序規則從大到小，排序演算法為選擇排序
分別利用char陣列和int陣列進行測試

示例：

//交換的函式模板
template<typename T>
void mySwap(T &a, T&b)
{
	T temp = a;
	a = b;
	b = temp;
}


template<class T> // 也可以替換成typename
//利用選擇排序，進行對陣列從大到小的排序
void mySort(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i; //最大數的下標
		for (int j = i + 1; j < len; j++)
		{
			if (arr[max] < arr[j])
			{
				max = j;
			}
		}
		if (max != i) //如果最大數的下標不是i，交換兩者
		{
			mySwap(arr[max], arr[i]);
		}
	}
}
template<typename T>
void printArray(T arr[], int len) {

	for (int i = 0; i < len; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
}
void test01()
{
	//測試char陣列
	char charArr[] = "bdcfeagh";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}

void test02()
{
	//測試int陣列
	int intArr[] = { 7, 5, 8, 1, 3, 9, 2, 4, 6 };
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);
}

int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

總結：模板可以提高程式碼複用，需要熟練掌握

1.2.4 普通函式與函式模板的區別

普通函式與函式模板區別：

普通函式呼叫時可以發生自動型別轉換（隱式型別轉換）
函式模板呼叫時，如果利用自動型別推導，不會發生隱式型別轉換
如果利用顯示指定型別的方式，可以發生隱式型別轉換

示例：

//普通函式
int myAdd01(int a, int b)
{
	return a + b;
}

//函式模板
template<class T>
T myAdd02(T a, T b)  
{
	return a + b;
}

//使用函式模板時，如果用自動型別推導，不會發生自動型別轉換,即隱式型別轉換
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	
	cout << myAdd01(a, c) << endl; //正確，將char型別的'c'隱式轉換為int型別  'c' 對應 ASCII碼 99

	//myAdd02(a, c); // 報錯，使用自動型別推導時，不會發生隱式型別轉換

	myAdd02<int>(a, c); //正確，如果用顯示指定型別，可以發生隱式型別轉換
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：建議使用顯示指定型別的方式，呼叫函式模板，因為可以自己確定通用型別T

1.2.5 普通函式與函式模板的呼叫規則

呼叫規則如下：

如果函式模板和普通函式都可以實現，優先呼叫普通函式
可以通過空模板引數列表來強制呼叫函式模板
函式模板也可以發生過載
如果函式模板可以產生更好的匹配,優先呼叫函式模板

示例：

//普通函式與函式模板呼叫規則
void myPrint(int a, int b)
{
	cout << "呼叫的普通函式" << endl;
}

template<typename T>
void myPrint(T a, T b) 
{ 
	cout << "呼叫的模板" << endl;
}

template<typename T>
void myPrint(T a, T b, T c) 
{ 
	cout << "呼叫過載的模板" << endl; 
}

void test01()
{
	//1、如果函式模板和普通函式都可以實現，優先呼叫普通函式
	// 注意 如果告訴編譯器  普通函式是有的，但只是宣告沒有實現，或者不在當前檔案內實現，就會報錯找不到
	int a = 10;
	int b = 20;
	myPrint(a, b); //呼叫普通函式

	//2、可以通過空模板引數列表來強制呼叫函式模板
	myPrint<>(a, b); //呼叫函式模板

	//3、函式模板也可以發生過載
	int c = 30;
	myPrint(a, b, c); //呼叫過載的函式模板

	//4、 如果函式模板可以產生更好的匹配,優先呼叫函式模板
	char c1 = 'a';
	char c2 = 'b';
	myPrint(c1, c2); //呼叫函式模板
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：既然提供了函式模板，最好就不要提供普通函式，否則容易出現二義性

1.2.6 模板的侷限性

侷限性：

模板的通用性並不是萬能的

例如：

	template<class T>
	void f(T a, T b)
	{ 
    	a = b;
    }

在上述程式碼中提供的賦值操作，如果傳入的a和b是一個陣列，就無法實現了

再例如：

	template<class T>
	void f(T a, T b)
	{ 
    	if(a > b) { ... }
    }

在上述程式碼中，如果T的資料型別傳入的是像Person這樣的自定義資料型別，也無法正常執行

因此C++為了解決這種問題，提供模板的過載，可以為這些特定的型別提供具體化的模板

示例：

#include<iostream>
using namespace std;
#include <string>

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

//普通函式模板
template<class T>
bool myCompare(T& a, T& b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}


//具體化，顯示具體化的原型和定義是以template<>開頭，並通過名稱來指出型別
//具體化優先於常規模板
template<> bool myCompare(Person &p1, Person &p2)
{
	if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test01()
{
	int a = 10;
	int b = 20;
	//內建資料型別可以直接使用通用的函式模板
	bool ret = myCompare(a, b);
	if (ret)
	{
		cout << "a == b " << endl;
	}
	else
	{
		cout << "a != b " << endl;
	}
}

void test02()
{
	Person p1("Tom", 10);
	Person p2("Tom", 10);
	//自定義資料型別，不會呼叫普通的函式模板
	//可以過載建立具體化的Person資料型別的模板，用於特殊處理這個型別
	bool ret = myCompare(p1, p2);
	if (ret)
	{
		cout << "p1 == p2 " << endl;
	}
	else
	{
		cout << "p1 != p2 " << endl;
	}
}

int main() {

	test01();

	test02();

	system("pause");

	return 0;
}

總結：

利用具體化的模板，可以解決自定義型別的通用化
學習模板並不是為了寫模板，而是在STL能夠運用系統提供的模板

1.3 類别範本

1.3.1 類别範本語法

類别範本作用：

建立一個通用類，類中的成員資料型別可以不具體制定，用一個虛擬的型別來代表。

語法：

template<typename T>
類

解釋：

template --- 宣告建立模板

typename --- 表面其後面的符號是一種資料型別，可以用class代替

T --- 通用的資料型別，名稱可以替換，通常為大寫字母

示例：

#include <string>
//類别範本
template<class NameType, class AgeType> 
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

void test01()
{
	// 指定NameType 為string型別，AgeType 為 int型別
	Person<string, int>P1("孫悟空", 999);
	P1.showPerson();
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：類别範本和函式模板語法相似，在宣告模板template後面加類，此類稱為類别範本

1.3.2 類别範本與函式模板區別

類别範本與函式模板區別主要有兩點：

類别範本沒有自動型別推導的使用方式
類别範本在模板引數列表中可以有預設引數

示例：

#include <string>
//類别範本
template<class NameType, class AgeType = int> 
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

//1、類别範本沒有自動型別推導的使用方式
void test01()
{
	// Person p("孫悟空", 1000); // 錯誤 類别範本使用時候，不可以用自動型別推導
	Person <string ,int>p("孫悟空", 1000); //必須使用顯示指定型別的方式，使用類别範本
	p.showPerson();
}

//2、類别範本在模板引數列表中可以有預設引數
void test02()
{
    //省略了Int引數，會使用預設
	Person <string> p("豬八戒", 999); //類别範本中的模板引數列表 可以指定預設引數
	p.showPerson();
}

int main() {

	test01();
	test02();

	system("pause");
	return 0;
}

總結：

類别範本使用只能用顯示指定型別方式
類别範本中的模板引數列表可以有預設引數

1.3.3 類别範本中成員函式建立時機

類别範本中成員函式和普通類中成員函式建立時機是有區別的：

普通類中的成員函式一開始就可以建立
類别範本中的成員函式在呼叫時才建立

示例：

class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};

template<class T>
class MyClass
{
public:
	T obj;

	//類别範本中的成員函式，並不是一開始就建立的，而是在模板呼叫時再生成

	void fun1() { obj.showPerson1(); }
	void fun2() { obj.showPerson2(); }

};

void test01()
{
	MyClass<Person1> m;
	
	m.fun1();

	//m.fun2();//編譯會出錯，說明函式呼叫才會去建立成員函式
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：類别範本中的成員函式並不是一開始就建立的，在呼叫時才去建立

1.3.4 類别範本物件做函式引數

學習目標：

類别範本例項化出的物件，向函式傳參的方式

一共有三種傳入方式：

指定傳入的型別 --- 直接顯示物件的資料型別
引數模板化 --- 將物件中的引數變為模板進行傳遞
整個類别範本化 --- 將這個物件型別模板化進行傳遞

示例：

#include <string>
//類别範本
template<class NameType, class AgeType = int> 
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

//1、指定傳入的型別
void printPerson1(Person<string, int> &p) 
{
	p.showPerson();
}
void test01()
{
	Person <string, int >p("孫悟空", 100);
	printPerson1(p);
}

//2、引數模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2>&p)
{
	p.showPerson();
	cout << "T1的型別為： " << typeid(T1).name() << endl;
	cout << "T2的型別為： " << typeid(T2).name() << endl;
}
void test02()
{
	Person <string, int >p("豬八戒", 90);
	printPerson2(p);
}

//3、整個類别範本化
template<class T>
void printPerson3(T & p)
{
	cout << "T的型別為： " << typeid(T).name() << endl;
	p.showPerson();

}
void test03()
{
	Person <string, int >p("唐僧", 30);
	printPerson3(p);
}

int main() {

	test01();
	test02();
	test03();

	system("pause");

	return 0;
}

總結：

通過類别範本建立的物件，可以有三種方式向函式中進行傳參
使用比較廣泛是第一種：指定傳入的型別

1.3.5 類别範本與繼承

當類别範本碰到繼承時，需要注意一下幾點：

當子類繼承的父類是一個類别範本時，子類在宣告的時候，要指定出父類中T的型別
如果不指定，編譯器無法給子類分配記憶體
如果想靈活指定出父類中T的型別，子類也需變為類别範本

示例：

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

//class Son:public Base  //錯誤，c++編譯需要給子類分配記憶體，必須知道父類中T的型別才可以向下繼承
class Son :public Base<int> //必須指定一個型別
{
};
void test01()
{
	Son c;
}

//類别範本繼承類别範本 ,可以用T2指定父類中的T型別
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
	Son2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
};

void test02()
{
	Son2<int, char> child1;
}


int main() {

	test01();

	test02();

	system("pause");

	return 0;
}

總結：如果父類是類别範本，子類需要指定出父類中T的資料型別

1.3.6 類别範本成員函式類外實現

學習目標：能夠掌握類别範本中的成員函式類外實現

示例：

#include <string>

//類别範本中成員函式類外實現
template<class T1, class T2>
class Person {
public:
	//成員函式類內宣告
	Person(T1 name, T2 age);
	void showPerson();

public:
	T1 m_Name;
	T2 m_Age;
};

//建構函式 類外實現
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
	this->m_Name = name;
	this->m_Age = age;
}

//成員函式 類外實現
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
	cout << "姓名: " << this->m_Name << " 年齡:" << this->m_Age << endl;
}

void test01()
{
	Person<string, int> p("Tom", 20);
	p.showPerson();
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：類别範本中成員函式類外實現時，需要加上模板引數列表

1.3.7 類别範本分檔案編寫

學習目標：

掌握類别範本成員函式分檔案編寫產生的問題以及解決方式

問題：

類别範本中成員函式建立時機是在呼叫階段，導致分檔案編寫時連結不到

解決：

解決方式1：直接包含.cpp原始檔
解決方式2：將宣告和實現寫到同一個檔案中，並更改字尾名為.hpp，hpp是約定的名稱，並不是強制

示例：

person.hpp中程式碼：

#pragma once
#include <iostream>
using namespace std;
#include <string>

template<class T1, class T2>
class Person {
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};

//建構函式 類外實現
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
	this->m_Name = name;
	this->m_Age = age;
}

//成員函式 類外實現
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
	cout << "姓名: " << this->m_Name << " 年齡:" << this->m_Age << endl;
}

類别範本分檔案編寫.cpp中程式碼

#include<iostream>
using namespace std;

//#include "person.h"
#include "person.cpp" //解決方式1，包含cpp原始檔

//解決方式2，將宣告和實現寫到一起，檔案字尾名改為.hpp
#include "person.hpp"
void test01()
{
	Person<string, int> p("Tom", 10);
	p.showPerson();
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：主流的解決方式是第二種，將類和模板成員函式寫到一起，並將字尾名改為.hpp

1.3.8 類别範本與友元

學習目標：

掌握類别範本配合友元函式的類內和類外實現

全域性函式類內實現 - 直接在類內宣告友元即可

全域性函式類外實現 - 需要提前讓編譯器知道全域性函式的存在

示例：

#include <string>

//2、全域性函式配合友元  類外實現 - 先做函式模板宣告，下方在做函式模板定義，在做友元
template<class T1, class T2> class Person;

//如果宣告瞭函式模板，可以將實現寫到後面，否則需要將實現體寫到類的前面讓編譯器提前看到
//template<class T1, class T2> void printPerson2(Person<T1, T2> & p); 

template<class T1, class T2>
void printPerson2(Person<T1, T2> & p)
{
	cout << "類外實現 ---- 姓名： " << p.m_Name << " 年齡：" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
	//1、全域性函式配合友元   類內實現
	friend void printPerson(Person<T1, T2> & p)
	{
		cout << "姓名： " << p.m_Name << " 年齡：" << p.m_Age << endl;
	}


	//全域性函式配合友元  類外實現
	friend void printPerson2<>(Person<T1, T2> & p);

public:

	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}


private:
	T1 m_Name;
	T2 m_Age;

};

//1、全域性函式在類內實現
void test01()
{
	Person <string, int >p("Tom", 20);
	printPerson(p);
}


//2、全域性函式在類外實現
void test02()
{
	Person <string, int >p("Jerry", 30);
	printPerson2(p);
}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

總結：建議全域性函式做類內實現，用法簡單，而且編譯器可以直接識別

1.3.9 類别範本案例

案例描述: 實現一個通用的陣列類，要求如下：

可以對內建資料型別以及自定義資料型別的資料進行儲存
將陣列中的資料儲存到堆區
建構函式中可以傳入陣列的容量
提供對應的拷貝建構函式以及operator=防止淺拷貝問題
提供尾插法和尾刪法對陣列中的資料進行增加和刪除
可以通過下標的方式訪問陣列中的元素
可以獲取陣列中當前元素個數和陣列的容量

示例：

myArray.hpp中程式碼

#pragma once
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
public:
    
	//建構函式
	MyArray(int capacity)
	{
		this->m_Capacity = capacity;
		this->m_Size = 0;
		pAddress = new T[this->m_Capacity];
	}

	//拷貝構造
	MyArray(const MyArray & arr)
	{
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < this->m_Size; i++)
		{
			//如果T為物件，而且還包含指標，必須需要過載 = 操作符，因為這個等號不是 構造 而是賦值，
			// 普通型別可以直接= 但是指標型別需要深拷貝
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	//過載= 操作符  防止淺拷貝問題
	MyArray& operator=(const MyArray& myarray) {

		if (this->pAddress != NULL) {
			delete[] this->pAddress;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		this->m_Capacity = myarray.m_Capacity;
		this->m_Size = myarray.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < this->m_Size; i++) {
			this->pAddress[i] = myarray[i];
		}
		return *this;
	}

	//過載[] 操作符  arr[0]
	T& operator [](int index)
	{
		return this->pAddress[index]; //不考慮越界，使用者自己去處理
	}

	//尾插法
	void Push_back(const T & val)
	{
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val;
		this->m_Size++;
	}

	//尾刪法
	void Pop_back()
	{
		if (this->m_Size == 0)
		{
			return;
		}
		this->m_Size--;
	}

	//獲取陣列容量
	int getCapacity()
	{
		return this->m_Capacity;
	}

	//獲取陣列大小
	int	getSize()
	{
		return this->m_Size;
	}


	//析構
	~MyArray()
	{
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}
	}

private:
	T * pAddress;  //指向一個堆空間，這個空間儲存真正的資料
	int m_Capacity; //容量
	int m_Size;   // 大小
};

類别範本案例—陣列類封裝.cpp中

#include "myArray.hpp"
#include <string>

void printIntArray(MyArray<int>& arr) {
	for (int i = 0; i < arr.getSize(); i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
}

//測試內建資料型別
void test01()
{
	MyArray<int> array1(10);
	for (int i = 0; i < 10; i++)
	{
		array1.Push_back(i);
	}
	cout << "array1列印輸出：" << endl;
	printIntArray(array1);
	cout << "array1的大小：" << array1.getSize() << endl;
	cout << "array1的容量：" << array1.getCapacity() << endl;

	cout << "--------------------------" << endl;

	MyArray<int> array2(array1);
	array2.Pop_back();
	cout << "array2列印輸出：" << endl;
	printIntArray(array2);
	cout << "array2的大小：" << array2.getSize() << endl;
	cout << "array2的容量：" << array2.getCapacity() << endl;
}

//測試自定義資料型別
class Person {
public:
	Person() {} 
		Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	string m_Name;
	int m_Age;
};

void printPersonArray(MyArray<Person>& personArr)
{
	for (int i = 0; i < personArr.getSize(); i++) {
		cout << "姓名：" << personArr[i].m_Name << " 年齡： " << personArr[i].m_Age << endl;
	}

}

void test02()
{
	//建立陣列
	MyArray<Person> pArray(10);
	Person p1("孫悟空", 30);
	Person p2("韓信", 20);
	Person p3("妲己", 18);
	Person p4("王昭君", 15);
	Person p5("趙雲", 24);

	//插入資料
	pArray.Push_back(p1);
	pArray.Push_back(p2);
	pArray.Push_back(p3);
	pArray.Push_back(p4);
	pArray.Push_back(p5);

	printPersonArray(pArray);

	cout << "pArray的大小：" << pArray.getSize() << endl;
	cout << "pArray的容量：" << pArray.getCapacity() << endl;

}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

總結：

能夠利用所學知識點實現通用的陣列

2 STL初識

2.1 STL的誕生

長久以來，軟體界一直希望建立一種可重複利用的東西
C++的物件導向和泛型程式設計思想，目的就是複用性的提升
大多情況下，資料結構和演算法都未能有一套標準,導致被迫從事大量重複工作
為了建立資料結構和演算法的一套標準,誕生了STL

2.2 STL基本概念

STL(Standard Template Library,標準模板庫)
STL 從廣義上分為: 容器(container) 演算法(algorithm) 迭代器(iterator)
容器和演算法之間通過迭代器進行無縫連線。
STL 幾乎所有的程式碼都採用了模板類或者模板函式

2.3 STL六大元件

STL大體分為六大元件，分別是:容器、演算法、迭代器、仿函式、介面卡（配接器）、空間配置器

容器：各種資料結構，如vector、list、deque、set、map等,用來存放資料。
演算法：各種常用的演算法，如sort、find、copy、for_each等
迭代器：扮演了容器與演算法之間的膠合劑。
仿函式：行為類似函式，可作為演算法的某種策略。
介面卡：一種用來修飾容器或者仿函式或迭代器介面的東西。
空間配置器：負責空間的配置與管理。

2.4 STL中容器、演算法、迭代器

容器：置物之所也

STL容器就是將運用最廣泛的一些資料結構實現出來

常用的資料結構：陣列, 連結串列,樹, 棧, 佇列, 集合, 對映表等

這些容器分為序列式容器和關聯式容器兩種:

序列式容器:強調值的排序，序列式容器中的每個元素均有固定的位置。
關聯式容器:二叉樹結構，各元素之間沒有嚴格的物理上的順序關係

演算法：問題之解法也

有限的步驟，解決邏輯或數學上的問題，這一門學科我們叫做演算法(Algorithms)

演算法分為:質變演算法和非質變演算法。

質變演算法：是指運算過程中會更改區間內的元素的內容。例如拷貝，替換，刪除等等

非質變演算法：是指運算過程中不會更改區間內的元素內容，例如查詢、計數、遍歷、尋找極值等等

迭代器：容器和演算法之間粘合劑

提供一種方法，使之能夠依序尋訪某個容器所含的各個元素，而又無需暴露該容器的內部表示方式。

每個容器都有自己專屬的迭代器

迭代器使用非常類似於指標，初學階段我們可以先理解迭代器為指標

迭代器種類：

種類	功能	支援運算
輸入迭代器	對資料的只讀訪問	只讀，支援++、==、！=
輸出迭代器	對資料的只寫訪問	只寫，支援++
前向迭代器	讀寫操作，並能向前推進迭代器	讀寫，支援++、==、！=
雙向迭代器	讀寫操作，並能向前和向後操作	讀寫，支援++、--，
隨機訪問迭代器	讀寫操作，可以以跳躍的方式訪問任意資料，功能最強的迭代器	讀寫，支援++、--、[n]、-n、<、<=、>、>=

常用的容器中迭代器種類為雙向迭代器，和隨機訪問迭代器

2.5 容器演算法迭代器初識

瞭解STL中容器、演算法、迭代器概念之後，我們利用程式碼感受STL的魅力

STL中最常用的容器為Vector，可以理解為陣列，下面我們將學習如何向這個容器中插入資料、並遍歷這個容器

2.5.1 vector存放內建資料型別

容器： vector

演算法： for_each

迭代器： vector<int>::iterator

示例：

#include <vector>
#include <algorithm>

void MyPrint(int val)
{
	cout << val << endl;
}

void test01() {

	//建立vector容器物件，並且通過模板引數指定容器中存放的資料的型別
	vector<int> v;
	//向容器中放資料
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	//每一個容器都有自己的迭代器，迭代器是用來遍歷容器中的元素
	//v.begin()返回迭代器，這個迭代器指向容器中第一個資料
	//v.end()返回迭代器，這個迭代器指向容器元素的最後一個元素的 下一個位置
	//vector<int>::iterator 拿到vector<int>這種容器的迭代器型別

	vector<int>::iterator pBegin = v.begin();
	vector<int>::iterator pEnd = v.end();

	//第一種遍歷方式：
	while (pBegin != pEnd) {
		cout << *pBegin << endl;
		pBegin++;
	}

	
	//第二種遍歷方式：
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << endl;
	}
	cout << endl;

	//第三種遍歷方式：
	//使用STL提供標準遍歷演算法  標頭檔案 algorithm
	for_each(v.begin(), v.end(), MyPrint);
}

int main() {

	test01();

	system("pause");
	return 0;
}

2.5.2 Vector存放自定義資料型別

學習目標：vector中存放自定義資料型別，並列印輸出

示例：

#include <vector>
#include <string>

//自定義資料型別
class Person {
public:
	Person(string name, int age) {
		mName = name;
		mAge = age;
	}
public:
	string mName;
	int mAge;
};
//存放物件
void test01() {

	vector<Person> v;

	//建立資料
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		cout << "Name:" << (*it).mName << " Age:" << (*it).mAge << endl;

	}
}


//放物件指標
void test02() {

	vector<Person*> v;

	//建立資料
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);

	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) {
		Person * p = (*it);
		cout << "Name:" << p->mName << " Age:" << (*it)->mAge << endl;
	}
}


int main() {

	test01();
    
	test02();

	system("pause");
	return 0;
}

2.5.3 Vector容器巢狀容器

學習目標：容器中巢狀容器，我們將所有資料進行遍歷輸出

示例：

#include <vector>

//容器巢狀容器
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);
	}

	//將容器元素插入到vector v中
	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 vit = (*it).begin(); vit != (*it).end(); vit++) {
			cout << *vit << " ";
		}
		cout << endl;
	}

}

int main() {

	test01();

	system("pause");

	return 0;
}

3 STL- 常用容器

3.1 string容器

3.1.1 string基本概念

本質：

string是C++風格的字串，而string本質上是一個類

string和char * 區別：

char * 是一個指標
string是一個類，類內部封裝了char*，管理這個字串，是一個char*型的容器。

特點：

string 類內部封裝了很多成員方法

例如：查詢find，拷貝copy，刪除delete ，替換replace，插入insert

string管理char*所分配的記憶體，不用擔心複製越界和取值越界等，由類內部進行負責

3.1.2 string建構函式

建構函式原型：

string(); //建立一個空的字串例如: string str;
string(const char* s); //使用字串s初始化
string(const string& str); //使用一個string物件初始化另一個string物件
string(int n, char c); //使用n個字元c初始化

示例：

#include <string>
//string構造
void test01()
{
	string s1; //建立空字串，呼叫無參建構函式
	cout << "str1 = " << s1 << endl;

	const char* str = "hello world";
	string s2(str); //把c_string轉換成了string

	cout << "str2 = " << s2 << endl;

	string s3(s2); //呼叫拷貝建構函式
	cout << "str3 = " << s3 << endl;

	string s4(10, 'a');
	cout << "str3 = " << s3 << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：string的多種構造方式沒有可比性，靈活使用即可

3.1.3 string賦值操作

功能描述：

給string字串進行賦值

賦值的函式原型：

string& operator=(const char* s); //char*型別字串賦值給當前的字串
string& operator=(const string &s); //把字串s賦給當前的字串
string& operator=(char c); //字元賦值給當前的字串
string& assign(const char *s); //把字串s賦給當前的字串
string& assign(const char *s, int n); //把字串s的前n個字元賦給當前的字串
string& assign(const string &s); //把字串s賦給當前字串
string& assign(int n, char c); //用n個字元c賦給當前字串

示例：

//賦值
void test01()
{
	string str1;
	str1 = "hello world";
	cout << "str1 = " << str1 << endl;

	string str2;
	str2 = str1;
	cout << "str2 = " << str2 << endl;

	string str3;
	str3 = 'a';
	cout << "str3 = " << str3 << endl;

	string str4;
	str4.assign("hello c++");
	cout << "str4 = " << str4 << endl;

	string str5;
	str5.assign("hello c++",5);
	cout << "str5 = " << str5 << endl;


	string str6;
	str6.assign(str5);
	cout << "str6 = " << str6 << endl;

	string str7;
	str7.assign(5, 'x');
	cout << "str7 = " << str7 << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

string的賦值方式很多，operator= 這種方式是比較實用的

3.1.4 string字串拼接

功能描述：

實現在字串末尾拼接字串

函式原型：

string& operator+=(const char* str); //過載+=操作符
string& operator+=(const char c); //過載+=操作符
string& operator+=(const string& str); //過載+=操作符
string& append(const char *s); //把字串s連線到當前字串結尾
string& append(const char *s, int n); //把字串s的前n個字元連線到當前字串結尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s, int pos, int n);//字串s中從pos開始的n個字元連線到字串結尾

示例：

//字串拼接
void test01()
{
	string str1 = "我";

	str1 += "愛玩遊戲";

	cout << "str1 = " << str1 << endl;
	
	str1 += ':';

	cout << "str1 = " << str1 << endl;

	string str2 = "LOL DNF";

	str1 += str2;

	cout << "str1 = " << str1 << endl;

	string str3 = "I";
	str3.append(" love ");
	str3.append("game abcde", 4);
	//str3.append(str2);
	str3.append(str2, 4, 3); // 從下標4位置開始 ，擷取3個字元，拼接到字串末尾
	cout << "str3 = " << str3 << endl;
}
int main() {

	test01();

	system("pause");

	return 0;
}

總結：字串拼接的過載版本很多，初學階段記住幾種即可

3.1.5 string查詢和替換

功能描述：

查詢：查詢指定字串是否存在
替換：在指定的位置替換字串

函式原型：

int find(const string& str, int pos = 0) const; //查詢str第一次出現位置,從pos開始查詢
int find(const char* s, int pos = 0) const; //查詢s第一次出現位置,從pos開始查詢
int find(const char* s, int pos, int n) const; //從pos位置查詢s的前n個字元第一次位置
int find(const char c, int pos = 0) const; //查詢字元c第一次出現位置
int rfind(const string& str, int pos = npos) const; //查詢str最後一次位置,從pos開始查詢
int rfind(const char* s, int pos = npos) const; //查詢s最後一次出現位置,從pos開始查詢
int rfind(const char* s, int pos, int n) const; //從pos查詢s的前n個字元最後一次位置
int rfind(const char c, int pos = 0) const; //查詢字元c最後一次出現位置
string& replace(int pos, int n, const string& str); //替換從pos開始n個字元為字串str
string& replace(int pos, int n,const char* s); //替換從pos開始的n個字元為字串s

示例：

//查詢和替換
void test01()
{
	//查詢
	string str1 = "abcdefgde";

	int pos = str1.find("de");

	if (pos == -1)
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "pos = " << pos << endl;
	}
	

	pos = str1.rfind("de");

	cout << "pos = " << pos << endl;

}

void test02()
{
	//替換
	string str1 = "abcdefgde";
	str1.replace(1, 3, "1111");

	cout << "str1 = " << str1 << endl;
}

int main() {

	//test01();
	//test02();

	system("pause");

	return 0;
}

總結：

find查詢是從左往後，rfind從右往左
find找到字串後返回查詢的第一個字元位置，找不到返回-1
replace在替換時，要指定從哪個位置起，多少個字元，替換成什麼樣的字串

3.1.6 string字串比較

功能描述：

字串之間的比較

比較方式：

字串比較是按字元的ASCII碼進行對比

= 返回 0

> 返回 1

< 返回 -1

函式原型：

int compare(const string &s) const; //與字串s比較
int compare(const char *s) const; //與字串s比較

示例：

//字串比較
void test01()
{

	string s1 = "hello";
	string s2 = "aello";

	int ret = s1.compare(s2);

	if (ret == 0) {
		cout << "s1 等於 s2" << endl;
	}
	else if (ret > 0)
	{
		cout << "s1 大於 s2" << endl;
	}
	else
	{
		cout << "s1 小於 s2" << endl;
	}

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：字串對比主要是用於比較兩個字串是否相等，判斷誰大誰小的意義並不是很大

3.1.7 string字元存取

string中單個字元存取方式有兩種

char& operator[](int n); //通過[]方式取字元
char& at(int n); //通過at方法獲取字元

示例：

void test01()
{
	string str = "hello world";

	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;


	//字元修改
	str[0] = 'x';
	str.at(1) = 'x';
	cout << str << endl;
	
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：string字串中單個字元存取有兩種方式，利用 [ ] 或 at

3.1.8 string插入和刪除

功能描述：

對string字串進行插入和刪除字元操作

函式原型：

string& insert(int pos, const char* s); //插入字串
string& insert(int pos, const string& str); //插入字串
string& insert(int pos, int n, char c); //在指定位置插入n個字元c
string& erase(int pos, int n = npos); //刪除從Pos開始的n個字元

示例：

//字串插入和刪除
void test01()
{
	string str = "hello";
	str.insert(1, "111");
	cout << str << endl;

	str.erase(1, 3);  //從1號位置開始3個字元
	cout << str << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：插入和刪除的起始下標都是從0開始

3.1.9 string子串

功能描述：

從字串中獲取想要的子串

函式原型：

string substr(int pos = 0, int n = npos) const; //返回由pos開始的n個字元組成的字串

示例：

//子串
void test01()
{

	string str = "abcdefg";
	string subStr = str.substr(1, 3);
	cout << "subStr = " << subStr << endl;

	string email = "hello@sina.com";
	int pos = email.find("@");
	string username = email.substr(0, pos);
	cout << "username: " << username << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：靈活的運用求子串功能，可以在實際開發中獲取有效的資訊

3.2 vector容器

3.2.1 vector基本概念

功能：

vector資料結構和陣列非常相似，也稱為單端陣列

vector與普通陣列區別：

不同之處在於陣列是靜態空間，而vector可以動態擴充套件

動態擴充套件：

並不是在原空間之後續接新空間，而是找更大的記憶體空間，然後將原資料拷貝新空間，釋放原空間

vector容器的迭代器是支援隨機訪問的迭代器

3.2.2 vector建構函式

功能描述：

建立vector容器

函式原型：

vector<T> v; //採用模板實現類實現，預設建構函式
vector(v.begin(), v.end()); //將v[begin(), end())區間中的元素拷貝給本身。
vector(n, elem); //建構函式將n個elem拷貝給本身。
vector(const vector &vec); //拷貝建構函式。

示例：

#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int> v1; //無參構造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	vector<int> v2(v1.begin(), v1.end());
	printVector(v2);

	vector<int> v3(10, 100);
	printVector(v3);
	
	vector<int> v4(v3);
	printVector(v4);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：vector的多種構造方式沒有可比性，靈活使用即可

3.2.3 vector賦值操作

功能描述：

給vector容器進行賦值

函式原型：

vector& operator=(const vector &vec);//過載等號操作符
assign(beg, end); //將[beg, end)區間中的資料拷貝賦值給本身。
assign(n, elem); //將n個elem拷貝賦值給本身。

示例：

#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//賦值操作
void test01()
{
	vector<int> v1; //無參構造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	vector<int>v2;
	v2 = v1;
	printVector(v2);

	vector<int>v3;
	v3.assign(v1.begin(), v1.end());
	printVector(v3);

	vector<int>v4;
	v4.assign(10, 100);
	printVector(v4);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結： vector賦值方式比較簡單，使用operator=，或者assign都可以

3.2.4 vector容量和大小

功能描述：

對vector容器的容量和大小操作

函式原型：

empty(); //判斷容器是否為空
capacity(); //容器的容量
size(); //返回容器中元素的個數
resize(int num); //重新指定容器的長度為num，若容器變長，則以預設值填充新位置。

//如果容器變短，則末尾超出容器長度的元素被刪除。
resize(int num, elem); //重新指定容器的長度為num，若容器變長，則以elem值填充新位置。

//如果容器變短，則末尾超出容器長度的元素被刪除

示例：

#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	if (v1.empty())
	{
		cout << "v1為空" << endl;
	}
	else
	{
		cout << "v1不為空" << endl;
		cout << "v1的容量 = " << v1.capacity() << endl;
		cout << "v1的大小 = " << v1.size() << endl;
	}

	//resize 重新指定大小 ，若指定的更大，預設用0填充新位置，可以利用過載版本替換預設填充
	v1.resize(15,10);
	printVector(v1);

	//resize 重新指定大小 ，若指定的更小，超出部分元素被刪除
	v1.resize(5);
	printVector(v1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

判斷是否為空 --- empty
返回元素個數 --- size
返回容器容量 --- capacity
重新指定大小 --- resize

3.2.5 vector插入和刪除

功能描述：

對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(); //刪除容器中所有元素

示例：

#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//插入和刪除
void test01()
{
	vector<int> v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	printVector(v1);
	//尾刪
	v1.pop_back();
	printVector(v1);
	//插入
	v1.insert(v1.begin(), 100);
	printVector(v1);

	v1.insert(v1.begin(), 2, 1000);
	printVector(v1);

	//刪除
	v1.erase(v1.begin());
	printVector(v1);

	//清空
	v1.erase(v1.begin(), v1.end());
	v1.clear();
	printVector(v1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

尾插 --- push_back
尾刪 --- pop_back
插入 --- insert (位置迭代器)
刪除 --- erase （位置迭代器）
清空 --- clear

3.2.6 vector資料存取

功能描述：

對vector中的資料的存取操作

函式原型：

at(int idx); //返回索引idx所指的資料
operator[idx]; //返回索引idx所指的資料
front(); //返回容器中第一個資料元素
back(); //返回容器中最後一個資料元素

示例：

#include <vector>

void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << " ";
	}
	cout << endl;

	cout << "v1的第一個元素為： " << v1.front() << endl;
	cout << "v1的最後一個元素為： " << v1.back() << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

除了用迭代器獲取vector容器中元素，[ ]和at也可以
front返回容器第一個元素
back返回容器最後一個元素

3.2.7 vector互換容器

功能描述：

實現兩個容器內元素進行互換

函式原型：

swap(vec); // 將vec與本身的元素互換

示例：

#include <vector>

void printVector(vector<int>& v) {

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
   	cout << "交換前： " << endl;
	printVector(v1);

    //轉置
	vector<int>v2;
	for (int i = 10; i > 0; i--)
	{
		v2.push_back(i);
	}
	printVector(v2);

	//互換容器
	cout << "互換後" << endl;
	v1.swap(v2);
	printVector(v1);
	printVector(v2);
}

void test02()
{
	vector<int> v;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
	}

	cout << "v的容量為：" << v.capacity() << endl;
	cout << "v的大小為：" << v.size() << endl;

	v.resize(3);

	cout << "v的容量為：" << v.capacity() << endl;
	cout << "v的大小為：" << v.size() << endl;

	//收縮記憶體
	vector<int>(v).swap(v); //匿名物件

	cout << "v的容量為：" << v.capacity() << endl;
	cout << "v的大小為：" << v.size() << endl;
}

int main() {

	test01();

	test02();

	system("pause");
	return 0;
}

總結：swap可以使兩個容器互換，可以達到實用的收縮記憶體效果

3.2.8 vector預留空間

功能描述：

減少vector在動態擴充套件容量時的擴充套件次數

函式原型：

reserve(int len);//容器預留len個元素長度，預留位置不初始化，元素不可訪問。

示例：

#include <vector>

void test01()
{
	vector<int> v;

	//預留空間
	v.reserve(100000);

	int num = 0;
	int* p = NULL;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
		if (p != &v[0]) {
			p = &v[0];
			num++;
		}
	}

	cout << "num:" << num << endl;
}

int main() {

	test01();
    
	system("pause");
	return 0;
}

總結：如果資料量較大，可以一開始利用reserve預留空間

3.3 deque容器

3.3.1 deque容器基本概念

功能：

雙端陣列，可以對頭端進行插入刪除操作

deque與vector區別：

vector對於頭部的插入刪除效率低，資料量越大，效率越低
deque相對而言，對頭部的插入刪除速度回比vector快
vector訪問元素時的速度會比deque快,這和兩者內部實現有關

deque內部工作原理:

deque內部有個中控器，維護每段緩衝區中的內容，緩衝區中存放真實資料

中控器維護的是每個緩衝區的地址，使得使用deque時像一片連續的記憶體空間

deque容器的迭代器也是支援隨機訪問的

3.3.2 deque建構函式

功能描述：

deque容器構造

函式原型：

deque<T> deqT; //預設構造形式
deque(beg, end); //建構函式將[beg, end)區間中的元素拷貝給本身。
deque(n, elem); //建構函式將n個elem拷貝給本身。
deque(const deque &deq); //拷貝建構函式

示例：

#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//deque構造
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;
	printDeque(d4);
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：deque容器和vector容器的構造方式幾乎一致，靈活使用即可

3.3.3 deque賦值操作

功能描述：

給deque容器進行賦值

函式原型：

deque& operator=(const deque &deq); //過載等號操作符
assign(beg, end); //將[beg, end)區間中的資料拷貝賦值給本身。
assign(n, elem); //將n個elem拷貝賦值給本身。

示例：

#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//賦值操作
void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	deque<int>d2;
	d2 = d1;
	printDeque(d2);

	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	deque<int>d4;
	d4.assign(10, 100);
	printDeque(d4);

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：deque賦值操作也與vector相同，需熟練掌握

3.3.4 deque大小操作

功能描述：

對deque容器的大小進行操作

函式原型：

deque.empty(); //判斷容器是否為空
deque.size(); //返回容器中元素的個數
deque.resize(num); //重新指定容器的長度為num,若容器變長，則以預設值填充新位置。

//如果容器變短，則末尾超出容器長度的元素被刪除。
deque.resize(num, elem); //重新指定容器的長度為num,若容器變長，則以elem值填充新位置。

//如果容器變短，則末尾超出容器長度的元素被刪除。

示例：

#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

//大小操作
void test01()
{
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	//判斷容器是否為空
	if (d1.empty()) {
		cout << "d1為空!" << endl;
	}
	else {
		cout << "d1不為空!" << endl;
		//統計大小
		cout << "d1的大小為：" << d1.size() << endl;
	}

	//重新指定大小
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(5);
	printDeque(d1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

deque沒有容量的概念
判斷是否為空 --- empty
返回元素個數 --- size
重新指定個數 --- resize

3.3.5 deque 插入和刪除

功能描述：

向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位置的資料，返回下一個資料的位置。

示例：

#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//兩端操作
void test01()
{
	deque<int> d;
	//尾插
	d.push_back(10);
	d.push_back(20);
	//頭插
	d.push_front(100);
	d.push_front(200);

	printDeque(d);

	//尾刪
	d.pop_back();
	//頭刪
	d.pop_front();
	printDeque(d);
}

//插入
void test02()
{
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.insert(d.begin(), 1000);
	printDeque(d);

	d.insert(d.begin(), 2,10000);
	printDeque(d);

	deque<int>d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);

	d.insert(d.begin(), d2.begin(), d2.end());
	printDeque(d);

}

//刪除
void test03()
{
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.erase(d.begin());
	printDeque(d);

	d.erase(d.begin(), d.end());
	d.clear();
	printDeque(d);
}

int main() {

	//test01();

	//test02();

    test03();
    
	system("pause");

	return 0;
}

總結：

插入和刪除提供的位置是迭代器！
尾插 --- push_back
尾刪 --- pop_back
頭插 --- push_front
頭刪 --- pop_front

3.3.6 deque 資料存取

功能描述：

對deque 中的資料的存取操作

函式原型：

at(int idx); //返回索引idx所指的資料
operator[]; //返回索引idx所指的資料
front(); //返回容器中第一個資料元素
back(); //返回容器中最後一個資料元素

示例：

#include <deque>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

//資料存取
void test01()
{

	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	for (int i = 0; i < d.size(); i++) {
		cout << d[i] << " ";
	}
	cout << endl;


	for (int i = 0; i < d.size(); i++) {
		cout << d.at(i) << " ";
	}
	cout << endl;

	cout << "front:" << d.front() << endl;

	cout << "back:" << d.back() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

除了用迭代器獲取deque容器中元素，[ ]和at也可以
front返回容器第一個元素
back返回容器最後一個元素

3.3.7 deque 排序

功能描述：

利用演算法實現對deque容器進行排序

演算法：

sort(iterator beg, iterator end) //對beg和end區間內元素進行排序

示例：

#include <deque>
#include <algorithm>

void printDeque(const deque<int>& d) 
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}

void test01()
{

	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	printDeque(d);
	sort(d.begin(), d.end());
	printDeque(d);

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：sort演算法非常實用，使用時包含標頭檔案 algorithm即可

3.4 案例-評委打分

3.4.1 案例描述

有5名選手：選手ABCDE，10個評委分別對每一名選手打分，去除最高分，去除評委中最低分，取平均分。

3.4.2 實現步驟

建立五名選手，放到vector中
遍歷vector容器，取出來每一個選手，執行for迴圈，可以把10個評分打分存到deque容器中
sort演算法對deque容器中分數排序，去除最高和最低分
deque容器遍歷一遍，累加總分
獲取平均分

示例程式碼：

//選手類
class Person
{
public:
	Person(string name, int score)
	{
		this->m_Name = name;
		this->m_Score = score;
	}

	string m_Name; //姓名
	int m_Score;  //平均分
};

void createPerson(vector<Person>&v)
{
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5; i++)
	{
		string name = "選手";
		name += nameSeed[i];

		int score = 0;

		Person p(name, score);

		//將建立的person物件 放入到容器中
		v.push_back(p);
	}
}

//打分
void setScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		//將評委的分數 放入到deque容器中
		deque<int>d;
		for (int i = 0; i < 10; i++)
		{
			int score = rand() % 41 + 60;  // 60 ~ 100
			d.push_back(score);
		}

		//cout << "選手： " << it->m_Name << " 打分： " << endl;
		//for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		//{
		//	cout << *dit << " ";
		//}
		//cout << endl;

		//排序
		sort(d.begin(), d.end());

		//去除最高和最低分
		d.pop_back();
		d.pop_front();

		//取平均分
		int sum = 0;
		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		{
			sum += *dit; //累加每個評委的分數
		}

        //求平均分
		int avg = sum / d.size();

		//將平均分 賦值給選手身上
		it->m_Score = avg;
	}

}

void showScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名： " << it->m_Name << " 平均分： " << it->m_Score << endl;
	}
}

int main() {

	//隨機數種子
	srand((unsigned int)time(NULL));

	//1、建立5名選手
	vector<Person>v;  //存放選手容器
	createPerson(v);

	//測試
	//for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << "姓名： " << (*it).m_Name << " 分數： " << (*it).m_Score << endl;
	//}

	//2、給5名選手打分
	setScore(v);

	//3、顯示最後得分
	showScore(v);

	system("pause");

	return 0;
}

總結： 選取不同的容器運算元據，可以提升程式碼的效率

3.5 stack容器

3.5.1 stack 基本概念

概念：stack是一種先進後出(First In Last Out,FILO)的資料結構，它只有一個出口

棧中只有頂端的元素才可以被外界使用，因此棧不允許有遍歷行為

棧中進入資料稱為 --- 入棧 push

棧中彈出資料稱為 --- 出棧 pop

生活中的棧：

3.5.2 stack 常用介面

功能描述：棧容器常用的對外介面

建構函式：

stack<T> stk; //stack採用模板類實現， stack物件的預設構造形式
stack(const stack &stk); //拷貝建構函式

賦值操作：

stack& operator=(const stack &stk); //過載等號操作符

資料存取：

push(elem); //向棧頂新增元素
pop(); //從棧頂移除第一個元素
top(); //返回棧頂元素

大小操作：

empty(); //判斷堆疊是否為空
size(); //返回棧的大小

示例：

#include <stack>

//棧容器常用介面
void test01()
{
	//建立棧容器 棧容器必須符合先進後出
	stack<int> s;

	//向棧中新增元素，叫做 壓棧 入棧
	s.push(10);
	s.push(20);
	s.push(30);

	while (!s.empty()) {
		//輸出棧頂元素
		cout << "棧頂元素為： " << s.top() << endl;
		//彈出棧頂元素
		s.pop();
	}
	cout << "棧的大小為：" << s.size() << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

入棧 --- push
出棧 --- pop
返回棧頂 --- top
判斷棧是否為空 --- empty
返回棧大小 --- size

3.6 queue 容器

3.6.1 queue 基本概念

概念：Queue是一種先進先出(First In First Out,FIFO)的資料結構，它有兩個出口

佇列容器允許從一端新增元素，從另一端移除元素

佇列中只有隊頭和隊尾才可以被外界使用，因此佇列不允許有遍歷行為

佇列中進資料稱為 --- 入隊 push

佇列中出資料稱為 --- 出隊 pop

生活中的佇列：

3.6.2 queue 常用介面

功能描述：棧容器常用的對外介面

建構函式：

queue<T> que; //queue採用模板類實現，queue物件的預設構造形式
queue(const queue &que); //拷貝建構函式

賦值操作：

queue& operator=(const queue &que); //過載等號操作符

資料存取：

push(elem); //往隊尾新增元素
pop(); //從隊頭移除第一個元素
back(); //返回最後一個元素
front(); //返回第一個元素

大小操作：

empty(); //判斷堆疊是否為空
size(); //返回棧的大小

示例：

#include <queue>
#include <string>
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void test01() {

	//建立佇列
	queue<Person> q;

	//準備資料
	Person p1("唐僧", 30);
	Person p2("孫悟空", 1000);
	Person p3("豬八戒", 900);
	Person p4("沙僧", 800);

	//向佇列中新增元素  入隊操作
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	//佇列不提供迭代器，更不支援隨機訪問	
	while (!q.empty()) {
		//輸出隊頭元素
		cout << "隊頭元素-- 姓名： " << q.front().m_Name 
              << " 年齡： "<< q.front().m_Age << endl;
        
		cout << "隊尾元素-- 姓名： " << q.back().m_Name  
              << " 年齡： " << q.back().m_Age << endl;
        
		cout << endl;
		//彈出隊頭元素
		q.pop();
	}

	cout << "佇列大小為：" << q.size() << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

入隊 --- push
出隊 --- pop
返回隊頭元素 --- front
返回隊尾元素 --- back
判斷隊是否為空 --- empty
返回佇列大小 --- size

3.7 list容器

3.7.1 list基本概念

功能：將資料進行鏈式儲存

連結串列（list）是一種物理儲存單元上非連續的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結實現的

連結串列的組成：連結串列由一系列結點組成

結點的組成：一個是儲存資料元素的資料域，另一個是儲存下一個結點地址的指標域

STL中的連結串列是一個雙向迴圈連結串列

由於連結串列的儲存方式並不是連續的記憶體空間，因此連結串列list中的迭代器只支援前移和後移，屬於雙向迭代器

list的優點：

採用動態儲存分配，不會造成記憶體浪費和溢位
連結串列執行插入和刪除操作十分方便，修改指標即可，不需要移動大量元素

list的缺點：

連結串列靈活，但是空間(指標域) 和時間（遍歷）額外耗費較大

List有一個重要的性質，插入操作和刪除操作都不會造成原有list迭代器的失效，這在vector是不成立的。

總結：STL中List和vector是兩個最常被使用的容器，各有優缺點

3.7.2 list建構函式

功能描述：

建立list容器

函式原型：

list<T> lst; //list採用採用模板類實現,物件的預設構造形式：
list(beg,end); //建構函式將[beg, end)區間中的元素拷貝給本身。
list(n,elem); //建構函式將n個elem拷貝給本身。
list(const list &lst); //拷貝建構函式。

示例：

#include <list>

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	list<int>L2(L1.begin(),L1.end());
	printList(L2);

	list<int>L3(L2);
	printList(L3);

	list<int>L4(10, 1000);
	printList(L4);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：list構造方式同其他幾個STL常用容器，熟練掌握即可

3.7.3 list 賦值和交換

功能描述：

給list容器進行賦值，以及交換list容器

函式原型：

assign(beg, end); //將[beg, end)區間中的資料拷貝賦值給本身。
assign(n, elem); //將n個elem拷貝賦值給本身。
list& operator=(const list &lst); //過載等號操作符
swap(lst); //將lst與本身的元素互換。

示例：

#include <list>

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//賦值和交換
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);

	//賦值
	list<int>L2;
	L2 = L1;
	printList(L2);

	list<int>L3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);

	list<int>L4;
	L4.assign(10, 100);
	printList(L4);

}

//交換
void test02()
{

	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	list<int>L2;
	L2.assign(10, 100);

	cout << "交換前： " << endl;
	printList(L1);
	printList(L2);

	cout << endl;

	L1.swap(L2);

	cout << "交換後： " << endl;
	printList(L1);
	printList(L2);

}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

總結：list賦值和交換操作能夠靈活運用即可

3.7.4 list 大小操作

功能描述：

對list容器的大小進行操作

函式原型：

size(); //返回容器中元素的個數
empty(); //判斷容器是否為空
resize(num); //重新指定容器的長度為num，若容器變長，則以預設值填充新位置。

//如果容器變短，則末尾超出容器長度的元素被刪除。
resize(num, elem); //重新指定容器的長度為num，若容器變長，則以elem值填充新位置。
```
  					    //如果容器變短，則末尾超出容器長度的元素被刪除。
```

示例：

#include <list>

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//大小操作
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	if (L1.empty())
	{
		cout << "L1為空" << endl;
	}
	else
	{
		cout << "L1不為空" << endl;
		cout << "L1的大小為： " << L1.size() << endl;
	}

	//重新指定大小
	L1.resize(10);
	printList(L1);

	L1.resize(2);
	printList(L1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

判斷是否為空 --- empty
返回元素個數 --- size
重新指定個數 --- resize

3.7.5 list 插入和刪除

功能描述：

對list容器進行資料的插入和刪除

函式原型：

push_back(elem);//在容器尾部加入一個元素
pop_back();//刪除容器中最後一個元素
push_front(elem);//在容器開頭插入一個元素
pop_front();//從容器開頭移除第一個元素
insert(pos,elem);//在pos位置插elem元素的拷貝，返回新資料的位置。
insert(pos,n,elem);//在pos位置插入n個elem資料，無返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)區間的資料，無返回值。
clear();//移除容器的所有資料
erase(beg,end);//刪除[beg,end)區間的資料，返回下一個資料的位置。
erase(pos);//刪除pos位置的資料，返回下一個資料的位置。
remove(elem);//刪除容器中所有與elem值匹配的元素。

示例：

#include <list>

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//插入和刪除
void test01()
{
	list<int> L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	//頭插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);

	printList(L);

	//尾刪
	L.pop_back();
	printList(L);

	//頭刪
	L.pop_front();
	printList(L);

	//插入
	list<int>::iterator it = L.begin();
	L.insert(++it, 1000);
	printList(L);

	//刪除
	it = L.begin();
	L.erase(++it);
	printList(L);

	//移除所有匹配的元素
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	printList(L);
	L.remove(10000);
	printList(L);
    
    //清空
	L.clear();
	printList(L);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

尾插 --- push_back
尾刪 --- pop_back
頭插 --- push_front
頭刪 --- pop_front
插入 --- insert
刪除 --- erase
移除 --- remove
清空 --- clear

3.7.6 list 資料存取

功能描述：

對list容器中資料進行存取

函式原型：

front(); //返回第一個元素。
back(); //返回最後一個元素。

示例：

#include <list>

//資料存取
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	
	//cout << L1.at(0) << endl;//錯誤 不支援at訪問資料
	//cout << L1[0] << endl; //錯誤  不支援[]方式訪問資料
	cout << "第一個元素為： " << L1.front() << endl;
	cout << "最後一個元素為： " << L1.back() << endl;

	//list容器的迭代器是雙向迭代器，不支援隨機訪問
	list<int>::iterator it = L1.begin();
    it++; //支援雙向
	it--;
	//it = it + 2 ;//錯誤，不可以跳躍訪問，即使是+1
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

list容器中不可以通過[]或者at方式訪問資料
返回第一個元素 --- front
返回最後一個元素 --- back

3.7.7 list 反轉和排序

功能描述：

將容器中的元素反轉，以及將容器中的資料進行排序

函式原型：

reverse(); //反轉連結串列
sort(); //連結串列排序

示例：

void printList(const list<int>& L) {

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

bool myCompare(int val1 , int val2)
{
	return val1 > val2;
}

//反轉和排序
void test01()
{
	list<int> L;
	L.push_back(90);
	L.push_back(30);
	L.push_back(20);
	L.push_back(70);
    cout << "反轉前： " << endl;
	printList(L);

	//反轉容器的元素
	L.reverse();
    cout << "反轉後： " << endl;
	printList(L);

	//排序
	L.sort(); //預設的排序規則 從小到大
    cout << "排序後： " << endl;
	printList(L);

	L.sort(myCompare); //指定規則，從大到小
	printList(L);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

反轉 --- reverse
排序 --- sort （成員函式）

3.7.8 排序案例

案例描述：將Person自定義資料型別進行排序，Person中屬性有姓名、年齡、身高

排序規則：按照年齡進行升序，如果年齡相同按照身高進行降序

示例：

#include <list>
#include <string>
class Person {
public:
	Person(string name, int age , int height) {
		m_Name = name;
		m_Age = age;
		m_Height = height;
	}

public:
	string m_Name;  //姓名
	int m_Age;      //年齡
	int m_Height;   //身高
};


bool ComparePerson(Person& p1, Person& p2) {

	if (p1.m_Age == p2.m_Age) {
        //身高降序
		return p1.m_Height  > p2.m_Height;
	}
	else
	{
        //年齡增序
		return  p1.m_Age < p2.m_Age;
	}

}

void test01() {

	list<Person> L;

	Person p1("劉備", 35 , 175);
	Person p2("曹操", 45 , 180);
	Person p3("孫權", 40 , 170);
	Person p4("趙雲", 25 , 190);
	Person p5("張飛", 35 , 160);
	Person p6("關羽", 35 , 200);

	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名： " << it->m_Name << " 年齡： " << it->m_Age 
              << " 身高： " << it->m_Height << endl;
	}

	cout << "---------------------------------" << endl;
	L.sort(ComparePerson); //排序

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名： " << it->m_Name << " 年齡： " << it->m_Age 
              << " 身高： " << it->m_Height << endl;
	}
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

對於自定義資料型別，必須要指定排序規則，否則編譯器不知道如何進行排序
高階排序只是在排序規則上再進行一次邏輯規則制定，並不複雜

3.8 set/ multiset 容器

3.8.1 set基本概念

簡介：

所有元素都會在插入時自動被排序

本質：

set/multiset屬於關聯式容器，底層結構是用二叉樹實現。

set和multiset區別：

set不允許容器中有重複的元素
multiset允許容器中有重複的元素

3.8.2 set構造和賦值

功能描述：建立set容器以及賦值

構造：

set<T> st; //預設建構函式：
set(const set &st); //拷貝建構函式

賦值：

set& operator=(const set &st); //過載等號操作符

插入元素：

insert(element)

示例：

#include <set>

void printSet(set<int> & s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//構造和賦值
void test01()
{
	set<int> s1;

    //插入資料 只有insert方式
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
    
    //遍歷容器
	//set容器特點：所有元素插入時候自動被排序
	//set容器不允許插入重複值
	printSet(s1);

	//拷貝構造
	set<int>s2(s1);
	printSet(s2);

	//賦值
	set<int>s3;
	s3 = s2;
	printSet(s3);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

set容器插入資料時用insert
set容器插入資料的資料會自動排序

3.8.3 set大小和交換

功能描述：

統計set容器大小以及交換set容器

函式原型：

size(); //返回容器中元素的數目
empty(); //判斷容器是否為空
swap(st); //交換兩個集合容器

示例：

#include <set>

void printSet(set<int> & s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//大小
void test01()
{

	set<int> s1;
	
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	if (s1.empty())
	{
		cout << "s1為空" << endl;
	}
	else
	{
		cout << "s1不為空" << endl;
		cout << "s1的大小為： " << s1.size() << endl;
	}

}

//交換
void test02()
{
	set<int> s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	set<int> s2;

	s2.insert(100);
	s2.insert(300);
	s2.insert(200);
	s2.insert(400);

	cout << "交換前" << endl;
	printSet(s1);
	printSet(s2);
	cout << endl;

	cout << "交換後" << endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

總結：

統計大小 --- size
判斷是否為空 --- empty
交換容器 --- swap

3.8.4 set插入和刪除

功能描述：

set容器進行插入資料和刪除資料

函式原型：

insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //刪除pos迭代器所指的元素，返回下一個元素的迭代器。
erase(beg, end); //刪除區間[beg,end)的所有元素，返回下一個元素的迭代器。
erase(elem); //刪除容器中值為elem的元素。

示例：

#include <set>

void printSet(set<int> & s)
{
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//插入和刪除
void test01()
{
	set<int> s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	printSet(s1);

	//刪除
	s1.erase(s1.begin());
	printSet(s1);

	s1.erase(30);
	printSet(s1);

	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printSet(s1);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

插入 --- insert
刪除 --- erase
清空 --- clear

3.8.5 set查詢和統計

功能描述：

對set容器進行查詢資料以及統計資料

函式原型：

find(key); //查詢key是否存在,若存在，返回該鍵的元素的迭代器；若不存在，返回set.end();
count(key); //統計key的元素個數

示例：

#include <set>

//查詢和統計
void test01()
{
	set<int> s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	
	//查詢
	set<int>::iterator pos = s1.find(30);

	if (pos != s1.end())
	{
		cout << "找到了元素 ： " << *pos << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	//統計
	int num = s1.count(30);
	cout << "num = " << num << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

查詢 --- find （返回的是迭代器）
統計 --- count （對於set，結果為0或者1）

3.8.6 set和multiset區別

學習目標：

掌握set和multiset的區別

區別：

set不可以插入重複資料，而multiset可以
set插入資料的同時會返回插入結果，表示插入是否成功
multiset不會檢測資料，因此可以插入重複資料

示例：

#include <set>

//set和multiset區別
void test01()
{
	set<int> s;
	pair<set<int>::iterator, bool>  ret = s.insert(10);
	if (ret.second) {
		cout << "第一次插入成功!" << endl;
	}
	else {
		cout << "第一次插入失敗!" << endl;
	}

	ret = s.insert(10);
	if (ret.second) {
		cout << "第二次插入成功!" << endl;
	}
	else {
		cout << "第二次插入失敗!" << endl;
	}
    
	//multiset
	multiset<int> ms;
	ms.insert(10);
	ms.insert(10);

	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

如果不允許插入重複資料可以利用set
如果需要插入重複資料利用multiset

3.8.7 pair對組建立

功能描述：

成對出現的資料，利用對組可以返回兩個資料

兩種建立方式：

pair<type, type> p ( value1, value2 );
pair<type, type> p = make_pair( value1, value2 );

示例：

#include <string>

//對組建立
void test01()
{
	pair<string, int> p(string("Tom"), 20);
	cout << "姓名： " <<  p.first << " 年齡： " << p.second << endl;

	pair<string, int> p2 = make_pair("Jerry", 10);
	cout << "姓名： " << p2.first << " 年齡： " << p2.second << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

兩種方式都可以建立對組，記住一種即可

3.8.8 set容器排序

學習目標：

set容器預設排序規則為從小到大，掌握如何改變排序規則

主要技術點：

利用仿函式，可以改變排序規則

示例一 set存放內建資料型別

#include <set>

class MyCompare 
{
public:
	bool operator()(int v1, int v2) const
    {
		return v1 > v2;
	}
};
void test01() 
{    
	set<int> s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(30);
	s1.insert(50);

	//預設從小到大
	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

	//指定排序規則
	set<int,MyCompare> s2;
	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(30);
	s2.insert(50);

	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：利用仿函式可以指定set容器的排序規則

示例二 set存放自定義資料型別

#include <set>
#include <string>

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;

};
class comparePerson
{
public:
	bool operator()(const Person& p1, const Person &p2) const
	{
		//按照年齡進行排序  降序
		return p1.m_Age > p2.m_Age;
	}
};

void test01()
{
    //自定義資料型別排序
	set<Person, comparePerson> s;

	Person p1("劉備", 23);
	Person p2("關羽", 27);
	Person p3("張飛", 25);
	Person p4("趙雲", 21);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << "姓名： " << it->m_Name << " 年齡： " << it->m_Age << endl;
	}
}
int main() {

	test01();

	system("pause");

	return 0;
}

總結：

對於自定義資料型別，set必須指定排序規則才可以插入資料

3.9 map/ multimap容器

3.9.1 map基本概念

簡介：

map中所有元素都是pair
pair中第一個元素為key（鍵值），起到索引作用，第二個元素為value（實值）
所有元素都會根據元素的鍵值自動排序

本質：

map/multimap屬於關聯式容器，底層結構是用二叉樹實現。

優點：

可以根據key值快速找到value值

map和multimap區別：

map不允許容器中有重複key值元素
multimap允許容器中有重複key值元素

3.9.2 map構造和賦值

功能描述：

對map容器進行構造和賦值操作

函式原型：

構造：

map<T1, T2> mp; //map預設建構函式:
map(const map &mp); //拷貝建構函式

賦值：

map& operator=(const map &mp); //過載等號操作符

示例：

#include <map>

void printMap(map<int,int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int,int>m; //預設構造
	m.insert(pair<int, int>(1, 10));//對組
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	printMap(m);

	map<int, int>m2(m); //拷貝構造
	printMap(m2);

	map<int, int>m3;
	m3 = m2; //賦值
	printMap(m3);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：map中所有元素都是成對出現，插入資料時候要使用對組

3.9.3 map大小和交換

功能描述：

統計map容器大小以及交換map容器

函式原型：

size(); //返回容器中元素的數目
empty(); //判斷容器是否為空
swap(st); //交換兩個集合容器

示例：

#include <map>

void printMap(map<int,int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	if (m.empty())
	{
		cout << "m為空" << endl;
	}
	else
	{
		cout << "m不為空" << endl;
		cout << "m的大小為： " << m.size() << endl;
	}
}


//交換
void test02()
{
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	map<int, int>m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));

	cout << "交換前" << endl;
	printMap(m);
	printMap(m2);

	cout << "交換後" << endl;
	m.swap(m2);
	printMap(m);
	printMap(m2);
}

int main() {

	test01();

	test02();

	system("pause");

	return 0;
}

總結：

統計大小 --- size
判斷是否為空 --- empty
交換容器 --- swap

3.9.4 map插入和刪除

功能描述：

map容器進行插入資料和刪除資料

函式原型：

insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //刪除pos迭代器所指的元素，返回下一個元素的迭代器。
erase(beg, end); //刪除區間[beg,end)的所有元素，返回下一個元素的迭代器。
erase(key); //刪除容器中值為key的元素。

示例：

#include <map>

void printMap(map<int,int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	//插入
	map<int, int> m;
	//第一種插入方式
	m.insert(pair<int, int>(1, 10));
	//第二種插入方式
	m.insert(make_pair(2, 20));
	//第三種插入方式
	m.insert(map<int, int>::value_type(3, 30));
	//第四種插入方式
	m[4] = 40; 
	printMap(m);

	//刪除
	m.erase(m.begin());
	printMap(m);

	m.erase(3);
	printMap(m);

	//清空
	m.erase(m.begin(),m.end());
	m.clear();
	printMap(m);
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

map插入方式很多，記住其一即可

插入 --- insert
刪除 --- erase
清空 --- clear

3.9.5 map查詢和統計

功能描述：

對map容器進行查詢資料以及統計資料

函式原型：

find(key); //查詢key是否存在,若存在，返回該鍵的元素的迭代器；若不存在，返回set.end();
count(key); //統計key的元素個數

示例：

#include <map>

//查詢和統計
void test01()
{
	map<int, int>m; 
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	//查詢
	map<int, int>::iterator pos = m.find(3);

	if (pos != m.end())
	{
		cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	//統計
    //map不允許插入重複key 元素 ，count統計而言 結果要麼是0 要麼是1
	//multimap的count統計可能大於1
	int num = m.count(3);
	cout << "num = " << num << endl;
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：

查詢 --- find （返回的是迭代器）
統計 --- count （對於map，結果為0或者1）

3.9.6 map容器排序

學習目標：

map容器預設排序規則為按照key值進行從小到大排序，掌握如何改變排序規則

主要技術點:

利用仿函式，可以改變排序規則

示例：

#include <map>

class MyCompare {
public:
	bool operator()(int v1, int v2) const
    {
		return v1 > v2;
	}
};

void test01() 
{
	//預設從小到大排序
	//利用仿函式實現從大到小排序
	map<int, int, MyCompare> m;

	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

	for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {
		cout << "key:" << it->first << " value:" << it->second << endl;
	}
}
int main() {

	test01();

	system("pause");
	return 0;
}

總結：

利用仿函式可以指定map容器的排序規則
對於自定義資料型別，map必須要指定排序規則,同set容器

3.10 案例-員工分組

3.10.1 案例描述

公司今天招聘了10個員工（ABCDEFGHIJ），10名員工進入公司之後，需要指派員工在那個部門工作
員工資訊有: 姓名工資組成；部門分為：策劃、美術、研發
隨機給10名員工分配部門和工資
通過multimap進行資訊的插入 key(部門編號) value(員工)
分部門顯示員工資訊

3.10.2 實現步驟

建立10名員工，放到vector中
遍歷vector容器，取出每個員工，進行隨機分組
分組後，將員工部門編號作為key，具體員工作為value，放入到multimap容器中
分部門顯示員工資訊

案例程式碼：

#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include <map>
#include <ctime>

/*
- 公司今天招聘了10個員工（ABCDEFGHIJ），10名員工進入公司之後，需要指派員工在那個部門工作
- 員工資訊有: 姓名  工資組成；部門分為：策劃、美術、研發
- 隨機給10名員工分配部門和工資
- 通過multimap進行資訊的插入  key(部門編號) value(員工)
- 分部門顯示員工資訊
*/

//部分定義
#define CEHUA  0
#define MEISHU 1
#define YANFA  2

class Worker
{
public:
	string m_Name;
	int m_Salary;
};

void createWorker(vector<Worker>&v)
{
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++)
	{
		Worker worker;
		worker.m_Name = "員工";
		worker.m_Name += nameSeed[i];

		worker.m_Salary = rand() % 10000 + 10000; // 10000 ~ 19999
		//將員工放入到容器中
		v.push_back(worker);
	}
}

//員工分組
void setGroup(vector<Worker>&v,multimap<int,Worker>&m)
{
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
	{
		//產生隨機部門編號
		int deptId = rand() % 3; // 0 1 2 

		//將員工插入到分組中
		//key部門編號，value具體員工
		m.insert(make_pair(deptId, *it));
	}
}

void showWorkerByGourp(multimap<int,Worker>&m)
{
	// 0  A  B  C   1  D  E   2  F G ...
	cout << "策劃部門：" << endl;

	multimap<int,Worker>::iterator pos = m.find(CEHUA);//策劃部門的第一個員工在multimap位置
	int count = m.count(CEHUA); // 統計具體人數
	int index = 0;
	for (; pos != m.end() && index < count; pos++ , index++)
	{
		cout << "姓名： " << pos->second.m_Name << " 工資： " << pos->second.m_Salary << endl;
	}

	cout << "----------------------" << endl;
	cout << "美術部門： " << endl;
	pos = m.find(MEISHU);
	count = m.count(MEISHU); // 統計具體人數
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名： " << pos->second.m_Name << " 工資： " << pos->second.m_Salary << endl;
	}

	cout << "----------------------" << endl;
	cout << "研發部門： " << endl;
	pos = m.find(YANFA);
	count = m.count(YANFA); // 統計具體人數
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名： " << pos->second.m_Name << " 工資： " << pos->second.m_Salary << endl;
	}

}

int main() {

	srand((unsigned int)time(NULL));

	//1、建立員工
	vector<Worker>vWorker;
	createWorker(vWorker);

	//2、員工分組
	multimap<int, Worker>mWorker;
	setGroup(vWorker, mWorker);


	//3、分組顯示員工
	showWorkerByGourp(mWorker);

	////測試
	//for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++)
	//{
	//	cout << "姓名： " << it->m_Name << " 工資： " << it->m_Salary << endl;
	//}

	system("pause");

	return 0;
}

總結：

當資料以鍵值對形式存在，可以考慮用map 或 multimap

4 STL- 函式物件

4.1 函式物件

4.1.1 函式物件概念

概念：

過載函式呼叫操作符的類，其物件常稱為函式物件
函式物件使用過載的()時，行為類似函式呼叫，也叫仿函式

本質：

函式物件(仿函式)是一個類，不是一個函式；

4.1.2 函式物件使用

特點：

函式物件在使用時，可以像普通函式那樣呼叫, 可以有引數，可以有返回值
函式物件超出普通函式的概念，函式物件可以有自己的狀態
函式物件可以作為引數傳遞

示例:

#include <string>

//1、函式物件在使用時，可以像普通函式那樣呼叫, 可以有引數，可以有返回值
class MyAdd
{
public :
	int operator()(int v1,int v2)
	{
		return v1 + v2;
	}
};

void test01()
{
	MyAdd myAdd;
	cout << myAdd(10, 10) << endl;
}

//2、函式物件可以有自己的狀態
class MyPrint
{
public:
	MyPrint()
	{
		count = 0;
	}
	void operator()(string test)
	{
		cout << test << endl;
		count++; //統計使用次數
	}

	int count; //內部自己的狀態
};
void test02()
{
	MyPrint myPrint;
	myPrint("hello world");
	myPrint("hello world");
	myPrint("hello world");
	cout << "myPrint呼叫次數為： " << myPrint.count << endl;
}

//3、函式物件可以作為引數傳遞
void doPrint(MyPrint &mp , string test)
{
	mp(test);
}

void test03()
{
	MyPrint myPrint;
	doPrint(myPrint, "Hello C++");
}

int main() {

	//test01();
	//test02();
	test03();

	system("pause");

	return 0;
}

總結：

仿函式寫法非常靈活，可以作為引數進行傳遞。

4.2 謂詞

4.2.1 謂詞概念

概念：

返回bool型別的仿函式稱為謂詞
如果operator()接受一個引數，那麼叫做一元謂詞
如果operator()接受兩個引數，那麼叫做二元謂詞

4.2.2 一元謂詞

示例：

#include <vector>
#include <algorithm>

//1.一元謂詞
//class GreaterFive
struct GreaterFive{
	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 << "找到:" << *it << endl;
	}

}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：引數只有一個的謂詞，稱為一元謂詞

4.2.3 二元謂詞

示例：

#include <vector>
#include <algorithm>
//二元謂詞
class MyCompare
{
public:
	bool operator()(int num1, int num2)
	{
		return num1 > num2;
	}
};

void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);

	//預設從小到大
	sort(v.begin(), v.end());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	cout << "----------------------------" << endl;

	//使用函式物件改變演算法策略，排序從大到小
	sort(v.begin(), v.end(), MyCompare());//像普通函式一樣呼叫
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：引數只有兩個的謂詞，稱為二元謂詞

4.3 內建函式物件

4.3.1 內建函式物件意義

概念：

STL內建了一些函式物件

分類:

算術仿函式
關係仿函式
邏輯仿函式

用法：

這些仿函式所產生的物件，用法和一般函式完全相同
使用內建函式物件，需要引入標頭檔案 #include<functional>

4.3.2 算術仿函式

功能描述：

實現四則運算
其中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> //取反仿函式

示例：

#include <functional>
//negate
void test01()
{
	negate<int> n;
	cout << n(50) << endl;
}

//plus
void test02()
{
	plus<int> p;
	cout << p(10, 20) << endl;
}

int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

總結：使用內建函式物件時，需要引入標頭檔案 #include <functional>

4.3.3 關係仿函式

功能描述：

實現關係對比

仿函式原型：

template<class T> bool equal_to<T> //等於
template<class T> bool not_equal_to<T> //不等於
template<class T> bool greater<T> //大於
template<class T> bool greater_equal<T> //大於等於
template<class T> bool less<T> //小於
template<class T> bool less_equal<T> //小於等於

示例：

#include <functional>
#include <vector>
#include <algorithm>

class MyCompare
{
public:
	bool operator()(int v1,int v2)
	{
		return v1 > v2;
	}
};
void test01()
{
	vector<int> v;

	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(40);
	v.push_back(20);

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

	//自己實現仿函式
	//sort(v.begin(), v.end(), MyCompare());
	//STL內建仿函式  大於仿函式
	sort(v.begin(), v.end(), greater<int>());

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：關係仿函式中最常用的就是greater<>大於

4.3.4 邏輯仿函式

功能描述：

實現邏輯運算

函式原型：

template<class T> bool logical_and<T> //邏輯與
template<class T> bool logical_or<T> //邏輯或
template<class T> bool logical_not<T> //邏輯非

示例：

#include <vector>
#include <functional>
#include <algorithm>
void test01()
{
	vector<bool> v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);

	for (vector<bool>::iterator it = v.begin();it!= v.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	//邏輯非  將v容器搬運到v2中，並執行邏輯非運算
	vector<bool> v2;
	v2.resize(v.size());
    //algorithm 庫內建函式
    //交換
	transform(v.begin(), v.end(),  v2.begin(), logical_not<bool>());
	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：邏輯仿函式實際應用較少，瞭解即可

5 STL- 常用演算法

概述:

演算法主要是由標頭檔案<algorithm> <functional> <numeric>組成。
<algorithm>是所有STL標頭檔案中最大的一個，範圍涉及到比較、交換、查詢、遍歷操作、複製、修改等等
<numeric>體積很小，只包括幾個在序列上面進行簡單數學運算的模板函式
<functional>定義了一些模板類,用以宣告函式物件。

5.1 常用遍歷演算法

學習目標：

掌握常用的遍歷演算法

演算法簡介：

for_each //遍歷容器
transform //搬運容器到另一個容器中

5.1.1 for_each

功能描述：

實現遍歷容器

函式原型：

for_each(iterator beg, iterator end, _func);

// 遍歷演算法遍歷容器元素

// beg 開始迭代器

// end 結束迭代器

// _func 函式或者函式物件

示例：

#include <algorithm>
#include <vector>

//普通函式
void print01(int val) 
{
	cout << val << " ";
}
//函式物件
class print02 
{
 public:
	void operator()(int val) 
	{
		cout << val << " ";
	}
};

//for_each演算法基本用法
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;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：for_each在實際開發中是最常用遍歷演算法，需要熟練掌握

5.1.2 transform

功能描述：

搬運容器到另一個容器中

函式原型：

transform(iterator beg1, iterator end1, iterator beg2, _func);

//beg1 源容器開始迭代器

//end1 源容器結束迭代器

//beg2 目標容器開始迭代器

//_func 函式或者函式物件

示例：

#include<vector>
#include<algorithm>

//常用遍歷演算法  搬運 transform

class TransForm
{
public:
	int operator()(int val)
	{
		return val + 100;
	}

};

class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector<int>vTarget; //目標容器

	vTarget.resize(v.size()); // 目標容器需要提前開闢空間

    //+100後，搬運到新的容器
	transform(v.begin(), v.end(), vTarget.begin(), TransForm());

    //輸出
	for_each(vTarget.begin(), vTarget.end(), MyPrint());
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結： 搬運的目標容器必須要提前開闢空間，否則無法正常搬運

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 查詢的元素

示例：

#include <algorithm>
#include <vector>
#include <string>
void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	//查詢容器中是否有 5 這個元素
	vector<int>::iterator it = find(v.begin(), v.end(), 5);
	if (it == v.end()) 
	{
		cout << "沒有找到!" << endl;
	}
	else 
	{
		cout << "找到:" << *it << endl;
	}
}

class Person {
public:
	Person(string name, int age) 
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//過載==
	bool operator==(const Person& p) 
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) 
		{
			return true;
		}
		return false;
	}

public:
	string m_Name;
	int m_Age;
};

void test02() {

	vector<Person> v;

	//建立資料
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator it = find(v.begin(), v.end(), p2);
	if (it == v.end()) 
	{
		cout << "沒有找到!" << endl;
	}
	else 
	{
		cout << "找到姓名:" << it->m_Name << " 年齡: " << it->m_Age << endl;
	}
}

總結：利用find可以在容器中找指定的元素，返回值是迭代器

5.2.2 find_if

功能描述：

按條件查詢元素

函式原型：

find_if(iterator beg, iterator end, _Pred);

// 按值查詢元素，找到返回指定位置迭代器，找不到返回結束迭代器位置

// beg 開始迭代器

// end 結束迭代器

// _Pred 函式或者謂詞（返回bool型別的仿函式）

示例：

#include <algorithm>
#include <vector>
#include <string>

//內建資料型別
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 + 1);
	}

	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) {
		cout << "沒有找到!" << endl;
	}
	else {
		cout << "找到大於5的數字:" << *it << endl;
	}
}

//自定義資料型別
class Person {
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	string m_Name;
	int m_Age;
};

class Greater20
{
public:
	bool operator()(Person &p)
	{
		return p.m_Age > 20;
	}

};

void test02() {

	vector<Person> v;

	//建立資料
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
	if (it == v.end())
	{
		cout << "沒有找到!" << endl;
	}
	else
	{
		cout << "找到姓名:" << it->m_Name << " 年齡: " << it->m_Age << endl;
	}
}

int main() {

	test01();

	test02();

	system("pause");
	return 0;
}

總結：find_if按條件查詢使查詢更加靈活，提供的仿函式可以改變不同的策略

5.2.3 adjacent_find

功能描述：

查詢相鄰重複元素

函式原型：

adjacent_find(iterator beg, iterator end);

// 查詢相鄰重複元素,返回相鄰元素的第一個位置的迭代器

// beg 開始迭代器

// end 結束迭代器

示例：

#include <algorithm>
#include <vector>

void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);
	v.push_back(4);
	v.push_back(3);

	//查詢相鄰重複元素
	vector<int>::iterator it = adjacent_find(v.begin(), v.end());
	if (it == v.end()) {
		cout << "找不到!" << endl;
	}
	else {
		cout << "找到相鄰重複元素為:" << *it << endl;
	}
}

總結：面試題中如果出現查詢相鄰重複元素，記得用STL中的adjacent_find演算法

5.2.4 binary_search

功能描述：

查詢指定元素是否存在

函式原型：

bool binary_search(iterator beg, iterator end, value);

// 查詢指定的元素，查到返回true 否則false

// 注意: 在無序序列中不可用

// beg 開始迭代器

// end 結束迭代器

// value 查詢的元素

示例：

#include <algorithm>
#include <vector>

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//二分查詢
	bool ret = binary_search(v.begin(), v.end(),2);
	if (ret)
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：二分查詢法查詢效率很高，值得注意的是查詢的容器中元素必須的有序序列

5.2.5 count

功能描述：

統計元素個數

函式原型：

count(iterator beg, iterator end, value);

// 統計元素出現次數

// beg 開始迭代器

// end 結束迭代器

// value 統計的元素

示例：

#include <algorithm>
#include <vector>

//內建資料型別
void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(4);
	v.push_back(5);
	v.push_back(3);
	v.push_back(4);
	v.push_back(4);

	int num = count(v.begin(), v.end(), 4);

	cout << "4的個數為： " << num << endl;
}

//自定義資料型別
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	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("劉備", 35);
	Person p2("關羽", 35);
	Person p3("張飛", 35);
	Person p4("趙雲", 30);
	Person p5("曹操", 25);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
    
    Person p("諸葛亮",35);

	int num = count(v.begin(), v.end(), p);
	cout << "num = " << num << endl;
}
int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

總結： 統計自定義資料型別時候，需要配合過載 operator==

5.2.6 count_if

功能描述：

按條件統計元素個數

函式原型：

count_if(iterator beg, iterator end, _Pred);

// 按條件統計元素出現次數

// beg 開始迭代器

// end 結束迭代器

// _Pred 謂詞

示例：

#include <algorithm>
#include <vector>

class Greater4
{
public:
	bool operator()(int val)
	{
		return val >= 4;
	}
};

//內建資料型別
void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(4);
	v.push_back(5);
	v.push_back(3);
	v.push_back(4);
	v.push_back(4);

	int num = count_if(v.begin(), v.end(), Greater4());

	cout << "大於4的個數為： " << num << endl;
}

//自定義資料型別
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

class AgeLess35
{
public:
	bool operator()(const Person &p)
	{
		return p.m_Age < 35;
	}
};
void test02()
{
	vector<Person> v;

	Person p1("劉備", 35);
	Person p2("關羽", 35);
	Person p3("張飛", 35);
	Person p4("趙雲", 30);
	Person p5("曹操", 25);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	int num = count_if(v.begin(), v.end(), AgeLess35());
	cout << "小於35歲的個數：" << num << endl;
}


int main() {

	test01();

	test02();

	system("pause");
	return 0;
}

總結：按值統計用count，按條件統計用count_if

5.3 常用排序演算法

學習目標：

掌握常用的排序演算法

演算法簡介：

sort //對容器內元素進行排序
random_shuffle //洗牌指定範圍內的元素隨機調整次序
merge // 容器元素合併，並儲存到另一容器中
reverse // 反轉指定範圍的元素

5.3.1 sort

功能描述：

對容器內元素進行排序

函式原型：

sort(iterator beg, iterator end, _Pred);

// 按值查詢元素，找到返回指定位置迭代器，找不到返回結束迭代器位置

// beg 開始迭代器

// end 結束迭代器

// _Pred 謂詞

示例：

#include <algorithm>
#include <vector>

void myPrint(int val)
{
	cout << val << " ";
}

void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);

	//sort預設從小到大排序
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;

	//從大到小排序
	sort(v.begin(), v.end(), greater<int>());//內建函式
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}

int main() {

	test01();
	system("pause");

	return 0;
}

總結：sort屬於開發中最常用的演算法之一，需熟練掌握

5.3.2 random_shuffle

功能描述：

洗牌指定範圍內的元素隨機調整次序

函式原型：

random_shuffle(iterator beg, iterator end);

// 指定範圍內的元素隨機調整次序

// beg 開始迭代器

// end 結束迭代器

示例：

#include <algorithm>
#include <vector>
#include <ctime>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
    //新增隨機數的種子
	srand((unsigned int)time(NULL));
	vector<int> v;
	for(int i = 0 ; i < 10;i++)
	{
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//打亂順序,洗牌演算法
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：random_shuffle洗牌演算法比較實用，使用時記得加隨機數種子

5.3.3 merge

功能描述：

兩個容器元素合併，並儲存到另一容器中

函式原型：

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 容器元素合併，並儲存到另一容器中

// 注意: 兩個容器必須是有序的

// beg1 容器1開始迭代器
// end1 容器1結束迭代器
// beg2 容器2開始迭代器
// end2 容器2結束迭代器
// dest 目標容器開始迭代器

示例：

#include <algorithm>
#include <vector>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10 ; i++) 
    {
		v1.push_back(i);
		v2.push_back(i + 1);
	}

	vector<int> vtarget;
	//目標容器需要提前開闢空間
	vtarget.resize(v1.size() + v2.size());
	//合併  需要兩個有序序列
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
	for_each(vtarget.begin(), vtarget.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：merge合併的兩個容器必須的有序序列，Merge前先進行排序

5.3.4 reverse

功能描述：

將容器內元素進行反轉

函式原型：

reverse(iterator beg, iterator end);

// 反轉指定範圍的元素

// beg 開始迭代器

// end 結束迭代器

示例：

#include <algorithm>
#include <vector>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);

	cout << "反轉前： " << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	cout << "反轉後： " << endl;

	reverse(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");
	return 0;
}

總結：reverse反轉區間內元素，面試題可能涉及到

5.4 常用拷貝和替換演算法

學習目標：

掌握常用的拷貝和替換演算法

演算法簡介：

copy // 容器內指定範圍的元素拷貝到另一容器中
replace // 將容器內指定範圍的舊元素修改為新元素
replace_if // 容器內指定範圍滿足條件的元素替換為新元素
swap // 互換兩個容器的元素

5.4.1 copy

功能描述：

容器內指定範圍的元素拷貝到另一容器中

函式原型：

copy(iterator beg, iterator end, iterator dest);

// 按值查詢元素，找到返回指定位置迭代器，找不到返回結束迭代器位置

// beg 開始迭代器

// end 結束迭代器

// dest 目標起始迭代器

示例：

#include <algorithm>
#include <vector>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i + 1);
	}
	vector<int> v2;
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());

	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：利用copy演算法在拷貝時，目標容器記得提前開闢空間

5.4.2 replace

功能描述：

將容器內指定範圍的舊元素修改為新元素

函式原型：

replace(iterator beg, iterator end, oldvalue, newvalue);

// 將區間內舊元素替換成新元素

// beg 開始迭代器

// end 結束迭代器

// oldvalue 舊元素

// newvalue 新元素

示例：

#include <algorithm>
#include <vector>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(50);
	v.push_back(10);
	v.push_back(20);

	cout << "替換前：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//將容器中的20 替換成 2000
	cout << "替換後：" << endl;
	replace(v.begin(), v.end(), 20,2000);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：replace會替換區間內滿足條件的元素

5.4.3 replace_if

功能描述:

將區間內滿足條件的元素，替換成指定元素

函式原型：

replace_if(iterator beg, iterator end, _pred, newvalue);

// 按條件替換元素，滿足條件的替換成指定元素

// beg 開始迭代器

// end 結束迭代器

// _pred 謂詞

// newvalue 替換的新元素

示例：

#include <algorithm>
#include <vector>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

class ReplaceGreater30
{
public:
	bool operator()(int val)
	{
		return val >= 30;
	}

};

void test01()
{
	vector<int> v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(50);
	v.push_back(10);
	v.push_back(20);

	cout << "替換前：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//將容器中大於等於的30 替換成 3000
	cout << "替換後：" << endl;
	replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：replace_if按條件查詢，可以利用仿函式靈活篩選滿足的條件

5.4.4 swap

功能描述：

互換兩個容器的元素

函式原型：

swap(container c1, container c2);

// 互換兩個容器的元素

// c1容器1

// c2容器2

示例：

#include <algorithm>
#include <vector>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+100);
	}

	cout << "交換前： " << endl;
	for_each(v1.begin(), v1.end(), myPrint());
	cout << endl;
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;

	cout << "交換後： " << endl;
	swap(v1, v2);
	for_each(v1.begin(), v1.end(), myPrint());
	cout << endl;
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：swap交換容器時，注意交換的容器要同種型別

5.5 常用算術生成演算法

學習目標：

掌握常用的算術生成演算法

注意：

算術生成演算法屬於小型演算法，使用時包含的標頭檔案為 #include <numeric>

演算法簡介：

accumulate // 計算容器元素累計總和
fill // 向容器中新增元素

5.5.1 accumulate

功能描述：

計算區間內容器元素累計總和

函式原型：

accumulate(iterator beg, iterator end, value);

// 計算容器元素累計總和

// beg 開始迭代器

// end 結束迭代器

// value 起始值

示例：

#include <numeric>
#include <vector>
void test01()
{
	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;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：accumulate使用時標頭檔案注意是 numeric，這個演算法很實用

5.5.2 fill

功能描述：

向容器中填充指定的元素

函式原型：

fill(iterator beg, iterator end, value);

// 向容器中填充元素

// beg 開始迭代器

// end 結束迭代器

// value 填充的值

示例：

#include <numeric>
#include <vector>
#include <algorithm>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{

	vector<int> v;
	v.resize(10);
	//填充
	fill(v.begin(), v.end(), 100);

	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：利用fill可以將容器區間內元素填充為指定的值

5.6 常用集合演算法

學習目標：

掌握常用的集合演算法

演算法簡介：

set_intersection // 求兩個容器的交集
set_union // 求兩個容器的並集
set_difference // 求兩個容器的差集

5.6.1 set_intersection

功能描述：

求兩個容器的交集

函式原型：

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求兩個集合的交集

// 注意:兩個集合必須是有序序列

// beg1 容器1開始迭代器
// end1 容器1結束迭代器
// beg2 容器2開始迭代器
// end2 容器2結束迭代器
// dest 目標容器開始迭代器

示例：

#include <vector>
#include <algorithm>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++)
    {
		v1.push_back(i);
		v2.push_back(i+5);
	}

	vector<int> vTarget;
	//取兩個裡面較小的值給目標容器開闢空間
	vTarget.resize(min(v1.size(), v2.size()));

	//返回目標容器的最後一個元素的迭代器地址
	vector<int>::iterator itEnd = 
        set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

求交集的兩個集合必須的有序序列
目標容器開闢空間需要從兩個容器中取小值
set_intersection返回值既是交集中最後一個元素的位置

5.6.2 set_union

功能描述：

求兩個集合的並集

函式原型：

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求兩個集合的並集

// 注意:兩個集合必須是有序序列

// beg1 容器1開始迭代器
// end1 容器1結束迭代器
// beg2 容器2開始迭代器
// end2 容器2結束迭代器
// dest 目標容器開始迭代器

示例：

#include <vector>
#include <algorithm>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+5);
	}

	vector<int> vTarget;
	//取兩個容器的和給目標容器開闢空間
	vTarget.resize(v1.size() + v2.size());

	//返回目標容器的最後一個元素的迭代器地址
    //set_union返回值既是並集中最後一個元素的位置
	vector<int>::iterator itEnd = 
        set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

求並集的兩個集合必須的有序序列
目標容器開闢空間需要兩個容器相加
set_union返回值既是並集中最後一個元素的位置

5.6.3 set_difference

功能描述：

求兩個集合的差集

函式原型：

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求兩個集合的差集

// 注意:兩個集合必須是有序序列

// beg1 容器1開始迭代器
// end1 容器1結束迭代器
// beg2 容器2開始迭代器
// end2 容器2結束迭代器
// dest 目標容器開始迭代器

示例：

#include <vector>
#include <algorithm>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i+5);
	}

	vector<int> vTarget;
	//取兩個裡面較大的值給目標容器開闢空間
	vTarget.resize( max(v1.size() , v2.size()));

	//返回目標容器的最後一個元素的迭代器地址
	cout << "v1與v2的差集為： " << endl;
	vector<int>::iterator itEnd = 
        set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;

  //順序不一樣，作差值結果也會不一樣
	cout << "v2與v1的差集為： " << endl;
	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

總結：

求差集的兩個集合必須的有序序列
目標容器開闢空間需要從兩個容器取較大值
set_difference返回值既是差集中最後一個元素的位置

C++ 提高程式設計
2022-02-18
C++程式設計
C++提高程式設計-模板
2024-11-18
C++程式設計
C++提高程式設計-STL
2024-11-23
C++程式設計
C++核心程式設計
2024-08-02
C++程式設計
C++程式設計實現
2020-11-07
C++程式設計
程式設計師如何提高影響力
2020-12-03
程式設計師
程式設計技巧│提高 Javascript 程式碼效率的技巧
2022-06-30
程式設計JavaScript
C++核心程式設計筆記
2020-10-19
C++程式設計筆記
c++簡單程式設計-3
2020-04-04
C++程式設計
QML之C++混合程式設計
2020-12-17
C++程式設計
物件導向程式設計C++
2018-10-27
物件程式設計C++
C++高階程式設計pdf
2018-08-09
C++程式設計
C++ & Intel MKL 混合程式設計
2018-05-10
C++Intel程式設計
Windows 程式設計簡介從C/C++到Windows程式設計
2021-09-09
Windows程式設計C++
C++入門程式設計----C++運算子（8）
2024-03-07
C++程式設計
可以提高程式設計師效率的工具！
2019-04-26
程式設計師
如何提高函數語言程式設計技巧
2018-10-18
函數程式設計
提高程式設計師的幾大利器
2019-01-11
程式設計師
ios程式設計師提高程式設計能力萬無一失的辦法
2018-05-17
iOS程式設計師
提高程式設計能力的關鍵（翻譯）
2023-01-26
程式設計
[譯] 程式設計師該如何提高生產力？
2020-02-15
程式設計師
優秀程式設計師，如何提高架構能力？
2020-10-19
程式設計師架構
我是如何提高自己的「程式設計能力」的？
2020-12-23
程式設計
程式設計提高之路的反思與總結感悟
2018-07-17
程式設計
c++程式設計基礎實驗4
2024-11-24
C++程式設計
C++程式設計基礎實驗1
2024-10-21
C++程式設計
Linux C++ 多執行緒程式設計
2024-08-11
LinuxC++執行緒程式設計
UE4中C++程式設計（一）
2021-11-15
C++程式設計
現代c++與模板超程式設計
2019-08-02
C++程式設計
C++的函數語言程式設計
2020-12-08
C++函數程式設計
C++程式設計基礎（2）變數
2018-06-11
C++程式設計變數
c++ 程式通用多執行緒單例設計 c++ web 框架設計經驗談
2023-02-15
C++執行緒單例Web框架
提高程式設計邏輯的7種方法 - DEV
2021-11-09
程式設計dev
可以提高php程式設計效率的20個要點
2019-02-01
PHP程式設計
Linux C/C++程式設計中的多執行緒程式設計基本概念
2024-12-03
LinuxC++程式設計執行緒
C++日期和時間程式設計總結
2022-12-05
C++程式設計
C++:與C混合程式設計 CMake undefined reference to
2024-06-03
C++程式設計Undefined
P2 C++ 程式設計正規化
2024-05-16
C++程式設計