56 - 60知识点

1、函数模板

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

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

//T1 = double, T2 = float, T3 = double
	double r2 = Add<double, float>(0.5, 0.8);

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

2、类模板

• 类模板的应用
  — 只能显示指定具体类型，无法自动推导
  — 使用具体类型 < Type >定义对象

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

3、类模板的特化

编译器优先选择特化类，然后才是模板类

部分特化：

完全特化：

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

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

函数模板没有部分特化，只有完全特化

#include <iostream>
#include <string>
using namespace std;

template<typename T>
bool equal(T a, T b)
{
	cout << "bool equal(T a, T b)" << endl;
	return a == b;
}

//函数模板完全特化

template<>
bool equal<double>(double a, double b)
{
	cout << "bool equal<double>(double a, double b)" << endl;
	const double dlta = 0.00001;
	double t = b - a;

	return (t > -dlta) && (t < dlta);
}
int main()
{
	cout << equal(1, 1) << endl;
	cout << equal(0.0001, 0.0001) << endl;


	return 0;
}

4、数值型模板参数

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

5、数组类模板
HeapArray.h

#ifndef _HEAPARRAY_H_
#define _HEAPARRAY_H_
#pragma once

template <typename T>
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=(const HeapArray& obj);
	~HeapArray();
};


template <typename T>
HeapArray<T>::HeapArray(int len)
{
	m_length = len;
}

template <typename T>
bool HeapArray<T>::construct()
{
	bool ret = true;
	m_pointer = new T[m_length];
	
	return (m_pointer != NULL);
}

template <typename T>
HeapArray<T>* HeapArray<T>::NewInstance(int length)
{
	HeapArray* ret = new HeapArray(length);
	if (!(ret && ret->construct()))
	{
		delete ret;
		ret = nullptr;
	}

	return ret;
}

template <typename T>
int HeapArray<T>::length()
{
	return m_length;
}

template <typename T>
HeapArray<T>& HeapArray<T>::self()
{
	return *this;
}

template <typename T>
bool HeapArray<T>::set(int index, T value)
{
	bool ret = (index >= 0 && index < m_length);
	if (ret)
	{
		m_pointer[index] = value;
	}
	return ret;
}

template <typename T>
bool HeapArray<T>::get(int index, T& value)
{
	bool ret = (index >= 0 && index < m_length);
	if (ret)
	{
		value = m_pointer[index];
	}
	return ret;
}

template <typename T>
T& HeapArray<T>::operator[](int i)
{
	return m_pointer[i];
}

template <typename T>
T HeapArray<T>::operator[](int i)const
{
	return m_pointer[i];
}

template <typename T>
HeapArray<T>& HeapArray<T>::operator=(const HeapArray& obj)
{
	if (this != &obj)
	{
		m_length = obj.m_length;
		delete[]m_pointer;
		m_pointer = new T[obj.m_length];
		if (m_pointer != nullptr)
		{
			for (int i = 0; i < obj.m_length; i++)
			{
				m_pointer[i] = obj.m_pointer[i];
			}
		}
	}
	return *this;
}

template <typename T>
HeapArray<T>::~HeapArray()
{
	delete[]m_pointer;
}

#endif

main.cpp

#include <iostream>
#include "HeapArray.h"
#include <string>
using namespace std;

int main()
{

	HeapArray<char>* array = HeapArray<char>::NewInstance(5);
	HeapArray<char>& a = array->self();
	if (array)
	cout << a.length() << endl;
	cout << endl;
	
	HeapArray<char>* brray = HeapArray<char>::NewInstance(10);
	HeapArray<char>& b = brray->self();

	a = b;
	cout << b.length() << endl;
	cout << a.length() << endl;

	delete array;
	delete brray;
	return 0;
}

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

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

6、单例类模板

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

#include <iostream>
using namespace std;

class Singleton
{
private:
	static Singleton* instance;

	Singleton()
	{
	}
	Singleton(const Singleton& obj)
	{
	}
	Singleton& operator=(const Singleton& obj)
	{
	}
public:
	
	static Singleton* setInstance();

	void print()
	{
		cout << "this = " << this << endl;
	}
};

Singleton* Singleton::instance = NULL;

Singleton* Singleton::setInstance()
{
	if (instance == NULL)
	{
		instance = new Singleton();
	}

	return instance;
}

int main()
{
	Singleton* ret = Singleton::setInstance();
	Singleton* ret1 = Singleton::setInstance();

	ret->print();
	ret1->print();
	return 0;
}