c++提高部分

news2024/11/18 8:47:26

c++提高部分

这部分主要涉及泛型编程和STL技术

1. 模版

1.1 模版的概念

模版就是通用的模具，大大提高复用性，但需要根据需求改动一些东西

1.2 函数模版

  • c++另一种编程思想为泛型编程，主要利用的技术就是模版
  • c++提供两种模版机制：函数模板和类模板

1.2.1 函数模板语法

函数模板语法
函数模板作用:
建立一个通用的函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法:

template<typename T>
函数声明或定义

解释:
template——声明创建模板

typena me——表明其后面的 符号为一种数据类型，可以用class代替。

T——通用的数据类型，名称可以替换，通常为大写字母。

#include<iostream>
using namespace std;


//函数模板
//两个整型交换
void  SwapInt(int &a, int &b)
{
	int temp = b;
	b = a;
	a = temp;
}
//两个浮点型交换
void SwapDouble(double &a,double & b)
{
	double temp = a;
	a = b;
	b = temp;
}


//函数模板
//声明一个模板,告诉编译器后面的代码中紧跟着的T不要报错，T是一个通用数据类型
template<typename T>
void MySwap(T& a, T& b)
{
	T Temp = a;
	a = b;
	b = Temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	//利用函数模板进行交换
	//1.自动类型推导
	MySwap(a, b);
cout << a  << endl;
cout << b << endl;

double c = 11.1;
double d = 12.2;
//显示指定类型
MySwap<double>(c, d);
cout << c << endl;
cout << d << endl;
}
int main(void)
{
	test01();
	system("pause");
	return 0;
}

总结：

函数模板利用关键字template
使用函数类型模板有两种方式：自动类型推导、显示指定类型
模板的目的是为了提高复用性，将类型参数化函数模板注意事项

1.2.2 函数模板注意事项:
  • 自动类型推导，必须推导出一致的数据类型T才能使用
#include<iostream>
using namespace std;
template<typename T>
void myswap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	char t = 'l';
	//myswap(a, l);     //不一样的数据类型使用模板会报错
	cout << a << endl;
	cout << b << endl;

}

int main()
{
	test01();
	system("pause");
	return 0;
}
  • 模板必须要确定出T的数据类型，才可以使用
#include<iostream>
using namespace std;
template<typename T>
void myswap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

template<typename T>
void func()
{
	cout << "hello！" << endl;
}

void test01()
{
	int a = 10;
	int b = 20;
	char t = 'l';
	cout << a << endl;
	cout << b << endl;

	//func();           //模板必须要确定出T的数据类型，才可以使用
	func<int>();       //或者这样，可以使用

}

int main()
{
	test01();
	system("pause");
	return 0;
}
1.2.3 函数模板案例

案例描述:

  • 利用函数模板封装一个排序的函数，可以对不用数据类型数组进行排序
  • 排序规则从大到小，排序算法为选择排序
  • 分别利用char数组和int数组进行测试
#include<iostream>
using namespace std;

template<class T>
void myswap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

template<class T>
void sort(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int flag = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[flag] < arr[j])
			{
				flag = j;
			}

		}
		if (flag != i)
		{
			myswap(arr[i], arr[flag]);
		}

	}
}

template<class T>
void my_print(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << '\t';
	}
	cout << endl;
}

void test01()
{
	char arr[] = "adecb";
	int num = sizeof(arr) / sizeof(char);
	sort(arr, num);
	my_print(arr, num);


	int n_arr[] = { 2,4,1,6,8,7 };
	int num1 = sizeof(n_arr) / sizeof(int);
	sort(n_arr, num1);
	my_print(n_arr, num1);

}

int main()
{
	test01();
	system("pause");
	return 0;
}
1.2.4 普通函数与函数模板的区别

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

  • 普通函数调用时可以发生自动类型转换(隐式类型推导)
  • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
  • 如果利用显式指定类型的方式，可以发生隐式类型转换
#include<iostream>
using namespace std;
//普通函数与函数模板的区别
//普通函数调用可以发生隐式类型转换
//函数模板用自动类型推导不可以发生隐式类型转换
// 函数模板用显式指定类型 可以发生隐式类型转换

