Question

我使用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写道：

喜欢将虚拟功能设为私有。

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

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

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

第二个例子是坏，因为：

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

我的问题是：

我对静态多态性缺少什么？这是关于良好的C ++风格吗？
什么时候应该使用？有哪些指导原则？

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，大多数用例都是允许基类根据派生类提供某些东西;例如提升iterator_facade。基类需要包含内部DerivedClass operator++() { /* Increment and return *this */ }之类的东西 - 在成员函数签名中派生的指定。

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

Answer 2

您提供的链接提到了迭代器作为静态多态的示例。 STL迭代器也表现出这种模式。让我们看一个例子，并考虑为什么这些类型的作者决定这种模式是合适的：

#include <vector>
#include <iostream>
using namespace std;
void print_ints( vector<int> const& some_ints )
{
    for( vector<int>::const_iterator i = some_ints.begin(), end = some_ints.end(); i != end; ++i )
    {
        cout << *i;
    }
}

现在，我们将如何实现int vector<int>::const_iterator::operator*() const;我们可以使用多重性吗？好吧，不。我们的虚函数的签名是什么？ void const* operator*() const？那没用！该类型已被删除（从int降级为void *）。相反，奇怪的重复模板模式介入以帮助我们生成迭代器类型。下面是我们实现上述所需的迭代器类的粗略近似值：

template<typename T>
class const_iterator_base
{
public:
    const_iterator_base():{}

    T::contained_type const& operator*() const { return Ptr(); }
    T::contained_type const& operator->() const { return Ptr(); }
    // increment, decrement, etc, can be implemented and forwarded to T
    // ....
private:
    T::contained_type const* Ptr() const { return static_cast<T>(this)->Ptr(); }
};

传统的动态多态无法提供上述实现！

一个相关且重要的术语是参数多态。这允许您在python中实现类似的API，您可以使用C ++中奇怪的重复模板模式。希望这有用！

我认为值得考虑所有这些复杂性的来源，以及为什么像Java和C＃这样的语言主要试图避免它：类型擦除！在c ++中，没有任何有用的包含Object类型的有用信息。相反，我们有void*，一旦你有void*，你就什么都没有！如果你的接口衰减到void*，恢复的唯一方法就是做出危险的假设或保留额外的类型信息。

Answer 3

虽然可能存在静态多态性有用的情况（其他答案列出了一些），但我通常认为这是一件坏事。为什么？因为实际上不能再使用指向基类的指针，所以总是必须提供一个模板参数来提供确切的派生类型。在这种情况下，您也可以直接使用派生类型。而且，坦率地说，静态多态性不是面向对象的。

静态和动态多态之间的运行时差异恰恰是两个指针解除引用（如果编译器真的在基类中内联调度方法，如果它由于某种原因没有，则静态多态性较慢）。这并不贵，特别是因为第二次查找实际上总是会打到缓存。总而言之，那些查找通常比函数调用本身便宜，并且当然有必要获得动态多态性提供的真正灵活性。

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

3 个答案: