我了解使用好奇重复模板模式的静态多态性的机制。我只是不明白这样做有什么好处。
声明的动机是：
为了提高速度，我们牺牲了动态多态性的灵活性。
但是，为什么东西打扰这么复杂，如：
template <class Derived>
class Base
{
public:
void interface()
{
// ...
static_cast<Derived*>(this)->implementation();
// ...
}
};
class Derived : Base<Derived>
{
private:
void implementation();
};
当您可以执行以下操作时：
class Base
{
public:
void interface();
}
class Derived : public Base
{
public:
void interface();
}
我最好的猜测是，代码中没有语义上的差异，而这只是良好的C ++风格的问题。
赫伯·萨特（Herb Sutter）写道Exceptional C++ style: Chapter 18：
最好将虚拟函数设为私有。
当然还要加上详尽的解释，解释为什么这是很好的风格。
在本指南的上下文中，第一个示例是good，因为：
void implementation()示例中的函数可以假装为虚拟的，因为它是在这里执行类的自定义。因此，它应该是私有的。
第二个例子很糟糕，因为：
我们不应该干预公共接口来执行定制。
我的问题是：
我对静态多态性缺少什么？都是关于良好的C ++风格吗？
静态多态和运行时多态是不同的事物，并且实现不同的目标。它们在技术上都是多态的，因为它们根据事物的类型决定执行哪段代码。运行时多态性将绑定某种东西的类型（以及因此运行的代码）推迟到运行时，而静态多态性在编译时已完全解决。
这在每个方面都有利弊。例如，静态多态性可以在编译时检查假设，或者在不会进行其他编译的选项中进行选择。它还向编译器和优化器提供了大量信息，这些信息可以内联，从而完全了解调用和其他信息的目标。但是静态多态性要求编译器可以在每个翻译单元中检查实现，这可能导致二进制代码大小膨胀（模板是花哨的裤子复制粘贴），并且不允许在运行时进行这些确定。
例如，考虑如下内容std::advance：
template<typename Iterator>
void advance(Iterator& it, ptrdiff_t offset)
{
// If it is a random access iterator:
// it += offset;
// If it is a bidirectional iterator:
// for (; offset < 0; ++offset) --it;
// for (; offset > 0; --offset) ++it;
// Otherwise:
// for (; offset > 0; --offset) ++it;
}
没有办法使用运行时多态性来编译它。您必须在编译时做出决定。（通常，您可以通过标签分发来执行此操作）
template<typename Iterator>
void advance_impl(Iterator& it, ptrdiff_t offset, random_access_iterator_tag)
{
// Won't compile for bidirectional iterators!
it += offset;
}
template<typename Iterator>
void advance_impl(Iterator& it, ptrdiff_t offset, bidirectional_iterator_tag)
{
// Works for random access, but slow
for (; offset < 0; ++offset) --it; // Won't compile for forward iterators
for (; offset > 0; --offset) ++it;
}
template<typename Iterator>
void advance_impl(Iterator& it, ptrdiff_t offset, forward_iterator_tag)
{
// Doesn't allow negative indices! But works for forward iterators...
for (; offset > 0; --offset) ++it;
}
template<typename Iterator>
void advance(Iterator& it, ptrdiff_t offset)
{
// Use overloading to select the right one!
advance_impl(it, offset, typename iterator_traits<Iterator>::iterator_category());
}
同样，在某些情况下，您实际上在编译时也不知道类型。考虑：
void DoAndLog(std::ostream& out, int parameter)
{
out << "Logging!";
}
在这里，它对获得DoAndLog的实际ostream实现一无所知-可能无法静态确定将要传入的类型。当然，可以将其转换为模板：
template<typename StreamT>
void DoAndLog(StreamT& out, int parameter)
{
out << "Logging!";
}
但这迫使DoAndLog在头文件中实现，这可能是不切实际的。它还要求StreamT在编译时可见所有可能的实现，而这可能不是正确的-运行时多态可以跨DLL或SO边界起作用（尽管不建议这样做）。
什么时候应该使用？有哪些指导方针？
这就像有人来找您说：“当我写一个句子时，应该使用复合句子还是简单句子？” 也许画家说：“我应该一直使用红色油漆还是蓝色油漆？” 没有正确的答案，这里没有一套可以盲目的遵循的规则。您必须查看每种方法的利弊，并确定哪种方法可以最好地映射到您的特定问题领域。
至于CRTP，大多数用例是允许基类根据派生类提供某些东西。例如Boost的iterator_facade。基类需要具有诸如DerivedClass operator++() { /* Increment and return *this */ }inside之类的东西-根据成员函数签名中的派生指定。
它可以用于多态目的，但是我还没有看到太多。
本文收集自互联网，转载请注明来源。
如有侵权，请联系 [email protected] 删除。
我来说两句