//普通函数隐式类型转换
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;

	//自动类型推导不行
	//cout << myAdd02(a, c) << endl;

	//显式指定类型行
	cout << myAdd02<int>(a, c) << endl;
}


int main(void)
{
	test01();
	system("pause");
	return 0;
}
1.2.5 普通函数与函数模板的调用规则

调用规则如下：

  1. 如果函数模板和普通函数都可以实现，优先调用普通函数
  2. 可以通过空模板参数列表来强制调用函数模板
  3. 函数模板也可以发生重载
  4. 如果函数模板可以产生更好的匹配，优先调用函数模板
#include<iostream>
using namespace std;
void myPrint(int a, int b)
{
	cout << "调用普通函数" << endl;
}
template<class T>
void myPrint(T a, T b)
{
	cout << "调用模板" << endl;
}

template<class T>
void myPrint(T a, T b,T c)
{
	cout << "调用重载模板" << endl;
}
void test01()
{
	int a = 10;
	int b = 20;
	//如果函数模板和普通函数都可以调用。优先调用普通函数。普通函数只有声明会报错
	myPrint(a, b);

	//通过空模板的参数列表强制调用函数模板
	myPrint<>(a,b);

	//调用重载模板
	myPrint(a, b, 100);

	//如果函数模板产生更好的匹配，优先调用函数模板,两个char，普通函数还需要去同时转换为int，还不如直接给模板，直接转为T类型
	char c1 = 'a';
	char c2 = 'b';

	myPrint(c1, c2);
}
int main(void)
{
	test01();
	system("pause");
	return 0;
}
1.2.6 模板的局限性
#include<iostream>
#include<string>
using namespace std;

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


template<class T>
bool compare(T& a, T& b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template <>bool compare(Person& a, Person& b)
{
	if (a.age == b.age && a.name == b.name)
	{
		return true;
	}
	else
	{
		return false;
	}
}
void test01()
{
	Person s1("il", 20);
	Person s2("il", 22);
	bool ret = compare(s1, s2);
	if (ret)
		cout << "s1=s2" << endl;
	else
		cout << "s1!=s2" << endl;
}


int main()
{
	test01();
	system("pause");
	return 0;
}

1.3 类模板

1.3.1 类模板基本语法
#include<iostream>
#include<string>
using namespace std;

template <class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_age = age;
		this->m_name = name;
	}
	NameType m_name;
	AgeType m_age;
	void show()
	{
		cout << this->m_age << endl;
		cout << this->m_name << endl;
	}
};

void test01()
{
    //Person<string, int>里的string和int是给那个Name和AgeType导向的，后面直接跟对象
	Person<string, int>p1("张三", 456);
	p1.show();
}

int main()
{
	test01();
	system("pause");
	return 0;
}
1.3.2 类模板与函数模板的不同
#include<iostream>
#include<string>
using namespace std;


template <class NameType, class AgeType = int>    //类模板可以在这里指定默认参数类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_age = age;
		this->m_name = name;
	}
	NameType m_name;
	AgeType m_age;
	void show()
	{
		cout << this->m_age << endl;
		cout << this->m_name << endl;
	}
};


//void test01()
//{
//	Person<string, int>p1("张三", 456);   //1.类模板必须用这种指定类型的方式赋值
//	p1.show();
//}


void test02()
{
	Person<string>p2("李逵", 26);   //1.类模板必须用这种指定类型的方式赋值
	p2.show();
}

int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}
1.3.3 类模板成员函数创建时机
#include<iostream>
#include<string>
using namespace std;

class Person1
{
public:
	void func1()
	{
		cout << "this is Person1" << endl;
	}
};


class Person2
{
public:
	void func2()
	{
		cout << "this is Person2" << endl;
	}
};

template <class T>
class Person
{
public:
	T obj;
	void show1()
	{
		obj.func1();
	}
	void show2()
	{
		obj.func2();
	}
};


void test02()
{
	Person<Person1>p1;
	p1.show1();
}

int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

类模板中的成员函数并不是一开始就创建的，在调用时才去创建。

1.3.4 类模板对象做函数参数

学习目标:
类模板实例化出的对象，向函数传参的方式

一共有三种传入方式

  1. 指定传入的类型——直接显式对象的数据类型
  2. 参数模板化——将对象中的参数变为模板参数进行传递
  3. 整个类模板化——将这个对象类型，模板化进行传递
