C++ Tutorial/template/template inheritance

virtual template inheritance

<source lang="cpp">/* The following code example is taken from the book

* "C++ Templates - The Complete Guide"
* by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002
*
* (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002.
* Permission to copy, use, modify, sell and distribute this software
* is granted provided this copyright notice appears in all copies.
* This software is provided "as is" without express or implied
* warranty, and with no claim as to its suitability for any purpose.
*/

1. include <iostream>

// PolicySelector<A,B,C,D> creates A,B,C,D as base classes // - Discriminator<> allows having even the same base class more than once template <typename Base, int D> class Discriminator : public Base { }; template <typename Setter1, typename Setter2,

         typename Setter3, typename Setter4>

class PolicySelector : public Discriminator<Setter1,1>,

                      public Discriminator<Setter2,2>,
                      public Discriminator<Setter3,3>,
                      public Discriminator<Setter4,4> {

};

// default policies class DefaultPolicy1 {}; class DefaultPolicy2 {}; class DefaultPolicy3 {

 public:
   static void doPrint() {
       std::cout << "DefaultPolicy3::doPrint()\n";
   }

}; class DefaultPolicy4 {};

// define default policies as P1, P2, P3, P4 class DefaultPolicies {

 public:
   typedef DefaultPolicy1 P1;
   typedef DefaultPolicy2 P2;
   typedef DefaultPolicy3 P3;
   typedef DefaultPolicy4 P4;

};

// class to define a usage of the default policy values // - avoids ambiguities if we derive from DefaultPolicies more than once class DefaultPolicyArgs : virtual public DefaultPolicies { };

// class templates to override the default policy values template <typename Policy> class Policy1_is : virtual public DefaultPolicies {

 public:
   typedef Policy P1;  // overriding typedef

}; template <typename Policy> class Policy2_is : virtual public DefaultPolicies {

 public:
   typedef Policy P2;  // overriding typedef

}; template <typename Policy> class Policy3_is : virtual public DefaultPolicies {

 public:
   typedef Policy P3;  // overriding typedef

}; template <typename Policy> class Policy4_is : virtual public DefaultPolicies {

 public:
   typedef Policy P4;  // overriding typedef

};

// create class template with four policies and default values template <typename PolicySetter1 = DefaultPolicyArgs,

         typename PolicySetter2 = DefaultPolicyArgs,
         typename PolicySetter3 = DefaultPolicyArgs,
         typename PolicySetter4 = DefaultPolicyArgs>

class BreadSlicer {

   typedef PolicySelector<PolicySetter1, PolicySetter2,
                          PolicySetter3, PolicySetter4>
           Policies;
   // use Policies::P1, Policies::P2, //... to refer to the various policies.
 public:
   void print () {
       Policies::P3::doPrint();
   }
   //...

};

// define a custom policy class CustomPolicy {

 public:
   static void doPrint() {
       std::cout << "CustomPolicy::doPrint()\n";
   }

}; int main() {

   BreadSlicer<> bc1;
   bc1.print();
   BreadSlicer<Policy3_is<CustomPolicy> > bc2;
   bc2.print();

}</source>

DefaultPolicy3::doPrint()
CustomPolicy::doPrint()