大连微信公众号开发公司_商机创业网_营销助手下载app下载_附近广告公司

---

前言

typename、非类型模板参数、模板参数的特化、模板类成员函数声明和定义分离、继承等的介绍

---

一、typename

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

对上述Print函数进行模板化，如果不加typename会出现如下情况：

#include <iostream>
#include <vector>
#include <list>
using namespace std;template <class Container>
void Print(Container& v)
{typename Container::iterator it = v.begin(); // 此处要加typename修饰while (it != v.end()){cout << *it << " ";++it;}cout << endl;
}
int main()
{vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.push_back(5);Print(v);vector<double> v1;v1.push_back(1.1);v1.push_back(2.2);v1.push_back(3.3);v1.push_back(4.4);v1.push_back(5.5);Print(v1);list<double> lt;lt.push_back(1.14);lt.push_back(2.14);lt.push_back(3.14);lt.push_back(4.14);lt.push_back(5.14);Print(lt);return 0;
}

二、非类型模板参数

• 比如一个静态栈，不仅需要接收类型参数， 还需要接收每个数组的长度

#include <iostream>
#include <vector>
#include <list>
using namespace std;// 静态栈
template <class T, size_t N>
class Stack
{
public:Stack(){}
private:T _a[N];int _top;
};
int main()
{Stack<int, 10> st1; // 10Stack<double, 100> st2; // 100return 0;
}

三、模板参数的特化

特化指的就是 特殊化处理

1. 函数模板参数的特化

• 函数模板个格式，虽然需要加template<>，但是大多数情况下，我们可以直接去掉，与原来的函数构成函数重载，达到特化的效果

#include <iostream>
using namespace std;
// 函数模板的特化
template <class T>
bool Less(T left, T right)
{return left < right;
}// 函数模板的特化格式
template<>
bool Less<int*>(int* left, int* right)
{return *left < *right;
}int main()
{cout << Less(1, 2) << endl;int a = 2, b = 1;cout << Less(&a, &b) << endl;return 0;
}

2. 类模板的特化

类模板的特化包括 全特化，偏特化（半特化）， 限制类型为指针， 限制类型为引用

#include <iostream>
using namespace std;// 类模板特化template <class T1, class T2>
class A
{
public:A() { cout << "A<T1, T2>" << endl; }
private:
};// 全特化
template<>
class A<int, double>
{
public:A() { cout << "A<int, double>" << endl; }
private:
};// 偏特化
template <class T1>
class A<T1, double>
{
public:A() { cout << "A<T1, double>" << endl; }
private:
};// 对类型进行限制---指针
template <class T1, class T2>
class A<T1*, T2*>
{
public:A() { cout << "A<T1*, T2*>" << endl; }
private:
};// 对类型限制---引用
template <class T1, class T2>
class A<T1&, T2&>
{
public:A() { cout << "A<T1&, T2&>" << endl; }
private:
};int main()
{A<int, int> a1;A<int, double> a2;A<double, double> a3;A<char, double> a4;A<int*, double> a5;A<int*, double*> a6;A<void*, void*> a7;A<int&, double&> a8;return 0;
}

四、模板类成员函数声明和定义分离

模板类成员函数声明和定义分离 有两种方式：
一种是： 在函数的定义处显示实例化
另一种是： 将生命和定义写在同一个.h文件中，（有些还将这种文件以.hpp作为后缀）

模板类成员函数声明和定义直接分离，因为模板类型T没有进行实例化，编译器在链接阶段无法找到正确的地址，所以会出现编译报错。

1. 显示实例化（不建议使用）

// Stack.h
#pragma once
#include <vector>namespace hhb
{template<class T, class Container = std::vector<T>>class stack{public:void push(const T& x);void pop();bool empty(){return _con.empty();}const T& top(){return _con.front();}private:Container _con;};}

---

// Stack.cpp
#include "Stack.h"namespace hhb
{template<class T, class Container>void stack<T, Container>::push(const T& x){_con.push_back(x);}template <class T, class Container>void stack<T, Container>::pop(){_con.pop_back();}templateclass stack<int>;templateclass stack<double>;
}

---

// test.cpp
#include "Stack.h"int main()
{hhb::stack<int> st;st.push(1);st.pop();hhb::stack<double> st1;st1.push(1.1);st1.pop();return 0;
}

• 不会有编译错误

2. 将生命和定义写在同一个.h文件中

// Stack.h
#pragma once
#include <vector>namespace hhb
{template<class T, class Container = std::vector<T>>class stack{public:void push(const T& x);void pop();bool empty(){return _con.empty();}const T& top(){return _con.front();}private:Container _con;};template<class T, class Container>void stack<T, Container>::push(const T& x){_con.push_back(x);}template <class T, class Container>void stack<T, Container>::pop(){_con.pop_back();}}

---

// test.cpp
#include "Stack.h"int main()
{hhb::stack<int> st;st.push(1);st.pop();hhb::stack<double> st1;st1.push(1.1);st1.pop();return 0;
}

• 不会有编译错误

---

五、 继承

访问限定符的权限 ： public > protected > privated;
继承是有基类以继承方式继承给派生类
继承方式： 有三种 以 public 、 protected、 private 三种方式进行继承。
派生类对基类成员变量/成员函数的访问方式取决于： 基类的成员变量和成员函数的访问限定符以及派生类的继承方式：

1. 基类的成员若为private， 则在派生类中无法看见（访问）基类private的成员
2. 基类的protected和public成员， 与派生类的继承方式权限进行比较，权限小的即为在派生类中访问基类成员的访问方式。

#include <iostream>
using namespace std;
class Person
{
public:Person(){}void print(){cout << "_name: " << _name <<  endl;cout << "_age: " << _age << endl;}
protected:string _name = "perter";int _age = 10;
};class student : public Person
{
public:
private:int _sid;
};class teacher : public Person
{
public:
private:int _tid;
};int main()
{student s;s.print();teacher t;t.print();return 0;
}

总结

typename、非类型模板参数、模板参数的特化、模板类成员函数声明和定义分离、继承等的介绍