#include<iostream>
#include<string>
using namespace std;

template <class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	T1 m_name;
	T2 m_age;

	void showPerson()
	{
		cout << "姓名：" << this->m_name << endl;
		cout << "年龄：" << this->m_age << endl;
	}
};


//1.指定传入类型，一般最常用
void printPerson1(Person<string, int>& p1)
{
	p1.showPerson();
}
void test01()
{
	Person<string, int>p1("孙悟空", 1520);
	printPerson1(p1);
}

//2.参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>& p2)
{
	p2.showPerson();
	cout << typeid(T1).name() << endl;   //查看推测的数据类型
	cout << typeid(T2).name() << endl;
}
void test02()
{
	Person<string, int>p2("杀神", 320);
	printPerson2(p2);
}

//3.整个类模板化
template<class T>
void printPerson3(T& p3)
{
	p3.showPerson();
	cout << typeid(T).name() << endl;   //查看推测的数据类型
}
void test03()
{
	Person<string, int>p3("刀郎", 6820);
	printPerson3(p3);
}


int main()
{
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}
1.3.5 类模板与继承

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

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
  • 如果不想指定，编译器无法给子类分配内存‘
  • 如果想灵活指定出父类中T的类型，子类也需要变为类模板

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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

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

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

};

void test01()
{
	Son s1;
}

//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
	Son2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
	T1 obj;
};
void test02()
{
	Son2<int, char>s2;
}


int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}
1.3.6 类模板成员函数类外实现

能够掌握类模板中的成员函数类外实现

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

template <class T1, class T2>
class Base
{
public:
	Base(T1 name, T2 age);
	void show();
	T1 m_name;
	T2 m_age;
};

template <class T1, class T2>
Base<T1, T2>::Base(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;;
}

template <class T1, class T2>
void Base<T1, T2>::show()
{
	cout << "姓名为：" << this->m_name << endl;
	cout << "年龄为：" << this->m_age << endl;
}

void test01()
{
	Base<string, int> b1("李青", 80);
	b1.show();
}


int main()
{
	test01();
	system("pause");
	return 0;
}
1.3.7 类模板分文件编写

学习目标:

掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

1.类模板分文件编写.cpp文件中只写test01(),和main函数

#include<iostream>
#include"Base.h"

void test01()
{
	Base<string, int> b1("李青", 80);
	b1.show();
}


int main()
{
	test01();
	system("pause");
	return 0;
}

2.创建Base.h头文件

#pragma once
#include<iostream>
#include<string>
using namespace std;
template <class T1, class T2>
class Base
{
public:
	Base(T1 name, T2 age);
	void show();
	T1 m_name;
	T2 m_age;
};

3.创建Base.cpp源文件

#include"Base.h"
template <class T1, class T2>
Base<T1, T2>::Base(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;;
}

template <class T1, class T2>
void Base<T1, T2>::show()
{
	cout << "姓名为：" << this->m_name << endl;
	cout << "年龄为：" << this->m_age << endl;
}

此时编译没问题，但是运行会有问题。运行的时候编译器只是看到了Base.h头文件的文件内容两次，并没有看到实现。

解决：

解决方式1：类模板分文件编写.cpp文件中直接包含Base.cpp源文件

#include<iostream>
#include"Base.cpp"

void test01()
{
	Base<string, int> b1("李青", 80);
	b1.show();
}


int main()
{
	test01();
	system("pause");
	return 0;
}

解决方式2:将声明.h和实现.cpp在到同一个文件中，并更改后缀名为.hpp,hpp是约定俗成的名称，并不是强制

  1. 在头文件部分新建Base.hpp源文件，其中包含Base.h和Base.cpp文件的内容
#pragma once
#include<iostream>
#include<string>
using namespace std;
template <class T1, class T2>
class Base
{
public:
	Base(T1 name, T2 age);
	void show();
	T1 m_name;
	T2 m_age;
};
template <class T1, class T2>
Base<T1, T2>::Base(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;;
}

template <class T1, class T2>
void Base<T1, T2>::show()
{
	cout << "姓名为：" << this->m_name << endl;
	cout << "年龄为：" << this->m_age << endl;
}
  1. 类模板分文件编写.cpp文件中直接包含Base.hpp源文件
