类模板 STL容器 vector

//11.05

//类模板语法

//类模板作用：建立一个通用类，类中成员 数据类型可以不具体制定，用一个虚拟的类型来代表

//语法：1.template<typename T>

//      2.类

//解释：

//1.template -声明创建模板

//2.typename-表明其后的符号是一种数据类型，可以用class代替

//3.T-通用的数据类型，名称可以替换，通常为大写字母

/*

#include<iostream>

#include<string>

using namespace std;

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

cout << "age="<<this->mage<<endl;

}

NameType mname;

AgeType  mage;

};

void test01()

{

Person <string,int> p1("lili",18);//实例化对象

    p1.showPerson();

}

int main()

{

test01();

system("pause");

return 0;

}

*/

//类模板个函数模板的区别

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

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

/*

#include<iostream>

#include<string>

using namespace std;

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

cout << "age="<<this->mage<<endl;

}

NameType mname;

AgeType  mage;

};

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

void test01()

{

//Person p1("lili",18);//错误，无法用自动类型推导

Person <string,int> p1("lili",18);//正确 只有用显示指定类型

}

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

void test02()

{

Person<string> p2("mingming",20);//20默认是int型 因为前边儿有class AgeType=int

//Person<string,int> p2("mingming",20);

p2.showPerson();

}

int main()

{

//test01();

test02();

system("pause");

return 0;

}

*/

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

//类模板中成员函数和普通类中成员函数创建时机是有区别的

//普通类中的成员函数一开始就可以创建

//类模板中的成员函数在调用时才创建

/*

#include<iostream>

using namespace std;

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 func1(){obj.showPerson1();}

void func2(){obj.showPerson2();}

};

void test01()

{

myclass<Person1>m;//Person1的不能调Person2的

m.func1();

//m.func2();//编译会报错，说明函数调用才会去创建成员函数；

}

int main()

{

test01();

system("pause");

return 0;

}

*/

//类模板对象做函数参数

//一共有三种传入方式

//1.指定传入的类型--直接显示对象的数据类型*****

//2.参数模板化    --将对象中的参数变为模板进行传递

//3.整个类模板化  --将这个对象类型模板化进行传递

/*

#include<iostream>

#include<string>

using namespace std;

template<class T1,class T2>

class Person

{

public:

T1 mname;

T2 mage;

Person (T1 name,T2 age)

{

this->mname=name;

this->mage=age;

}

void showPerson()

{

cout<<"姓名"<<this->mname<<" " << "年龄" << this->mage<<endl;

}

};

//1.指定传入的类型--直接显示对象的数据类型

void printPerson1(Person<string,int>&p)

{

p.showPerson();

}

void test01()

{

Person <string,int> p("lili",18);

  printPerson1(p);

}

//2.参数模板化    --将对象中的参数变为模板进行传递

template<class T1,class T2>

void printPerson2(Person <T1,T2>&p2)

{

p2.showPerson();

cout << "T1类型"<<typeid(T1).name()<<endl;//推出来是什么类型

cout << "T2类型"<<typeid(T2).name()<<endl;

}

void test02()

{

Person <string,int> p2("liming",18);

printPerson2(p2);

}

//3.整个类模板化  --将这个对象类型模板化进行传递

template <class T>

void printPerson3(T &p3)

{

p3.showPerson();

cout << "T类型"<<typeid(T).name()<<endl;

}

void test03()

{

Person <string,int> p3("wangli",22);

printPerson3(p3);

}

int main()

{

//test01();

//test02();

test03();

system("pause");

return 0;

}

*/

