5660知识点

1、函数模板

• 函数模板本身不允许隐式类型转换&＃xff0c;但是有以下两种情况
  1、自动推导类型时&＃xff0c;必须严格匹配
  2、显示类型指定时&＃xff0c;能够进行隐式类型转换

多参数模板的使用&＃xff0c;显示类型指定时&＃xff0c;能够进行隐式类型转换。返回值参数作为第一个类型参数&＃xff0c;必须显示指定

//T1 &＃61; double, T2 &＃61; float, T3 &＃61; doubledouble r2 &＃61; Add(0.5, 0.8);


• 函数模板可以像普通函数一样被重载
  — C&＃43;&＃43;编译器优先考虑普通函数
  — 如果函数模板可以产生一个更好的搭配&＃xff0c;那么选择模板
  — 可以通过空模板实参列表限定编译器只匹配模板
  

2、类模板

• 类模板的应用
  — 只能显示指定具体类型&＃xff0c;无法自动推导
  — 使用具体类型 定义对象

• 类模板的工程应用
  — 类模板必须在头文件中定义
  — 类模板不能分开实现在不同的文件中
  — 类模板外部定义的成员函数需要加上 模板<>声明

3、类模板的特化

编译器优先选择特化类&＃xff0c;然后才是模板类

部分特化&＃xff1a;

完全特化&＃xff1a;

特化是建立在类模板的基础上的&＃xff0c;有类模板之后&＃xff0c;才分为部分特化和完全特化。只要是特化&＃xff0c;就必须在class Test 后面加上 <&＃xff08;含参数&＃xff09;>

部分特化我个人觉得它是一个小模板&＃xff0c;class Test 后面加上<参数 >
完全特化我个人觉得它具体到了某一个类型&＃xff0c;class Test 后面加上 <>

函数模板没有部分特化&＃xff0c;只有完全特化

#include
#include
using namespace std;template
bool equal(T a, T b)
{cout <<"bool equal(T a, T b)" <;return a &＃61;&＃61; b;
}//函数模板完全特化template<>
bool equal(double a, double b)
{cout <<"bool equal(double a, double b)" <;const double dlta &＃61; 0.00001;double t &＃61; b - a;return (t > -dlta) && (t );
}
int main()
{cout <<equal(1, 1) <;cout <<equal(0.0001, 0.0001) <;return 0;
}


4、数值型模板参数

• 数值型模板参数的限制
  — 变量不能作为模板参数
  — 浮点数不能作为模板参数
  — 类对象不能作为模板参数
  — …
  本质&＃xff1a;模板参数是在编译阶段被处理的单元&＃xff0c;因此&＃xff0c;在编译阶段必须准确无误的唯一确定

5、数组类模板
HeapArray.h

#ifndef _HEAPARRAY_H_
#define _HEAPARRAY_H_
#pragma oncetemplate
class HeapArray
{
private:T* m_pointer;int m_length;HeapArray(int len);bool construct();
public:static HeapArray* NewInstance(int length);int length();bool set(int index,T value);bool get(int index, T& value);HeapArray& self();T& operator[](int i);T operator[](int i)const;HeapArray& operator&＃61;(const HeapArray& obj);~HeapArray();
};template
HeapArray::HeapArray(int len)
{m_length &＃61; len;
}template
bool HeapArray::construct()
{bool ret &＃61; true;m_pointer &＃61; new T[m_length];return (m_pointer !&＃61; NULL);
}template
HeapArray* HeapArray::NewInstance(int length)
{HeapArray* ret &＃61; new HeapArray(length);if (!(ret && ret->construct())){delete ret;ret &＃61; nullptr;}return ret;
}template
int HeapArray::length()
{return m_length;
}template
HeapArray& HeapArray::self()
{return *this;
}template
bool HeapArray::set(int index, T value)
{bool ret &＃61; (index >&＃61; 0 && index );if (ret){m_pointer[index] &＃61; value;}return ret;
}template
bool HeapArray::get(int index, T& value)
{bool ret &＃61; (index >&＃61; 0 && index );if (ret){value &＃61; m_pointer[index];}return ret;
}template
T& HeapArray::operator[](int i)
{return m_pointer[i];
}template
T HeapArray::operator[](int i)const
{return m_pointer[i];
}template
HeapArray& HeapArray::operator&＃61;(const HeapArray& obj)
{if (this !&＃61; &obj){m_length &＃61; obj.m_length;delete[]m_pointer;m_pointer &＃61; new T[obj.m_length];if (m_pointer !&＃61; nullptr){for (int i &＃61; 0; i ; i&＃43;&＃43;){m_pointer[i] &＃61; obj.m_pointer[i];}}}return *this;
}template
HeapArray::~HeapArray()
{delete[]m_pointer;
}#endif


main.cpp

#include
#include "HeapArray.h"
#include
using namespace std;int main()
{HeapArray* array &＃61; HeapArray::NewInstance(5);HeapArray& a &＃61; array->self();if (array)cout <length() <;cout <;HeapArray* brray &＃61; HeapArray::NewInstance(10);HeapArray& b &＃61; brray->self();a &＃61; b;cout <length() <;cout <length() <;delete array;delete brray;return 0;
}


几个要注意的点&＃xff1a;
1、 类模板必须在头文件中定义&＃xff0c;类模板外部定义的成员函数需要加上 模板<>声明&＃xff0c;也就是类似于HeapArray::

• 实现我们这些成员函数
  1、遇到返回值类型为类名的&＃xff0c;我们要把返回值类型改成HeapArray
  2、遇到构造函数这种&＃xff0c;直接在前面加上HeapArray::

6、单例类模板

• 单例类模板的思想&＃xff1a;
  1、整个类只能创建一个对象&＃xff0c;我们把所有的构造函数全部私有化&＃xff0c;以及把赋值操作符的重载函数也私有化&＃xff0c;这样就不能随意的创建对象
  2、其次我们定义一个状态值 instance &＃xff0c;类型为类指针&＃xff0c;是一个静态变量&＃xff0c;初始化为NULL。在公有成员函数里面定义一个静态成员函数 setInstance。当instance 为空时利用instance 这个类指针申请堆空间&＃xff0c;返回这个类指针。
  
  Singleton.cpp

#include
using namespace std;class Singleton
{
private:static Singleton* instance;Singleton(){}Singleton(const Singleton& obj){}Singleton& operator&＃61;(const Singleton& obj){}
public:static Singleton* setInstance();void print(){cout <<"this &＃61; " <;}
};Singleton* Singleton::instance &＃61; NULL;Singleton* Singleton::setInstance()
{if (instance &＃61;&＃61; NULL){instance &＃61; new Singleton();}return instance;
}int main()
{Singleton* ret &＃61; Singleton::setInstance();Singleton* ret1 &＃61; Singleton::setInstance();ret->print();ret1->print();return 0;
}