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

Question

我使用Curiously Recurring模板模式了解静态多态的机制.我只是不明白它有什么好处.

声明的动机是:

我们牺牲了动态多态性的一些灵活性来提高速度.

但是,为什么东西打扰这么复杂,如:

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()示例中的函数可以假装是虚拟的,因为它是在这里执行类的自定义.因此它应该是私人的.

第二个例子很糟糕,因为:

我们不应该干涉公共接口来执行自定义.

我的问题是:

1. 我对静态多态性有什么看法？这是关于良好的C++风格吗？
2. 什么时候应该使用？有什么指导方针？

Answer 1

我对静态多态性有什么看法？这是关于良好的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 */ }内部的东西- 在成员函数签名中派生的条件中指定.

它可以用于多态目的,但我没有看到太多这些.