迹忆客 专注技术分享

静态多态性主要可以在 C++ 上下文中解释。 本教程将教您重要性、有用性以及如何在 C++ 中实现静态多态性。

C++ 中的 std:sort 函数是静态多态的，因为它依赖于对象提供的接口（行为类似于迭代的对象）。

此外，可以在编译时确定接口下提供的迭代（对象）的确切行为。

了解奇怪的重复模板模式以了解 C++ 中静态多态性的机制

实现静态多态性是一种很好的编码风格； 为此，您需要通过 CRTP 了解其机制。 事实上，为了速度（通过静态多态性），您必须牺牲 C++ 程序的一些灵活性。

它显示了技术多态性行为，实现了与其他类型不同的目标，并根据某物的类型决定执行哪一段代码并确定优先级。

此外，它需要可能导致二进制代码大小膨胀的实现，并在每个翻译单元中进行检查，以便编译器可以理解该实现。

#include <iostream>

template <class Self>
struct Primary
{
  Self& self() { return static_cast<Self&>(*this); }

  // an algorithm to perform some function
  int basic_function(int x)
  {
    self().prologue();
    if (x > 42)
      x = self().downsize(x);
    x = self().crunch(x);
    self().epilogue();
    return x;
  }

  void prologue()
  {}

  int downsize(int x)
  { return x % 42; }

  int crunch(int x)
  { return -x; }

  void epilogue()
  {}
};

struct secondary_Derived : Primary<secondary_Derived>
{
  int downsize(int x)
  {
    while (x > 42) x /= 2;
    return x;
  }

  void epilogue()
  { std::cout << "CRTP__ \n" << "Process complete! \n"; }
};

int main()
{
    secondary_Derived obj_Dri;
    std::cout << obj_Dri.basic_function(420);
}

输出:

CRTP__
Process complete!
-26

CRTP 允许基类根据派生类提供信息或数据，并且其大多数用例表示相同； 例如，Boost 的 iterator_facade。

签名是 CRTP 的成员函数，DerivedClass operator++() {/* Return *this afterincrementation */} 之类的东西都是从这个成员函数派生的。

如果您的 C++ 代码需要多态输出行为，则应派生自 std::sstream、std::fstream 和 std::cout（即使其类型未指定）是多态性并派生自 ostream。 由于 CRTP 是 F 结合定量的一种形式，因此被称为 F 结合多态性。

它可以实现虚拟功能，而无需牺牲灵活性，有时称为模拟动态绑定。

Windows STL 和 WTL 库使用此函数，Barton-Nackman 技巧是静态多态性的类似使用，有时称为受限模板扩展，其中常见功能可以放置在基类中，从而最大限度地减少 C++ 代码冗余。

了解基于策略的设计以了解 C++ 中静态机制的用处

它是在 C++ 中实现静态多态性的极其强大的技术之一。 在现代 C++ 设计中，基于策略的类或基于策略的编程是一种基于称为策略的 C++ 习惯用法的设计方法。

策略模式的编译时变体增加了模块化并突出了正交设计决策。

它在相对较低的水平上定义了各个类的行为，代表了创新，而从可互换模块中组装软件组件远不是一个新概念。

#include <iostream>
#include <windows.h>

struct color_code
{
  void pri_color()
  {
    this -> reveal_colorCode();
  }

  void reveal_colorCode()
  {
    std::cout << "The color code is revealed!" << std::endl;
  }

};

struct banner_code
{
  void pri_color()
  {
    std::cout << "The banner code is revealed to the officials!" << std::endl;
  }
};

template <class code_type>

class Info : public code_type
{

public:
  void code_implementation()
  {
      code_type::pri_color();
  }
};

int main()
{
  Info<color_code> lordcommander;
  lordcommander.code_implementation();

  Info<banner_code> kingslayer;
  kingslayer.code_implementation();
  return 0;
}

输出:

The color code is revealed!
The banner code is revealed to the officials!

它使您能够重新解释编译时的模式（例如，模板方法模式），以便主类具有骨架算法，该算法调用各个策略的适当函数（在自定义点）。

一般来说，这些设计不需要继承，并且它们的大多数功能反映了静态多态行为。

在 C++ 中使用早期绑定、重载或参数多态性实现静态多态性

它的对象方法在编译时调用，通常使用运算符和函数重载来实现。

方法重载是一种编译时多态性，其中多个方法可以具有相同的名称但不同的参数列表和类型。

它提高了性能，因为它的方法在编译时是已知的，这使得执行速度更快，但导致实现解决方案的灵活性降低。

函数重载和运算符重载反映了静态多态性行为，因为它提供了重载工具来扩展代码的功能。

#include <iostream>
#include <windows.h>

// parametric polymorphism
template <class T>

T max(T a, T b)
{
    return a > b ? a : b;
}

// early binding | static binding
class Base
{
public:
    void show() { std::cout<<"\nIn Base \n"; }
};

class Derived: public Base
{
public:
    void show() { std::cout<<"In Derived \n"; }
};

// override
void swap(int* a, int* b)
{

};

void swap(double* a, double *b)
{

};

int main()
{
   int x = 10, y = 20;
   double a = 1.2, b = 3.4;

   // overloading | as static polymorphism
   swap(&x, &y);            // swap(int,int)
   swap(&a, &b);            // swap(double, double)

   // parametric polymorphism | as static polymorphism
   std::cout << ::max(9, 5) << std::endl;

   std::string foo("kingslayer"), bar("widow'swale");
   std::cout << ::max(foo, bar) << std::endl;

   // early binding or static binding | as static polymorphism
   Base *bp = new Derived;
   bp->show();

   return 0;
}

输出:

9
widow'swale

In Base

UML 图不能直接描述多态性是如何处理的，但至少可以部分地静态或动态地实现（取决于 OOP 模型的静态多态性依赖性）。

当静态多态性的行为发生在编译时而不是运行时时，可以消除间接调用对性能的影响。

最重要的是，性能是静态多态性的主要优势，PBD（基于策略的设计）和 CRTP（奇怪的重复模板模式）是其完美的例子，凸显了该技术的强大功能。

它为编译器和优化器提供了大量至关重要的信息，可以在编译时检查假设，并可以在程序执行的关键选项中进行选择。