#include<iostream>
#include"Base.hpp"
void test01()
{
	Base<string, int> b1("李青", 80);
	b1.show();
}


int main()
{
	test01();
	system("pause");
	return 0;
}
1.3.8 类模板与友元
  1. 类内实现
#include<iostream>
#include<string>
using namespace std;

template <class T1, class T2>
class Perosn
{
	//友元类内实现
	friend void show(Perosn<string, int>p)
	{
		cout << "姓名：" << p.m_name << "，年龄：" << p.m_age << endl;
	}
public:
	Perosn(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
private:
	T1 m_name;
	T2 m_age;
};


void test01()
{

	Perosn<string, int>p1("张三", 45);
	show(p1);
}


int main()
{
	test01();
	system("pause");
	return 0;
}
  1. 类外实现
#include<iostream>
#include<string>
using namespace std;

//提前让编译器知道Person类的存在
template<class T1, class T2 >
class Person;
//类外实现
template<class T1, class T2>
void show_p(Person<T1, T2>p)
{
	cout << "姓名：" << p.m_name << "，年龄：" << p.m_age << endl;
}


template <class T1, class T2>
class Person
{
	//加空模板参数列表
	friend void show_p<>(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;
};


void test01()
{

	Person<string, int>p1("小期待", 154);
	show_p(p1);
}


int main()
{
	test01();
	system("pause");
	return 0;
}

在此例中，全局函数friend void show_p<>(Person<T1, T2>p);这是一个普通函数，得让编译器提前知道全局函数的存在，也需要知道Person是一个模板。

1.3.9 类模板案例

案例描述:

  • 可以对内置数据类型以及自定义数据类型的数据进行存储
  • 将数组中的数据存储到堆区
  • 构造函数中可以传入数组的容量
  • 提供对应的拷贝构造函数以及operator=防止浅拷贝问题
  • 提供尾插法和尾删法对数组中的数据进行增加和删除
  • 可以通过下标的方式访问数组中的元素
  • 可以获取数组汇中当前元素个数和数组的容量
  1. MyArray.hpp文件中编写
#pragma once
#include<iostream>
#include<string>
using namespace std;

template <class T>
class Myarray
{
public:
	//有参构造函数
	Myarray(int capacity)
	{
		cout << "MyArry的有参构造函数调用" << endl;
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}
	//拷贝构造函数
	Myarray(Myarray& m1)
	{
		cout << "MyArry的拷贝构造函数调用" << endl;
		this->m_Capacity = m1.m_Capacity;
		this->m_Size = m1.m_Size;
		//深拷贝
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m1.m_Size; i++)
		{
			this->pAddress[i] = m1.pAddress[i];
		}
	}

