部分类模板专业化是这个设计问题的答案吗？
假设你有一个班级负责连接远程服务器。 我想抽象这个类来提供两个版本，一个通过UDP连接，另一个通过TCP连接。 我想构建可能的最简化运行时代码，而不是使用多态我正在考虑模板。 这是我的设想，但我不确定这是做这件事的最佳方式：
class udp {};
class tcp {};
template<class T,typename X>
class service
{
private:
// Make this private so this non specialized version can't be used
service();
};
template<typename X>
class service<udp, X>
{
private:
udp _udp;
X _x;
};
template<typename X>
class service<tcp, X>
{
private:
tcp _tcp;
X _x;
};
所以最终的好处是T的通用性仍然可用，但是设置UDP或TCP连接所需的非常不同的代码却是专用的。 我想你可以把它放到一个类中，或者提供另一个类，它遵循一些纯虚拟接口来设置网络连接，如IConnectionManager。
但是这确实使得通用T的代码现在不得不写入并维护在两个专用版本中，它们最终都是相同的。 如何最好地解决这个问题？ 我有一种感觉，我对这一切都是错误的。
这可以通过使用传输协议的策略来完成：
template<typename Transport>
class service : Transport {
public:
typedef Transport transport_type;
// common code
void do_something() {
this->send(....);
}
};
class tcp {
public:
void send(....) {
}
};
class udp {
public:
void send(....) {
}
};
typedef service<tcp> service_tcp;
typedef service<udp> service_udp;
请注意，这也是多态的。 它被称为编译时多态。 将策略放入基类将受益于空基类优化。 也就是说，你的基类不需要占用任何空间。 把政策作为一个成员有另一个缺点，就是你总是要把东西委托给那个会员，这会随着时间的推移变得令人讨厌。 Modern C ++ Design这本书深入地描述了这种模式。
理想情况下，传输协议不需要知道任何有关它上面的协议。 但是，如果由于某种原因您必须获得关于它的一些信息，则可以使用crtp模式wiki：
template<template<typename Service> class Transport>
class service : Transport<service> {
// since we derive privately, make the transport layer a friend of us,
// so that it can cast its this pointer down to us.
friend class Transport<service>;
public:
typedef Transport<service> transport_type;
// common code
void do_something() {
this->send(....);
}
};
template<typename Service>
class tcp {
public:
void send(....) {
}
};
template<typename Service>
class udp {
public:
void send(....) {
}
};
typedef service<tcp> service_tcp;
typedef service<udp> service_udp;
您不必将模板放入标题中。 如果你明确地实例化它们，你将获得更快的编译时间，因为需要包含更少的代码。 把它放到service.cpp中：
template class service<tcp>;
template class service<udp>;
现在，使用服务的代码不需要知道服务的模板代码，因为代码已经生成到service.cpp的目标文件中。
我会使用好奇的复仇模板模式，又名五点掌上爆炸Alexandrescu技术：
template <typename Underlying>
class Transmit
{
public:
void send(...)
{
_U.send(...)
};
private:
Underlying _U;
};
class Tcp
{
public:
void send(...) {};
};
class Udp
{
public:
void send(...) {};
};
可能会有更多的模板参数和子类，但你明白了，你也可以使用静态方法。
顺便说一下，模板代码通常更高效，但也更大。
模板不是必需的（尽管可能的解决方案）。 这只是通过模板而不是通过构造函数进行依赖注入。 我个人会通过构造函数来做到这一点。 但是通过模板来做这件事给了你一个更便宜的方法调用的可疑的好处（它不需要是虚拟的）。 但也确实允许更简单的编译器优化。
udp和tcp对象都必须支持相同的接口。
如果你通过继承来实现它们，它们都必须实现一个通用接口（虚拟基类），它通过模板完成，但这不是必须的，但编译器会检查它们是否支持与Service对象相同的方法调用。
正如在原始问题中所提到的，我没有看到部分模板专业化的明确需要（或受益）（在所描述的情况下）。
模板方法
class udp {/*Interface Plop*/static void plop(Message&);};
class tcp {/*Interface Plop*/static void plop(Message&);};
template<typename T>
class Service
{
public:
void doPlop(Message& m) { T::plop(m);}
// Do not actually need to store an object if you make the methods static.
// Alternatively:
public:
void doPlop(Message& m) { protocol.plop(m);}
private:
T protocol;
};
多态版本
class Plop{virtual void plop(Message&) = 0;} // Destruct or omitted for brevity
class upd:public Plop {/*Interface Plop*/void plop(Message&);};
class tcp:public Plop {/*Interface Plop*/void plop(Message&);};
class Service
{
public:
Service(Plop& p):protocol(p) {};
void doPlop(Message& m) { protocol.plop(m);}
private:
Plop& protocol;
};
上一篇: Is partial class template specialization the answer to this design problem?
下一篇: Difference in implementation of malloc and new. Stack implementation?