Understanding C++ polymorphism

Sunday, December 30, 2012 c , c++ 0 Comments

Understanding of / requirements for polymorphism

    Type1 x;
    Type2 y;

    f(x);
    f(y);

C++ mechanisms for polymorphism

Explicit programmer-specified polymorphism

• Preprocessing:

  #define f(X) ((X) += 2)
  // (note: in real code, use a longer uppercase name for a macro!)

• Overloading:

  void f(int& x)    { x += 2; }
  
  void f(double& x) { x += 2; }

• Templates:

  template <typename T>
  void f(T& x) { x += 2; }

• Virtual dispatch:

  struct Base { virtual Base& operator+=(int) = 0; };
  
  struct X : Base
  {
      X(int n) : n_(n) { }
      X& operator+=(int n) { n_ += n; return *this; }
      int n_;
  };
  
  struct Y : Base
  {
      Y(double n) : n_(n) { }
      Y& operator+=(int n) { n_ += n; return *this; }
      double n_;
  };
  
  void f(Base& x) { x += 2; } // run-time polymorphic dispatch

Other related mechanisms

• they're commonly intuitively understood anyway (warranting a "oh, that" reaction),
• they impact the threshold in requiring, and seamlessness in using, the above mechanisms, and
• usefully detailed explanation is a fiddly distraction from more important concepts.

Terminology

Further categorisation

• When is the polymorphic type-specific code selected?
  • Run time means the compiler must generate code for all the types the program might handle while running, and at run-time the correct code is selected (virtual dispatch)
  • Compile time means the choice of type-specific code is made during compilation, and code not used may not even be compiled (every mechanism except virtual dispatch)
• Which types are supported?
  • Ad-hoc meaning you must provide explicit code to support each type (e.g. overloading); you explicitly add support "for this" (as per ad hoc's meaning) type, some other "this", and maybe "that" too ;-).
  • Parametric meaning you can just try to use the function for various parameter types without specifically doing anything to enable its support for them (e.g. templates, macros). An object with functions/operators that act like the template/macro expects is all that template/macro needs to do its job, with the exact type being irrelevant. The "concepts" cut from C++11 help express and enforce such expectations - let's hope they make it into the next Standard.
    • Parametric polymorphism provides duck typing - a concept attributed to James Whitcomb Riley who apparently said "When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.".

      template <typename Duck>
      void do_ducky_stuff(const Duck& x) { x.walk().swim().quack(); }
      
      do_ducky_stuff(Vilified_Cygnet());

"Polymorphic"

polymorphism - providing a single interface to entities of different types. virtual functions provide dynamic (run-time) polymorphism through an interface provided by a base class. Overloaded functions and templates provide static (compile-time) polymorphism. TC++PL 12.2.6, 13.6.1, D&E 2.9.

Discussion

• using unambiguous terminology ("can we make this code reusable for other types?" or "can we use virtual dispatch?" vs "can we make this code polymorphic?"), and/or
• clearly defining your terminology.

• input processed by factory methods and spat out as an heterogeneous object collection handled viaBase*s,
• implementation chosen at runtime based on config files, command line switches, UI settings etc.,
• implementation varied at runtime, such as for a state machine pattern,
• pImpl idiom / managing re-compilation coupling.

• the compile-what's-called aspect of templated classes is preferable to fat interfaces failing at runtime
• SFINAE
• CRTP
• optimisations (many including inlining and dead code elimination, loop unrolling, static stack-based arrays vs heap)
• __FILE__, __LINE__, string literal concatenation and other unique capabilities of macros (which remain evil ;-))

Other mechanisms supporting polymorphism

• compiler-provided overloads
• conversions
• casts/coercion

Mechanisms for mapping to type-specific operations

• type-specific CPU instructions
• a result of the same type.

std::string x;
int y = 0;

x += 'c';
y += 'c';

-1- Standard conversions are implicit conversions defined for built-in types. Clause conv enumerates the full set of such conversions. A standard conversion sequence is a sequence of standard conversions in the following order:

• Zero or one conversion from the following set: lvalue-to-rvalue conversion, array-to-pointer conversion, and function-to-pointer conversion.
• Zero or one conversion from the following set: integral promotions, floating point promotion, integral conversions, floating point conversions, floating-integral conversions, pointer conversions, pointer to member conversions, and boolean conversions.
• Zero or one qualification conversion.

[Note: a standard conversion sequence can be empty, i.e., it can consist of no conversions. ] A standard conversion sequence will be applied to an expression if necessary to convert it to a required destination type.

double a(double x) { return x + 2; }

a(3.14);
a(42);

To be polymorphic, [a()] must be able to operate with values of at least two distinct types (e.g.int and double), finding and executing type-appropriate code.

int a, b;

if (std::cin >> a >> b)
    f(a, b);

f(const std::string& x);
f("hello");  // invokes `std::string::string(const char*)`

Implications of compiler-provided overloads, conversions and coercion

void f()
{
    typedef int Amount;
    Amount x = 13;
    x /= 2;
    std::cout << x * 1.1;
}

void f()                               void f()
{                                      {
    typedef int Amount;                    typedef double Amount;
    Amount x = 13;                         Amount x = 13.0;
    x /= 2;                                x /= 2.0;
    std::cout << double(x) * 1.1;          std::cout << x * 1.1;
}                                      }

template <typename Amount>
void f()
{
    Amount x = 13;
    x /= 2;
    std::cout << x * 1.1;
}

template <typename Amount, typename Policy>
void f()
{
    Amount x = Policy::thirteen;
    x /= static_cast<Amount>(2);
    std::cout << traits<Amount>::to_double(x) * 1.1;
}

• "away" from parameter types
  • from the many data types polymorphic algorithmic code handles
  • to code written for a (potentially lesser) number of (the same or other) types.
• "to" parametric types from values of constant type