	//赋值符重载
	Myarray& operator =(Myarray& arr)
	{

		cout << "MyArry的operator=调用" << endl;

		//先判断原来堆区是否有数据，如果有先释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

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

	~Myarray()
	{
		if (this->pAddress != NULL)
		{
			cout << "析构函数！" << endl;
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

private:
	T* pAddress;//指针指向堆区开辟的真实数组
	int m_Capacity;//数组容量
	int m_Size;//数组大小
};
  1. 类函数模板.cpp文件编写
#include<iostream>
#include"MyArray.hpp"

void test01()
{
	Myarray<int>a1(5);
	Myarray<int>a2(a1);
	Myarray<int>a3(12);
	a3 = a1;

}

int main()
{
	test01();
	system("pause");
	return 0;
}
  1. 在MyArray.hpp文件中继续编写统计大小、统计容量、[]重载（用于显示值）、尾插法、尾删法
#pragma once
#include<iostream>
#include<string>
using namespace std;

template <class T>
class Myarray
{
public:
	//有参构造函数
	Myarray(int capacity)
	{
		//cout << "MyArry的有参构造函数调用" << endl;
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}
	//拷贝构造函数
	Myarray(Myarray& m1)
	{
		//cout << "MyArry的拷贝构造函数调用" << endl;
		this->m_Capacity = m1.m_Capacity;
		this->m_Size = m1.m_Size;
		//深拷贝
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m1.m_Size; i++)
		{
			this->pAddress[i] = m1.pAddress[i];
		}
	}

	//赋值符重载
	Myarray& operator =(Myarray& arr)
	{

		//cout << "MyArry的operator=调用" << endl;

		//先判断原来堆区是否有数据，如果有先释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

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

	//中括号重构，返回值
	T& operator [](int index)
	{
		return this->pAddress[index];
	}

	//尾插
	void push_add(T& val)
	{
		if (this->m_Capacity == this->m_Size)
			return;
		else
		{
			this->pAddress[this->m_Size] = val;
			this->m_Size++;
		}
	}
	//尾删
	void push_del()
	{
		if (this->m_Size == 0)
			return;
		else
		{
			this->m_Size--;
		}
	}

	//统计大小
	int get_size()
	{
		return this->m_Size;
	}
	//统计容量
	int get_capacity()
	{
		return this->m_Capacity;
	}
	//析构函数
	~Myarray()
	{
		if (this->pAddress != NULL)
		{
			//cout << "析构函数！" << endl;
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

private:
	T* pAddress;//指针指向堆区开辟的真实数组
	int m_Capacity;//数组容量
	int m_Size;//数组大小
};
  1. 类函数模板.cpp文件中测试普通数据
#include<iostream>
#include"MyArray.hpp"

void print_arr(Myarray<int>& a1)
{
	for (int i = 0; i < a1.get_size(); i++)
	{
		cout << a1[i] << endl;
	}
}

void test01()
{
	Myarray<int>a1(5);
	for (int i = 0; i < 5; i++)
	{
		a1.push_add(i);
	}
	cout << "插入之后的数据为：" << endl;
	print_arr(a1);
	cout << "数组的容量为：" << a1.get_capacity() << endl;
	cout << "数组的大小为：" << a1.get_size() << endl;
	a1.push_del();
	cout << "删除之后的数据为：" << endl;
	print_arr(a1);
	cout << "数组的容量为：" << a1.get_capacity() << endl;
	cout << "数组的大小为：" << a1.get_size() << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}
  1. 在类函数模板.cpp文件中测试结构体数据
#include<iostream>
#include"MyArray.hpp"

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



void PrintPersonArry(Myarray<Person>& arr)
{
	for (int i = 0; i < arr.get_size(); i++)
	{
		cout << "姓名为：" << arr[i].m_name << "年龄为：" << arr[i].m_age << endl;
	}
}

void test02()
{

	Myarray<Person>arr(10);
	Person p1("伞兵1", 21);
	Person p2("伞兵2", 22);
	Person p3("伞兵3", 23);
	Person p4("伞兵4", 24);
	Person p5("伞兵5", 25);

	//将数据插入到数组中
	arr.push_add(p1);
	arr.push_add(p2);
	arr.push_add(p3);
	arr.push_add(p4);
	arr.push_add(p5);

	//打印数组
	PrintPersonArry(arr);
	//输出容量
	cout << "arr容量为" << arr.get_capacity() << endl;
	//输出大小
	cout << "arr大小为" << arr.get_size() << endl;

}

int main()
{
	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)

算法分为:质变算法和非质变算法

  • 质变算法:是指运算过程中会更改区间内元素的内容。例如拷贝、查找、删除等等

  • 非质变算法:是指在运算过程中不会更改区间内的元素内容，例如查找、

计数、遍历、寻找极值等等

迭代器：容器和算法之间的的粘合剂

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1501188.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C++ 篇 数组

C++ 篇 数组

数组是含有多个数据项的数据结构&#xff0c;并且这些数据项都具有相同的数据类型。这些数据项称为数组的元素&#xff0c;我们可以根据元素在数组中的位置来选取元素。 最简单的数组就是一维数组。数组元素在内存中是依次排列的&#xff0c;如下图所示&#xff1a; 声明一个…
阅读更多...
js【详解】原型 vs 原型链

js【详解】原型 vs 原型链

原型 每个 class 都有显示原型 prototype每个实例都有隐式原型_proto_实例的_proto_指向对应 class 的 prototype 如下范例&#xff1a; class Student 创建了 实例 xialuo 获取属性 xialuo.name 或执行方法 xialuo.sayhi()时&#xff0c;先在自身属性和方法寻找&#xff0…
阅读更多...
1.5如何缓解图像分类任务中训练数据不足带来的问题？

1.5如何缓解图像分类任务中训练数据不足带来的问题？

1.5 图像数据不足时的处理方法 场景描述 在机器学习中&#xff0c;绝大部分模型都需要大量的数据进行训练和学习(包括有监督学习和无监督学习)&#xff0c;然而在实际应用中经常会遇到训练数据不足的问题。 比如图像分类&#xff0c;作为计算机视觉最基本的任务之一&#xff0…
阅读更多...
C++进阶之路---继承（二）

C++进阶之路---继承（二）

顾得泉&#xff1a;个人主页 个人专栏&#xff1a;《Linux操作系统》 《C从入门到精通》 《LeedCode刷题》 键盘敲烂&#xff0c;年薪百万&#xff01; 一、继承与友元 友元关系不能继承&#xff0c;也就是说基类友元不能访问子类私有和保护成员。 class Student; class Per…
阅读更多...
机器学习——神经网络压缩

机器学习——神经网络压缩

神经网络压缩 需要部署&#xff0c;设备内存和计算能力有限&#xff0c;需要进行模型压缩&#xff0c;在设备上运行的好处是低延迟&#xff0c;隐私性。 目录 不考虑硬件问题&#xff0c;只考虑通过软件算法优化。 修剪网络 参数过多或者没有用的参数&#xff0c;可以将其剪…
阅读更多...
JavaWeb笔记 --- 二、Maven

JavaWeb笔记 --- 二、Maven

二、Maven Maven概述 所有的IDE创建的Maven项目都可以使用 Maven简介 Maven模型 Maven常用命令 Maven生命周期 Maven坐标 依赖管理 dpendencies&#xff1a;依赖 依赖范围
阅读更多...
Matlab|基于目标级联法的微网群多主体分布式优化调度

Matlab|基于目标级联法的微网群多主体分布式优化调度

目录 主要内容 1.1 上层微网群模型 1.2 下层微网模型 部分程序 实现效果 下载链接 主要内容 本文复现《基于目标级联法的微网群多主体分布式优化调度》文献的目标级联部分&#xff0c; 建立微网群系统的两级递阶优化调度模型: 上层是微网群能量调度中心优化调度…
阅读更多...
考研数学｜张宇30讲，搭配什么基础题？

考研数学｜张宇30讲，搭配什么基础题？

如果基础跟的是张宇&#xff0c;那么基础做的题目要根据自己的题目来决定 题集的选择最好不要太难&#xff0c;而且基础也不用做太多题目&#xff0c;以数学知识点的运用&#xff0c;培养做题感觉为主。 张宇老师的课程在基础阶段也有配套的课程&#xff0c;就是《张宇基础30…
阅读更多...
二维码门楼牌管理系统应用场景：推动旅游与文化产业的智慧化升级

二维码门楼牌管理系统应用场景：推动旅游与文化产业的智慧化升级

文章目录 前言一、二维码门楼牌管理系统在旅游领域的应用二、二维码门楼牌管理系统在文化产业的应用三、结语 前言 随着信息技术的不断发展&#xff0c;二维码门楼牌管理系统作为一种创新的信息化手段&#xff0c;正在逐渐渗透到旅游和文化领域。它通过为文化景点、旅游景点和…
阅读更多...
【动态规划.3】[IOI1994]数字三角形 Number Triangles

【动态规划.3】[IOI1994]数字三角形 Number Triangles

题目 https://www.luogu.com.cn/problem/P1216 观察下面的数字金字塔。 写一个程序来查找从最高点到底部任意处结束的路径&#xff0c;使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。 7→3→8→7→5 的路径产生了最大权值。 分析 这是一个动态规划…
阅读更多...
【Kaggle】练习赛《肥胖风险的多类别预测》

【Kaggle】练习赛《肥胖风险的多类别预测》

前言 作为机器学习的初学者&#xff0c;Kaggle提供了一个很好的练习和学习平台&#xff0c;其中有一个栏目《PLAYGROUND》&#xff0c;可以理解为游乐场系列赛&#xff0c;提供有趣、平易近人的数据集&#xff0c;以练习他们的机器学习技能&#xff0c;并每个月都会有一场比赛…
阅读更多...
Postman(注册，使用，作用)【详解】

Postman(注册，使用，作用)【详解】

目录 一、Postman 1. Postman介绍 2. 安装Postman 3. 注册帐号再使用(可保存测试记录) 4. 创建workspace 5. 测试并保存测试记录 一、Postman postman工具可以发送不同方式的请求,浏览器只能发送get请求(所有用这个工具) 在前后端分离开发模式下&#xff0c;前端技术人员…
阅读更多...
mybatis plus 查询数据库 字段名 自动添加下划线

mybatis plus 查询数据库 字段名 自动添加下划线

问题 mybatis plus 查询数据库 字段名 自动添加下划线 详细问题 笔者使用mybatis plus 查询数据库&#xff0c;执行查询语句报错。详细报错信息 2024-03-08 11:08:33.156 ERROR 4816 --- [nio-9090-exec-9] o.a.c.c.C.[.[.[/].[dispatcherServlet] : Servlet.service() …
阅读更多...
数据开发 - 面经（已OC） - 北京中海通

数据开发 - 面经（已OC） - 北京中海通

投递流程&#xff1a; 2023.12.28 Boss 打招呼 2024.1.3 约面 2024.1.4 上午面试 &#xff08;手机端腾讯会议&#xff09; 2024.1.5 上午 通知面试通过 腾讯会议手机端无法和录影机同时运行&#xff0c;录音无效&#xff0c;之后注意使用电脑面试 面试流程&#xff1a;首…
阅读更多...
SpringCloud-搭建RabbitMQ消息队列

SpringCloud-搭建RabbitMQ消息队列

本文介绍了在 Windows 环境下安装 RabbitMQ 及其依赖的 Erlang 语言的过程。通过提供下载链接和详细的安装步骤&#xff0c;使读者能够快速搭建 RabbitMQ 开发环境。同时&#xff0c;展示了常用的命令和验证方法&#xff0c;确保安装正确完成。这为搭建 RabbitMQ 服务奠定了基…
阅读更多...
【深入理解设计模式】享元设计模式

【深入理解设计模式】享元设计模式

享元设计模式 概述 享元设计模式&#xff08;Flyweight Design Pattern&#xff09;是一种用于性能优化的设计模式&#xff0c;它通过共享尽可能多的相似对象来减少对象的创建&#xff0c;从而降低内存使用和提高性能。享元模式的核心思想是将对象的共享部分提取出来&#xff…
阅读更多...
推房子游戏c++

推房子游戏c++

这段代码是一个推箱子游戏的实现。游戏中有一个地图&#xff0c;地图上有墙壁、人、箱子和目标位置。玩家通过键盘输入WASD或方向键来控制人物的移动&#xff0c;目标是将所有的箱子推到相应的目标位置上。 代码中的dt数组表示地图&#xff0c;每个位置上的字符表示对应的元素…
阅读更多...
分享2024年在家轻松兼职赚钱的5个副业

分享2024年在家轻松兼职赚钱的5个副业

今天在网上看到这么一句话&#xff0c;真的让我深有感触&#xff1a;“职场人一定要有居安思危的意识&#xff0c;创业的人一定要三思而后行”。在这个瞬息万变的时代&#xff0c;连被视为铁饭碗的公务员、教师等体制内工作都不能保证一辈子的稳定。发展副业&#xff0c;似乎成…
阅读更多...
Deepl翻译相关介绍

Deepl翻译相关介绍

DeepL是一种机器翻译软件&#xff0c;它在2017年首次发布。该软件利用了神经网络和深度学习技术&#xff0c;以提供更准确和自然的翻译结果。DeepL的翻译质量被广泛认为是当前机器翻译技术中最佳的之一。 官网&#xff1a;DeepL翻译&#xff1a;全世界最准确的翻译 DeepL具有许…
阅读更多...
伊理威科技：新手开抖店的教程

伊理威科技：新手开抖店的教程

在数字浪潮中&#xff0c;抖音小店如星火燎原&#xff0c;吸引无数创业者。你是否也心潮澎湃&#xff0c;想要一试身手?别急&#xff0c;让我们一步步揭开开店的神秘面纱。 注册流程。想象一下&#xff0c;你只需在抖音平台上点击“我要开店”&#xff0c;按提示填写相关信息&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023