C++基础
模板及标准模板库
- 模板的作用
- 模板使程序员能够快速的建立具有类型安全得库集合和函数集合，它的实现，方便了大规模的软件开发。
- 简单的求最大值
#include <iostream>
using namespace std;
template <class X>
X Max(X a,X b)
{
return (a>b?a:b);
}
int main()
{
int x1=20,x2=100;
cout<<"max="<<Max<double>(x1,x2)<<endl;
double y1=22.3,y2=100.2;
cout<<"max="<<Max<double>(y1,y2)<<endl;
char z1='A',z2='z';
cout<<"max="<<Max<char>(z1,z2)<<endl;
}
- 模板定义
- 模板的定义很特殊，由 template<…> 处理的任何东西都意味着编译器在当时不为它分配存储空间，它一直处于等待状态直到被一个模板实例告知。所以为了容易使用，几乎总是在头文件中放置全部的模板声明和定义
#include <iostream>
using namespace std;
template <class X,class Y>
class Test
{
X m_t1;
Y m_t2;
public:
Test(X t1,Y t2)
{
m_t1=t1;
m_t2=t2;
}
void show()
{
cout<<"T1="<<m_t1<<"T2="<<m_t2<<endl;
}
void print();
};
template <class X,class Y>
void Test<X,Y>::print()
{
cout<<"t1="<<m_t1<<"t2="<<m_t2<<endl;
}
int main()
{
Test<int,char> t(10,'s');
t.show();
t.print();
}
-
类模板
- 使用类模板使用户可以为类声明一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值，能取任意类型（包括基本类型的和用户自定义类型）。
- 定义
template <模板参数表> class 类名 {类成员声明}- 在类模板以外定义其成员函数:
template <模板参数表> 类型名 类名<T>::函数名 ( 参数表 ) -
类模板与模板类的区别。
- 类模板是模板的定义，不是一个实实在在的类，定义中用到通用类型参数。
- 模板类是实实在在的类定义，是类模板的实例化。类定义中参数被实际类型所代替。
-
标准模板类
- 将程序写的尽可能通用
- 将算法从特定的数据结构中抽象出来，成为通用的
- C++的模板为泛型的程序设计奠定了关键的基础
- STL是泛型程序设计的一个范例
- 容器(container)
- 迭代器(itetator)
- 算法(algorithms)
- 函数对象(function object)
容器是容纳包含一组元素集合的对象
-
基本容器
- 向量（vector）
- 双端队列（deque）
- 列表（list）
- 集合（set）
- 多重集合（multiset）
- 映射（map）
- 多重映射（multimap）
-
容器的接口
- 通用容器运算符
- ==，!=，>，>=，<，<=，=
- 方法（函数）
- 迭代方法
- begin()，end()，rbegin()，rend()
- 访问方法
- size()，max_size()，swap()，empty()
- 迭代方法
- 通用容器运算符
-
顺序容器的接口
- 插入方法
- push_front()，push_back()，insert()，运算符“=”
- 删除方法
- pop() ，erase()，clear()
- 迭代访问方法
- 使用迭代器
- 其他顺序容器访问方法（不修改访问方法）
- front()，back()，下标[ ]运算符
- 插入方法
vector
-
初始化 vector 容器方法
- vector<elementType> v; // 创建一个没有任何元素的空容器
- vector<elementType> v(otherVec); //调用拷贝构造函数创建新容器
- vector<elementType> v(size); //创建一个大小为size的对象v，并使用默认构造函数初始化该向量
- vector<elementType> v(n,elem); //创建一个大小为n的容器，并使用元素elem初始化每一个元素
- vector<elementType> v(begin,end); //创建容器v，并使用（begin，end）之间的元素初始化容器
-
元素的插入
- veclist.push_back(elem); //将elem的一个拷贝插入到veclist的末尾
- veclist.insert(position,elem); //将elem的一个拷贝插入到指定的position的位置上
- veclist.insert(position,n,elem); //将elem的n个拷贝插入到由position指定的位置上
- veclist.insert(position,beg,end); //将从迭代器 beg至end-1 之间的元素插入到veclist 的position位置上
-
元素的删除
- veclist.clear(); //清空容器中所有元素
- veclist.erase(position); //删除position指定位置的元素
- veclist.erase(beg,end); //删除从beg至end-1之间的元素
- veclist.pop_back(); //删除最后一个元素
-
迭代器其他常用函数
- veclist.capacity(); //返回当前可插入到容器veclist的最大数(capacity是指容器在必须分配新的存储空间之前可以存放的元素总数)
- veclist.empty(); //判断容器是否为空，为空返回true，否则返回false
- veclist.size(); //返回容器veclist 中当前元素个数
- veclist.max_size(); //返回可以插入到容器中元素的最大个数(max_szie表示STL容器允许的最大元素数，通常，这个数是一个很大的常整数，可以理解为无穷大。这个数目与平台和实现相关)
vector使用
#include <iostream>
#include <vector>
using namespace std;
vector<int> v;
int main()
{
int elem;
//从标准输入设备输入整形
//知道输入的不是整形为止
while(cin>>elem)
{
v.push_back(elem);
}
for(int j=0;j<v.size();j++)
{
cout<<v[j]<<" ";
}
cout<<endl;
/*
for (vector<int>::size_type ix = 0; ix != ivec.size(); ++ix)
{
cout<<ivec[ix] <<endl; // 用下标方式访问
}
*/
for(vector<int>::iterator it=v.begin();it<v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
for(vector<int>::reverse_iterator it=v.rbegin();it<v.rend();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
- vector 与指针
#include <iostream>
#include <vector>
using namespace std;
int *p1; //iterator i1;
const int *p2; //const_iterator i2;
int *const p3; //const iterator i3;
const int *const p4; //const const_iterator i4;
void show(vector<int> vi)
{
vector<int>::iterator it;
it=vi.begin();
while(it!=vi.end())
{
cout<<*it++<<' ';
}
cout<<endl;
};
int main()
{
vector<int> vi(3,90);
show(vi);
int a[5]={3,4,5,6,7};
vi.insert(vi.begin(),a,a+5);
show(vi);
vi.push_back(100);
show(vi);
cout<<"size:"<<vi.size()<<endl;
vi.assign(5,99);
show(vi);
cout<<"size:"<<vi.size()<<endl;
}
List
- list的使用
- list的四种构造函数
- list<elementType> L; //构造空容器L
- list<elementType> L(n, elem); //创建一个大小为size的对象L，并使用elem元素进行初始化
- list<elementType> L(list1); //创建容器L，并使用已创建的容器list1进行初始化
- list<elementType> L(begin,end); //创建容器L，并使用（begin，end）之间的元素初始化容器
- list元素的插入
- L.push_back(elem); //向容器的末尾插入元素elem的拷贝
- L.push_front(elem); //向容器的开端插入元素elem的拷贝
- L.insert(position, elem); //向容器的position位置插入元素elem的拷贝
- L.insert(position, n, elem); //向容器的position位置上插入元素elem的n个拷贝
- L.insert(position, beg, end); //将迭代器beg至 end-1 指向的内容插入到容器的position位置上
- L.splice(position, list); //将链表容器list中的元素插入到position位置上，并且清空list容器
- L.splice(position, list, pos); //将容器list中的pos位置上的元素插入到position位置上，并将pos位置上的元素从list中移除
- L.splice(position, list, beg, end); //将容器list中beg 至 end-1 位置上的元素插入到position位置上，并将这些元素从list中移除
- 访问容器元素
List<elementType>::iterator i;
使用begin, end 成员函数来操作List<elementType>::reverse_iterator ri;
使用rbegin， rend 成员函数来操作List<elementType>::const_iterator ci;
使用begin， end 成员函数来操作，但是只能访问，不能进行修改
- 元素的删除
- L.pop_back(); //删除容器的最后一个元素
- L.pop_front(); //删除容器的第一个元素
- L.clear(); //删除容器的所有元素
- L.erase(position); //删除容器指定位置的元素
- L.erase(beg, end); //删除迭代器beg 至 end-1 之间的元素
- L.remove(elem); //移除与元素elem相等的元素
- list的四种构造函数
#include <iostream>
using namespace std;
#include <list>
int main()
{
int cpp[5]={3,6,1,7,5};
int java[8]={6,4,7,8,15,2,3,9};
int Unix[4]={5,2,6,9};
list<int> li;
li.insert(li.begin(),cpp,cpp+5);
li.insert(li.begin(),java,java+8);
li.insert(li.begin(),Unix,Unix+4);
li.sort();
li.unique();
li.reverse();
list<int>::iterator it=li.begin();
while(it!=li.end())
{
cout<<*it++<<' ';
}
cout<<endl;
}
/*
15 9 8 7 6 5 4 3 2 1
*/
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> l1;
int a[5]={3,4,5,6,7};
list<int> l2(a,a+5);
cout<<"l1.size="<<l1.size()<<endl;
cout<<"l2.size="<<l2.size()<<endl;
list<int>::iterator it;
for(it=l2.begin();it!=l2.end();it++)
{
cout<<*it<<' ';
}
cout<<endl;
it=l2.begin();
it++;
l2.erase(it);//删除it对应位置元素
l2.insert(l2.begin(),100);
l2.insert(l2.end(),200);
for(it=l2.begin();it!=l2.end();it++)
{
cout<<*it<<' ';
}
cout<<endl;
}
l1.size=0
l2.size=5
3 4 5 6 7
100 3 5 6 7 200
- map 使用
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main()
{
//key(是唯一的) value
map<int,string> mis;
//1. 插入map元素
mis.insert(make_pair(62,"东方不败"));
mis.insert(make_pair(32,"岳不群"));
mis.insert(make_pair(36,"林平之"));
//2. 插入方式,这里的20不是下标
mis[20]="劳德罗";
//mis.insert(make_pair(36,"abc"));无法覆盖
//mis[36]="xyz";//可覆盖
map<int,string>::iterator it;
it=mis.begin();
//元素位置和key相关,和插入顺序无关
//1.自动顺序的
while(it!=mis.end())
{
cout<<it->first<<":"<<it->second<<endl;
++it;
}
}
/*
20:劳德罗
32:岳不群
36:林平之
62:东方不败
*/
- 使用映射(map)建立阿拉伯数字0~9和英文单词zero到nine的映射关系，并输入阿拉伯数字(如1)，输出英文数字(如one)。
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main()
{
int num;
map<int,string> mis;
mis.insert(make_pair(0,"zero"));
mis.insert(make_pair(1,"one"));
mis.insert(make_pair(2,"two"));
mis.insert(make_pair(3,"three"));
mis.insert(make_pair(4,"four"));
mis.insert(make_pair(5,"five"));
mis.insert(make_pair(6,"six"));
mis.insert(make_pair(7,"seven"));
mis.insert(make_pair(8,"eight"));
mis.insert(make_pair(9,"nine"));
map<int,string>::iterator it;
cin>>num;
for(it=mis.begin();it!=mis.end();it++)
{
if(it->first==num)
cout<<it->second<<endl;
}
}
- vector 实现删除指定元素(vector<int> num,从控制台输入int填充vector，删除指定元素)
#include <iostream>
#include <vector>
using namespace std;
vector<int> vi;
int main()
{
int elem;
int place;
while(cin>>elem)
{
vi.push_back(elem);
}
for(vector<int>::iterator it=vi.begin();it<vi.end();it++)
{
cout<<*it<<' ';
}
cout<<endl;
for(vector<int>::iterator it1=vi.begin();it1<vi.end();)
{
if(*it1==3)
{
it1=vi.erase(it1);
cout<<*it1<<endl;
}
else
it1++;
}
for(vector<int>::iterator it2=vi.begin();it2<vi.end();it2++)
{
cout<<*it2<<' ';
}
cout<<endl;
}
- const 的使用拓展
#include <iostream>
#include <vector>
using namespace std;
class Test
{
int m_t;
public:
Test(){}
void lianxi()const
{
cout<<"lianxi const"<<endl;
}
void lianxi()
{
cout<<"lianxi"<<endl;
}
};
int main()
{
const Test t1;
t1.lianxi();
Test t2;
t2.lianxi();
}
