《Effective C++》 总结篇(模板与泛型编程)

和面向对象编程的显示接口和运行期多态不同，
泛型编程更多是隐式接口和编译期多态。

#include 
using namespace std;
class A
{
public:
	A() { x = 12; cout << "Create A" << endl; }
	virtual std::size_t size() const { return x; }
	virtual void Init() { x = 10; cout << "Init A" << endl; }
	void swap(A& other) { int t = x; x = other.x; other.x = t; cout << "Swap" << endl; }
	bool operator != (const int & x)
	{
		cout << "!=" << endl;
		return this->x != x;
	}
private:
	int x;
};
template
void Func(T& a)
{
	if (a.size() > 10 && a != 5)
	{
		T temp(a);
		temp.Init();
		temp.swap(a);
	}
}
int main()
{
	A a;
	Func(a);
	return 0;
}

1.以不同的参数具现化会导致调用不同的函数，这便是所谓的编译期多态。
2.泛型编程必须支持对应的隐式转换，如果函数中使用到诸如，size(),Init(),swap(),!=

请记住：
classes和templates都支持接口和多态。
对classes而言接口是显示的，以签名函数为中心。多态则是virtual函数发生于运行期。
对template参数而言接口是隐式的，奠基于有效表达式。多态则是通过template具现化和函数重载解析发生于编译期。

template
template

没什么不同，但是c++并不总是把class和typename视为等价。

涉及嵌套从属名称时只能使用关键字typename：

（从属名称（dependent name）：template内出现的名称（示例中的iter）如果相依于某个template参数（示例中的C）的名称。如果从属名称在class内呈嵌套状，则称为嵌套从属名称（nested dependent name）。const_iterator也是类。
）

#include 
using namespace std;
class A
{
public:
	typedef int const_iterator;
private:
	int x;
};
template
void Func(T& x)
{
	T::const_iterator* x;
}
int main()
{
	A a;
	Func(a);
	return 0;
}

这段代码编译会有报错

为什么？
因为我们不知道T::const_iterator是不是一个类型。我们无法确定！
可能T的某个静态成员变量恰好叫const_iterator，或者x碰巧是个global变量名称呢？
那样的话上述代码甚至不再是声明一个local变量而是一个相动作！！！
（T::const_iterator）* (x)！！！
所以c++规定必须使用typename为前缀。

#include 
using namespace std;
class A
{
public:
	typedef int const_iterator;
private:
	int x;
};
template
void Func(T& a)
{
	typename T::const_iterator* x;
}
int main()
{
	A a;
	Func(a);
	return 0;
}

任何时候当你想要在template中指涉一个从属类型名称，就必须在紧临它的前一个位置放上关键字typename。
但是有例外！typename不可以出现在base classes list内的嵌套从属类型名称之前，也不可在member initialization list(成员初值列)中作为base class 修饰符。

#include 
using namespace std;
template
class Base
{
public:
	class Nested
	{
	public:
		Nested(int x) { cout << x << endl; }
	};
};

template
class Dierived :public Base::Nested
{
public:
	Dierived(int x) :Base::Nested(x) {}
	int x;
};
int main()
{
	Dierived d(10);
	return 0;
}

即不能写成
typename Base::Nested

对于这种长名称我们可以通过typedef简写，这是非常常用的技巧，谁不想少写点单词呢？

template
void Func(T& a)
{
	typedef typename T::const_iterator* iter;
	iter x;
}

请记住：
声明template参数时，前缀关键字class和tyoename可互换
请使用typename标识嵌套从属类型名称：但不得在base class lists(基类列)和member initalization list(成员初值列)内以它作为base class修饰符

看这一段代码。Send(info)无法通过编译

#include 
using namespace std;
class CompanyA
{
public:
	void Send(string msg)
	{
		cout << "A Send : " << msg << endl;
	}
};
class CompanyB
{ 
	void Send(string msg)
	{
		cout << "B Send : " << msg << endl;
	}
};
class MsgInfo
{
public:
	string msg;
};
template
class MsgSender
{
	void Send(const MsgInfo& info)
	{
		string msg;
		msg = info.msg;
		Company c;
		c.Send(msg);
	}
};
template
class LoggingMsgSender :public MsgSender
{
public:
	void SendLog(const MsgInfo& info)
	{
		//log
		Send(info);//编译器不知道Company是什么，所以无法知道MsgSender是什么
	}
};
int main()
{

	return 0;
}

问题在于，当编译器遭遇class template LoggingMsgSender定义式时，并不知道他继承的是什么样的class。主要是不知道Company是什么。更明确的说是无法确定有Send这个函数。

这涉及到模板特化的问题！
我们看一个例子，假设我们引入了一个模板全特化的MsgSender

class CompanyZ
{

};
template<>
//一个全特化的MsgSender
class MsgSender
//，它和一般template相同，差别只是没有Send
{
};

