C++模板与泛型编程(41-49条款)

最新推荐文章于 2022-11-30 00:35:47 发布

嗨，人

最新推荐文章于 2022-11-30 00:35:47 发布

阅读量363

点赞数

分类专栏： C++ 文章标签： c++ 模板多态泛型

本文链接：https://blog.csdn.net/qq_33670157/article/details/104814600

版权

C++ 专栏收录该内容

24 篇文章 510 订阅

订阅专栏

41：了解隐式接口和编译器多态

1.面向对象编程世界里总是以显式接口（源码中明确可见）和运行期多态解决问题；Templates及泛型编程的世界中，与面向对象有根本上不同，在此世界中，显式接口和运行期多态仍然存在，但是重要性降低，反倒是隐式接口和编译期多态比较重要了。

template<typename T>
void doProcessing(T& w)
{
	T temp(w);
	temp.normalize();
	temp.swap();
	...
}

w的类型T好像必须支持swap，normalize()和拷贝构造函数，这一组表达式便是T必须支持的一组隐式接口。
涉及w的任何函数调用得以成功的原因是template具现化，这种具现化发生在编译期，不同的template参数具现化function templates 会导致调用不同的函数，这便是所谓的编译期多态。

2.显式接口和隐式接口？

通常显式接口由函数的签名式（也就是函数名称、参数类型、返回类型）构成。

class Widget
{
	public:
		Widget();
		~Widget();
		virtual void normalize();
		void swap(Widget& other);
		...
};

隐式接口不基于函数签名式，而是由有效表达式组成。

template<typename T>
void doProcessing(T& w)
{
	T temp(w);
	temp.normalize();
	temp.swap();
	...
}

显式接口和隐式接口都在编译器完成，就像无法以一种”与类童工之显式接口矛盾“的方式来使用对象，也无法在template中使用”不支持template所要求之隐式接口“的对象。

请记住

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

42：了解typename的双重意义

template<typename C>
void print2Nd(const C& container)
{
	if(container.size()>=2)
	{
		typename C::const_iterator iter(container.begin())
		....
	}
}

C::const_iterator前加上typename，告诉C++C::const_iterator是个类型不是局部变量。

请记住

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

43：学习处理模板化基类内的名称

template<typename Company>
class LoggingMsgSender:public MsgSender<Company>
{
	public:
		...
		void SendClaearMsg(const MsgInfo& info)
		{
			sendClear(info);//调用基类函数，无法通过编译
		}
		....
};

原因：当编译器遇到类LoggingMsgSender:punlic定义式时，不知道它继承什么样的class。继承的MsgSender<Company>不到最后具现化无法确切知道它是什么。
解决方法：
1.在基类函数调用之前加上this->

template<typename Company>
class LoggingMsgSender:public MsgSender<Company>
{
	public:
		...
		void SendClaearMsg(const MsgInfo& info)
		{
			this->sendClear(info);//成立，假设sendClear将被继承
		}
		....
};

2.使用using声明式

template<typename Company>
class LoggingMsgSender:public MsgSender<Company>
{
	public:
		using MsgSender<Company>::sendClear;//告诉编译器，假设sendClear位于基类内
		...
		void SendClaearMsg(const MsgInfo& info)
		{
			sendClear(info);
		}
		....
};

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

template<typename Company>
class LoggingMsgSender:public MsgSender<Company>
{
	public:
		...
		void SendClaearMsg(const MsgInfo& info)
		{
			MsgSender<Company>::sendClear(info);//假设sendClear将被继承下来
		}
		....
};

如果被调用的是virtual函数，上述的明确资格修饰符会关闭”virtual绑定行为“。
请记住

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

44：将与参数无关的代码抽离templates

请记住

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

45：运用成员函数模板接收所有兼容类型

template<typename T>
class SmartPtr
{
	public:
		template<typename U>
		SmartPtr(const SmartPtr<U> &other);
		... 
};

泛化构造函数并未被声明为explicit，因为原始指针类型之间的转换是隐式的，无需明白写成转型动作

member function templates(成员函数模板)的效用不限于构造函数，它们常扮演的另一个角色是支持赋值操作。例如TR1的shared_ptr
在类内声明泛化拷贝构造函数并不会阻止编译器会自动生成自己的拷贝构造函数（非泛化）

template<class T>
class shared_ptr
{
public:
	template<class Y>
	explicit shared_ptr(Y* p);


	shared_ptr(shared_ptr const& r);
	template<class Y>
	shared_ptr(shared_ptr<Y> const& r);

	template<class Y>
	explicit shared_ptr(weak_ptr<Y> const& r);
	template<class Y>
	explicit shared_ptr(auto_ptr<Y>&r);
	
	shared_ptr& operator=(shared_ptr const& r);
	template<class Y>
	shared_ptr& operator=(shared_ptr<Y> const& r);
	
	template<class Y>
	shared_ptr& operator=(auto_ptr<Y>& r);
	...
};