/*

STL基本概念

STL：标准模板库

STL从广义上分为：容器（container）算法（algorithm）迭代器（iterator）

容器和算法之间通过迭代器进行无缝连接

STL几乎所有的代码都采用了模板类或模板函数

STL六大组件：容器，算法，迭代器，仿函数，适配器（配接器），空间配置器

1.容器：各种数据结构，如vector list deque set map等用来存放数据

2.算法：各种常用的算法，如sort find copy for_each等

3.迭代器：扮演了容器于算法之间的胶合剂

4.仿函数：行为类似函数，可作为算法的某种策略

5.适配器：一种用来修饰容器或者仿函数或迭代器接口的东西

6.空间配置器：负责空间的配置与管理

容器：置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组，链表，树，栈，队列，集合，映射表等

序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置

关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

算法:问题之解法也

有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)

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

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

非质变算法:是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

算法必须通过迭代器才能访问容器中的元素

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

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

每个容器都有自己专属的迭代器

迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

*/

/*

vector容器（可以理解为数组）

vector存放内置数据类型

容器：vector

算法：for_each

迭代器：vector<int>::iterator

*/

/*

#include<iostream>

#include<vector>

#include<algorithm>

using namespace std;

void myprint(int val)

{

cout << val<<endl;

}

void test01()

{

vector<int>v;//创建了一个vector容器 数组

    v.push_back(10);//向容器中插入数据

v.push_back(20);

v.push_back(30);

v.push_back(40);

//通过迭代器访问容器中的数据

//vector<int>::iterator itbegin=v.begin();//起始迭代器，指向容器中第一个元素

//vector<int>::iterator itend=v.end();//结束迭代器，指向容器中最后一个元素的下一位置

//第一种遍历方式

//while(itbegin!=itend)

// {

// cout << *itbegin << endl;

// itbegin++;

// }

//第二种遍历方式

// for(vector<int>::iterator it=v.begin();it!=v.end();it++)

// {

// cout <<*it<<endl;

// }

//第三种遍历方式（利用STL提供的遍历算法）

for_each(v.begin(),v.end(),myprint);

}

int main()

{

test01();

system("pause");

return 0;

}

*/

/*

vector存放自定义数据类型

*/

/*

#include<iostream>

#include<string>

#include<vector>

using namespace std;

class Person

{

public:

string mname;

int mage;

Person(string name,int age)

{

this->mname=name;

this->mage=age;

}

};

void test01()

{

vector<Person>v;

Person p1("aa",10);

Person p2("bb",20);

Person p3("cc",30);

Person p4("dd",40);

Person p5("ee",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 << "姓名：" << (*it).mname<<"年龄："<<(*it).mage<< endl;

cout << "姓名：" << it->mname<<"年龄："<<it->mage<< endl;

}

}

int main()

{

test01();

system("pause");

return 0;

}

*/

/*

#include<iostream>

#include<string>

#include<vector>

using namespace std;

class Person

{

public:

string mname;

int mage;

Person(string name,int age)

{

this->mname=name;

this->mage=age;

}

};

void test02()

{

vector<Person*>v;

Person p1("aa",10);

Person p2("bb",20);

Person p3("cc",30);

Person p4("dd",40);

Person p5("ee",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 << "姓名：" << (*it)->mname<<"年龄："<<(*it)->mage<< endl;

}

}

int main()

{

test02();

system("pause");

return 0;

}

*/

//vector容器嵌套容器

#include<iostream>

#include<vector>

using namespace std;

//容器嵌套容器

void test01()

{

vector<vector<int>> v;

//创建小容器

vector<int>v1;

vector<int>v2;

vector<int>v3;

vector<int>v4;

//向小容器中添加数据

for(int i=0;i<4;i++)

{

v1.push_back(i+1);

        v2.push_back(i+2);

v3.push_back(i+3);

v4.push_back(i+4);

}

//将校容器插入到大容器里面

v.push_back(v1);

v.push_back(v2);

v.push_back(v3);

v.push_back(v4);

//通过大容器，把所有数据遍历

for(vector<vector<int>>::iterator it =v.begin();it!=v.end();it++)

{

//(*it)--容器vector<int>

for(vector<int>::iterator vit =(*it).begin();vit!=(*it).end();vit++)

{

cout <<*vit<<" ";

}

cout <<endl;

}

}

int main()

{

test01();

system("pause");

return 0;

}