所谓的模板全特化：template MsgSender针对类型Companyz特化了，并且其特化是全面的，也就是说一旦类型参数被定义为Companyz，再没有其他template参数可供变化。
（说人话：模板参数列表中all的模板参数都用具体的类型标识）
当类模板/函数模板进行全特化之后，这个全特化后的类/函数就不是一个模板类/函数了
（因为全特化完成后，模板参数类型为空了，即template<>了，就是一个具体的类/函数）

那么我们再考虑之前的LoggingMsgSender

template
class LoggingMsgSender :public MsgSender
{
public:
	void SendLog(const MsgInfo& info)
	{
		//log
		Send(info);//如果Company==Companyz这个函数不存在
	}
};

这就是为什么C++拒绝调用的原因：它知道base class template可能被特化，而那个特化版本可能不提供和一般性template相同的接口。

解决方案有三种：
1.加上“this->”

template
class LoggingMsgSender :public MsgSender
{
public:
	void SendLog(const MsgInfo& info)
	{
		//log
		this->Send(info);
	}
};

2.使用using声明式

template
class LoggingMsgSender :public MsgSender
{
public:
	using MsgSender::Send;
	void SendLog(const MsgInfo& info)
	{
		//log
		Send(info);
	}
};

3.明白指出被调用的函数位于base class内：

template
class LoggingMsgSender :public MsgSender
{
public:
	
	void SendLog(const MsgInfo& info)
	{
		//log
		MsgSender::Send(info);
	}
};

请记住：
可在derived class templates内通过”this->”指涉base class templates内的成员名称，或藉由一个明白写出的“base class 资格修饰符”完成。

使用template可能导致代码膨胀，二进制码会带着重复(或者几乎重复）的代码、数据，或两者。其结果有可能源码看起来合身而整齐，但目标码却不是这么回事。所以该条例用于我们解决template带来的代码膨胀问题。

参考这一篇

#include 
using namespace std;
template 
class SquareMatrixBase
{
public:
    SquareMatrixBase(T* p) : DataPointer(p) {}
    void Invert(size_t n) {}//求逆矩阵
private:
    T* DataPointer;
};
template 
class SquareMatrix:private SquareMatrixBase //n*n的矩阵T类型的
{
public:
    SquareMatrix() : SquareMatrixBase(Data)
    {}
    void Invert()
    {
        SquareMatrixBase::Invert(n);//调父类函数
    }
private:
    T Data[n * n];
};

int main()
{
    SquareMatrix a;
    SquareMatrix b;
}

请记住：
Templates生成多个classes和多个函数，所以任何template代码都不该与某个造成膨胀的template参数产生相依关系。
因非类型模板参数而造成的代码膨胀，往往可消除，做法是以函数参数或class成员变量替换template参数。
因类型参数而造成的代码膨胀，往往可降低，做法是让带有完全相同二进制表述的具现类型共享实现码。

真实的指针考研支持隐式转换。但我们自己简单写的指针不能这样

#include 
using namespace std;
template 
class SmartPtr
{
public:
    SmartPtr(T* p) : p(p) {}
private:
    T* p;
};

class A
{

};
class B :public A
{

};
int main()
{
    SmartPtr p1=SmartPtr(new B);//不行
    shared_ptr p2 = shared_ptr(new B);//可以
}

#include 
using namespace std;
template 
class SmartPtr
{
public:
    template
    SmartPtr(const SmartPtr & other):p(static_cast(other.get()))  {
    }
    SmartPtr(T* p) : p(p) {}
    T* get() const
    {
        return p;
    }
private:
    T* p;
};

class A
{

};
class B :public A
{

};
int main()
{
    SmartPtr p1=SmartPtr(new B);//不行
    shared_ptr p2 = shared_ptr(new B);//可以
}

#include 
using namespace std;
template 
class A {
public:
    A(T t) {
        this->t = t;
    }
    A(const A& e) {
        this->t = e.t;
    }
    const A& operator=(const A& e) {
        this->t = e.t;
        return *this;
    }
    template
    const A operator*(const A& t1, const A& t2) {
        return A(t1.t*t2.t);
    }
private:
    T t;
};
int main() {
    A t1(10);
    A t2 = t1 * 10;//报错
    return 0;
}

#include 
using namespace std;
template 
class A {
public:
    A(T t) {
        this->t = t;
    }
    A(const A& e) {
        this->t = e.t;
    }
    const A& operator=(const A& e) {
        this->t = e.t;
        return *this;
    }
    friend const A operator*(const A& t1, const A& t2) {
        return A(t1.t*t2.t);
    }
private:
    T t;
};
int main() {
    A t1(10);
    A t2 = t1 * 10;//没报错
    return 0;
}

#include 
using namespace std;
template
struct Factorial {
    enum { value = n * Factorial::value };
};
//特化模板，Factorial<0>的value值为1
template<>
struct Factorial<0> {
    enum { value = 1 };
};
int main() {
    Factorial<5> a;
    cout << a.value << endl;
    return 0;
}