首先认识一下函数模板、类模板、栈模板。
函数模板就是一个模型,而模板函数是函数模板经过类型实例化的函数。
如下template
template
T Max(T a, T b)
{
return a > b ? a : b;
}
int main()
{
cout << Max(2, 5) << endl;//与Max匹配的函数叫模板函数
cout << Max('t', 'a') << endl;//使用模板不受限于它的类型
}
也可以一次定义几个不同类型
template
void fn(T1 a, T2 b)
{
cout << a << " " << b << endl;
}
void main()
{
fn('a', 5);
}
类模板不是类,需要经过参数实例化之后才是可以用的类(创建对象的时候告诉类模板<类型>)
template
class A
{
public:
A(int i=0):m_i(i){}
void print() { cout << m_i << endl; }
private:
T m_i
};
int main()
{
//A a;//err
A a(10);//这样经过参数实例化之后才是可以用的类
a.print();
}
自己模拟栈要很长一段代码:
#define SIZE 10
template
class SeqStack
{
public:
SeqStack()
{
m_capacity = SIZE;
m_data = new T[m_capacity];
m_top = -1;
}
~SeqStack()
{
delete[]m_data;
m_data = nullptr;
}
void Push(int v)
{
if (IsFull())return;
m_data[++m_top] = v;
}
void Pop()
{
if (IsEmpty())
{
return;
}
m_top--;
}
bool IsEmpty()
{
return m_top == -1;
}
bool IsFull()
{
return m_top >= m_capacity - 1;
}
int GetTop() //要优化
{
if (IsEmpty())
return 0;
return m_data[m_top];
}
private:
T* m_data;
int m_top;
int m_capacity;
};
int main()
{
SeqStack ss;
ss.Push(1);
ss.Push(2);
ss.Push(3);
while (!ss.IsEmpty())
{
cout << ss.GetTop() << " ";
ss.Pop();
}
}
栈模板就可以直接用,带上头文件#include
int main()
{
stack ss;
ss.push(1);
ss.push(2);
ss.push(3);
while (!ss.empty())
{
cout << ss.top() << endl;
ss.pop();
}
}
STL的重要的组件:容器、算法、迭代器
容器:存放数据
算法:操作数据
迭代器:容器和算法之间的粘合器——通过迭代器把容器里的东西取出,给算法操作(指针)
STL是泛型程序库:所有组件可以针对任意型别运作。
例:从标准输入读取一段整数,将这些整数存放在一个动态开辟的数组中,数组的
第一个元素存储整数的个数,以后依次是这些整数。
void main()
{
vector vv;
copy(istream_iterator(cin), istream_iterator(),
back_insert_iterator>(vv));
copy(vv.begin(), vv.end(), ostream_iterator(cout, " "));
}
•容器:用来管理某类对象的集合。容纳特定数据类型对象的集合,STL容器是将最常用的一些数据结构实现出来.包含了许多数据结构,如:vector,queue,statck…,string也可以看作是一个容器.
•分类:容器用来管理一组元素,为了适应不同需要,STL根据数据在容器中排列的特性,容器可分为序列式容器和关联式容器两种.
•序列式容器:可序群集,其中每个元素都有固定位置——取决于插入时机和地点,与元素的值没有关系,如果你以追加方式对一个群集置入n个元素,它们的排列次序将和置入次序一致。如vector,deque,list
•关联式容器:已序群集,元素位置取决于特定的排序准则,和插入顺序无关。如果你将n个元素置入这样的群集中,它们的位置取决于元素值,和插入次序无关。STL提供了4个这样的容器:set,map,。multiset,multimap。
关联式容器也可被视为特殊的序列式容器,因为已序群集正是根据某个排序准则排列而成。
向量(Vector)是一个封装了动态大小数组的顺序容器(Sequence Container)。跟任意其它类型容器一样,它能够存放各种类型的对象。可以简单的认为,向量是一个能够存放任意类型的动态数组。
vector:将其元素置于一个动态数组中加以管理,是一种动态数组,是基本数组的类模板,用于代替数组,支持随机存取。
int main()
{
vector v;
//v里面的构造方法
vector v1(5);//5个0
vector v2(4, 7);//4个7
int arr[5] = { 1,2,3,4,5 };
vector v3(arr,arr+5);//1,2,3,4,5
for (int i = 0; i < v2.size(); i++)
cout << v2[i] << " ";
cout << endl;
v.push_back(1);
v.push_back(2);
v.push_back(40);
v.push_back(3);
for (int i = 0; i < v.size(); i++)
cout << v[i] << " ";
cout << endl;
}
普通二维数组必须定义列数,如a[][3],但vector的每行列数可以不一样
void main()
{
vector v;
vector> vv;//vv相当于一个二维数组
v.push_back(1);//1
vv.push_back(v);//1
v.push_back(2);//1 2
vv.push_back(v);
//1
//1 2
v.push_back(3);//1 2 3
vv.push_back(v);
//1
//1 2
//1 2 3
for (int i = 0; i < vv.size(); i++)
{
for (int j = 0; j < vv[i].size(); j++)
cout << vv[i][j] << " ";
cout << endl;
}
}
vector定义后不能直接赋值,必须有东西存进去再修改
void main()
{
vector v;
//v.resize(5);
v[0] = 5;
//这相当于下面这两行,是不行的
//int a;
//a[0] = 6;
}
•算法:用来处理群集内的元素。它们可以出于不同的目的而搜寻,排序,修改,使用那些元素。是一种应用在容器上以各种方法处理其内存的行为或功能,如sort(排序),copy(拷贝)…,算法由模板函数体现,这些函数不是容器类的成员函数,是独立的函数,它们可以用于STL容器,也可以用于普通的C++数组等.
•头文件:#include
•1)变序型队列算法: 可以改变容器内的数据;
•2)非变序型队列算法:处理容器内的数据而不改变他们;
•3)排序值算法:包涵对容器中的值进行排序和合并的算法,还有二叉搜 索算法 ,
•4)通用数值算法:此种算法不多,涉及到专业领域中有用的算术操作,独立包涵于头文件
使用必须加上头文件#include
sort默认是做非递减排序,用的类模板,这个自己也可以模拟,如下:
自己也可以写个函数传入sort使其做非递增排序。
bool great(int a, int b)
{
return a > b;
}
template
class Great
{
public:
bool operator()(T a, T b)
{
return a > b;
}
};
void main()
{
int a[] = { 1,3,2,5,4,7,6,9,8,0 };
int n = sizeof(a) / sizeof(a[0]);
//sort(a, a + n,greater());
//sort(a, a + n, great);//函数模板,用函数名当做函数指针传入
sort(a, a + n, Great());//类模板,运用了()的重载
for (int i = 0; i < n; i++)
cout << a[i] << " ";
cout << endl;
}
for_each()函数是C++ STL中的一个遍历函数,函数原型如下:
for_each(InputIterator first, InputIterator last, Function functor);
复制 [first, last) 所定义的范围中的元素到始于 d_first 的另一范围。
函数原型:
template
inline OutputIterator copy(
InputIterator first,
InputIterator last,
OutputIterator result
);
void print(int n)
{
cout << n << " ";
}
int s = 0;
void Sum(int n)
{
s = s + n;
}
void main()
{
int a[5] = { 1,2,3,4,5 };
int b[5];
copy(a, a + 5, b);//把[a,a+n)复制到b
// copy(b, b + 5, ostream_iterator(cout, ","));
for_each(b, b + 5, print);//输出12345
for_each(b, b + 5, Sum);//输出15
cout << "s = " << s << endl;
}
将区间[iterator1,iterator2)内的元素反转
函数原型:
template
void swap(std::pair left, std::pair right);
前两个参数分别是第一个序列的开始和结束迭代器,第三个参数是第二个序列的开始迭代器。显然,这两个序列的长度必须相同。这个算法会返回一个迭代器,它指向第二个序列的最后一个被交换元素的下一个位置。
bool great5(int n)
{
return n > 5;
}
template
class Less5
{
public:
bool operator()(T n)
{
return n < 5;
}
};
void main()
{
int a[] = { 1,2,3,4,5 };
int b[] = { 6,7,8,9,0 };
int n = sizeof(a) / sizeof(a[0]);
int* p = find(a, a + n, 15);
cout << *(p - 1) << endl;
p = find_if(a, a + n, great5);
cout << *p << endl;
p = find_if(a, a + n, Less5());
cout << *p << endl;
reverse(a, a + n);
swap_ranges(a, a + 3, b);
cout << count(a, a + 5, 2) << endl;
cout << count_if(a, a + 5, Less5()) << endl;
}
函数原型
template
bool includes ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, Compare comp );
测试 [first1,last1)里面是否包含了[first2,last2)里面的所有元素。
int main(void)
{
int a[10] = { 12,0,5,3,6,8,9,34,32,18 };
int b[5] = { 5,3,6,8,9 };
int d[15];
sort(a, a + 10);
for (int i = 0; i < 10; i++)
cout << " " << a[i];
sort(b, b + 5); // 3 5 6 8 9
if (includes(a, a + 10, b, b + 5)) //一个数组是否包含另外一个数组
cout << "\n" << "sorted b members are included in a." << endl;
else
cout << "sorted a dosn`t contain sorted b!";
merge(a, a + 10, b, b + 5, d); //合并
for (int j = 0; j < 15; j++)
cout << " " << d[j];
return 0;
}
merge只有归并部分,使用它必须是两个有序数组经行归并(先用sort()排序)
void main()
{
int a[5] = { 5,4,1,2,3 };
int b[5] = { 6,8,1,4,6 };
int c[10];
sort(a, a + 5);
sort(b, b + 5);
merge(a, a + 5, b, b + 5, c);
}
迭代器简称it,它封装了指针(可以把它看成指针用)。它是算法和容器的粘合器——通过迭代器把容器里的东西取出
•迭代器:用来在一个对象群集的元素上进行遍历动作。这个对象群集或许是个容器,或许是容器的一部分。迭代器的主要好处是,为所有容器提供了一组很小的公共接口,利用这个接口,某项操作就可以行进至群集内的下一个元素。每一种容器都提供了自己的迭代器,而这些迭代器了解该种容器的内部结构,所以能够知道如何正确行进。迭代器的接口和一般指针差不多。
•可将其看作是一个指向容器中元素的普通指针,用迭代器来访问容器中的元素,是它将算法和容器连接在一起,每个容器都有自己的迭代器,只有容器自己才知道如何访问自己的元素.
•Vector有以下函数
•capacity():返回重新分配空间前所能容纳的元素最大数量
•reserve():如果容量不足,扩大之
•c.assign(n,elem):复制n个elem,赋值给c
•c.assign(beg,end):将区间[beg,end]内的元素赋值给c
•c.at(index):返回索引为index的元素,如果越界,则抛出异常
•c[index]:返回索引为index的元素,不检查错误
•c.front():返回第一个元素,不检查第一个元素是否存在
•c.back():返回最后一个元素,不检查最后一个元素是否存在
•c.insert(pos,elem):在pos位置上插入一个elem,并返回新元素位置
•c.insert(pos,n,elem):在pos位置插入n个elem,无返回值
•c.insert(pos,beg,end):在pos位置插入区间[beg,end]内的所有元素副本,无返回子
•c.push_back(elen):在尾部添加一个elem
•c.pop_back():移除最后一个元素(但不回传)
•c.erase(beg,end):移除[beg,end]区间内的所有元素,返回下一个元素的位置
•c.resize(num):将元素数量改为num(如果size变大,多出来的新元素都需以默认构造函数构造)
•c.resize(num,elem):将元素数量改为num(如果size变大,多出来的新元素都是elem的副本)
istream_iterator输入流迭代器类,不传参:默认为收到非法输入结束
back_insert_iterator向后插入类
vv.begin(),vv.end()容器自带使用的迭代器:
begin()返回指向首元素的迭代器,vv.end()指向尾元素的下一个
ostream_iterator(输出,分隔符);输出迭代器
void Print(int n)
{
cout << n << " ";
}
int main()
{
//创建一个容器vv
vector vv;
//copy输入流迭代器获取cin内容,到非法字符结束,向后插入到vector类型容器vv中
copy(istream_iterator(cin), istream_iterator(),
back_insert_iterator>(vv) );
//排序:从vv首元素,到vv尾元素的下一个
sort(vv.begin(), vv.end());
// 将vv开头到结尾copy到输出流迭代器中,以空格分割
copy(vv.begin(), vv.end(), ostream_iterator(cout, " "));
//输出
cout << endl;
//foreach也可以输出
for_each(vv.begin(), vv.end(), Print);
return 0;
}
容器push_back操作:字符串向后插入
二维数组:在一个容器里存放另一个容器
int main()
{
vector> vv;//二维数组
int i, j;
//创建3行4列的容器
for (i = 0; i < 3; i++)
{//给每一行添加一个动态构造的vector,一共i行
vv.push_back(vector());//向后插入
for (j = 0; j < 4; j++)
{//每一行放入j个0
vv[i].push_back(0);//把0放进去
}
}
//输出
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
cout << vv[i][j] << " ";
}
cout << endl;
}
}
字符串就相当于一个二维的存char的数组,存字符串的数组相当于一个“三维数组”。
v.append( 个数,追加的内容 ):容器存储内容的追加
int main()
{
vector v;//装字符串
vector>vv;//装字符串的数组
int i, j;
for (i = 0; i < 3; i++)
{
v.push_back("");//字符串
v[i].append(5,'*');//追加5个*,用于字符
}
for (i = 0; i < 3; i++)
{
cout << v[i] << endl;
}
for (i = 0; i < 4; i++)
{
vv.push_back(vector());//vv里面是字符串数组的数组
for (j = 0; j < 5; j++)
{
vv[i].push_back("11111");//vv[i]里面是字符串数组
cout << vv[i][j] << endl;//vv[i][j]里面是字符串
}
cout << vv[i][4][0] <<"-----"<< endl;//这里面是字符
}
}
用这个可以装n皇后问题的结果。
定义vector的一个迭代器(跟指针很像)
基类型::迭代器 名字
v.at(i)相当于v[i],但是at做越界异常处理了,v[i]不会管越界
v.size()取容器大小
int main()
{
int arr[5] = { 1,2,3,4,5 };
vector v1( arr,arr + 5 );
vector v2;
vector v3(v1);
int i;
for (i = 0; i < v1.size(); i++)
{
cout << v1[i] << " "<::iterator iter;//基类型::迭代器 名字
//迭代器指向v2开头,到末尾,输出
for (iter = v2.begin(); iter != v2.end(); iter++)
{
cout << *iter << " ";
}
cout << endl;
}
v.reserve();//设置最小容纳数量
v.resize();//设置容器大小,如果缩小容器大小,则容器大小范围外的东西都会被清零。
v.size();//输出容器大小
v.capacity();//输出容量大小
int main()
{
int num = 0;
int* p = nullptr;
vector v;
v.reserve(10);//最小容量为10
vector::iterator iter;
for (int i = 1; i < 20; i++)
{
v.push_back(i);
}
v.resize(5);//将v的大小改变为5
cout << v.size() << endl;//大小5
cout << v.capacity() << endl;//容量10
v.resize(10);//改变大小,resize之后的东西都没有了
for (iter = v.begin(); iter != v.end(); iter++)
{
cout << *iter << " ";
}
cout << endl;
}
v.assign(个数, 内容);//重新给值
v.front();//返回容器头的引用
v.back();//返回容器尾的引用
v1.begin(), v1.end()//返回开始的迭代器,末尾元素下一个的迭代器
v.pop_back();//删除尾部
v.erase( ,);//可以删除某个范围的
int main()
{
int arr[5] = { 1,2,3,4,5 };
vector v(arr,arr+3);//1,2,3,4,5
v.assign(5, 3);//重新给值3,3,3,3,3
vectorv1(arr, arr + 5);//1,2,3,4,5
v.assign(v1.begin(), v1.end());//v = v1;可以v.assign(v1.begin(), v1.begin()+3)//1,2,3,4,5
vectorv2(arr, arr + 5);
//v.clear();
v.insert(v.begin(),100);//100,1,2,3,4,5
v.insert(v.begin() + 2, arr, arr + 3);//100,1,1,2,3,2,3,4,5
v.insert (v.begin(), v1.begin(), v1.end());//1,2,3,4,5,100,1,1,2,3,2,3,4,5
v.insert(v.end() - 1, 3, 40);//1,2,3,4,5,100,1,1,2,3,2,3,4,40,40,40,5
vector::iterator iters = v.begin();
vector::iterator itere = v.end();
for (; iters != itere; iters++)
{
cout << *iters << " ";
}
cout << endl;
cout << "front:" << v.front() << endl;//1
cout << "back:" << v.back() << endl;//5
//删除
v.pop_back();1,2,3,4,5,100,1,1,2,3,2,3,4,40,40,40
cout << "size:" << v.size() << endl;//16
v.erase(v.begin());//2,3,4,5,100,1,1,2,3,2,3,4,40,40,40
v.erase(v.begin(), v.begin() + 3);//5,100,1,1,2,3,2,3,4,40,40,40
iters = v.begin();
itere = v.end();
for (; iters != itere; iters++)
cout << *iters << " ";
cout << endl;
}
跟容器的差不多
string查找、比较、插入、移除、子串赋值
int main()
{
string s = "helloworld";
const char* str = s.c_str();
cout << str << endl;
const char* str2 = "hello";
string s2 = str2;
s2 = "world";
cout << s2 << endl;
s2.assign("ssss");//重新赋值
cout << s2 << endl;
s2[3] = 'k';
cout << s2 << endl;
s2.at(2) = 'p';//改某个
cout << s2 << endl;
s2 = s2 + "tttttt";
cout << s2 << endl;
s2.append("kkkk");//追加
cout << s2 << endl;
}
int main()
{
string s = "abcdefgef";
string s1 = "abcf";
string sub = "bd";
string sub2 = "ef";
int pos = s.find(sub);//查找字符串
cout << pos << endl;//找不到返回-1
pos = s.find(sub2);
cout << pos << endl;//找到,返回当前字符串的起始位置,4
pos = s.rfind(sub2);
cout << pos << endl;//从右边找
int ret = s.compare(s1);//比较大小
cout << ret << endl;//s比s1小,返回-1
int ret1 = s1.compare(s);
cout << ret1 << endl;//s1比s大,返回1
//子串
string s2 = s.substr(0, 2);//取子串赋值给s2,从0开始取2个,(偏移量,数量)
cout << s2 << endl;
//插入
s2.insert(0, "kkk");//在0号下标插入kkk
cout << s2 << endl;
//移除
s2.erase(0, 5);//从0开始移除5个
cout << s2 << endl;
}