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

Question

我了解 static polymorphism 的机制使用 Curiously Recurring Template Pattern .我只是不明白它有什么好处。

声明的动机是:

We sacrifice some flexibility of dynamic polymorphism for speed.

但为什么要为如此复杂之类的事情烦恼:

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 写道:

Prefer to make virtual functions private.

当然伴随着详尽的解释为什么这是好风格。

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

示例中的 void implementation() 函数可以假装是虚拟的，因为它在这里执行类的自定义。因此它应该是私有(private)的。

第二个例子不好，因为:

我们不应该干预公共(public)界面来执行定制。

我的问题是:

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

Answer 1

What am I missing about static polymorphism? Is it all about good C++ style?

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

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

例如，考虑类似 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 边界工作(尽管不推荐这样做)。

---

When should it be used? What are some guidelines?

这就像有人来找你说“当我在写一个句子时，我应该使用复合句还是简单句”？或者也许是一位画家说“我应该总是使用红色油漆还是蓝色油漆？”没有正确的答案，也没有一套可以在这里盲目遵循的规则。您必须查看每种方法的优缺点，并决定哪种方法最适合您的特定问题域。

---

对于 CRTP，大多数用例是允许基类提供派生类的东西；例如Boost 的 iterator_facade。基类需要有类似 DerivedClass operator++() {/* Increment and return *this */} 之类的东西——在成员函数 signatures 中指定派生.

它可以用于多态目的，但我没有看到太多。