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

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

声明的动机是:



但是为什么要麻烦一些复杂的事情呢:

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



当然，还要详细解释为什么这是好风格。

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

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

第二个示例是 bad ，因为:

我们不应干预公共(public)接口(interface)来执行定制。

我的问题是:

我对静态多态性缺少什么？都是关于良好的C++风格吗？

什么时候应该使用？有哪些指导方针？

最佳答案

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

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

例如，考虑类似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边界起作用(尽管不建议这样做)。



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

至于CRTP，大多数用例是允许基类根据派生类提供某些东西。例如Boost的iterator_facade。基类需要在内部包含DerivedClass operator++() { /* Increment and return *this */ }之类的东西-根据成员函数签名中的派生指定。

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

关于c++ - C++中静态多态性背后的动机是什么？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/19062733/