C++中静态多态背后的动机是什么？

Question

我理解了使用奇怪的重复模板模式的静态多态性的机制。我只是不明白这有什么好处。

公开的动机是：

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();
}

更喜欢使虚函数私有。

当然，还有一个彻底的解释，为什么这是好的风格。

在本指南的上下文中，第一个示例是好的，因为：

1. 关于静态多态性，我遗漏了什么？这一切都是关于好的C++风格吗？
2. 应该什么时候使用？有哪些指导方针？

Answer 1

关于静态多态性，我遗漏了什么？这一切都是关于好的C++风格吗？

静态多态性和运行时多态性是不同的东西，完成不同的目标。它们在技术上都是多态性，因为它们根据某样东西的类型来决定执行哪段代码。运行时多态性将绑定某物（以及运行的代码）的类型推迟到运行时，而静态多态在编译时完全解析。

这导致了每一个利弊。例如，静态多态性可以在编译时检查假设，或者在否则不会编译的选项中进行选择。它还为编译器和优化器提供了大量的信息，这些信息可以内联，完全了解调用的目标和其他信息。但是静态多态性要求实现可供编译器在每个翻译单元中检查，可能导致二进制代码大小膨胀（模板是花哨的裤子复制粘贴），并且不允许这些确定在运行时发生。

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或其他边界工作（尽管不建议这样做）。

应该什么时候使用？一些指导方针是什么？

它可以用于多态目的，但我还没有见过太多。