Template method: UML class diagram.
Template Method in LePUS3 (legend)

In software engineering, the template method pattern is a design pattern. It is a so-called behavioral pattern, and is unrelated to C++ templates.

Contents

Introduction

In a template pattern, the model (data such as XML, or a set of APIs) has no inherent knowledge of how it would be utilized. The actual algorithm is delegated to the views, i.e. templates. Different templates could be applied to the same set of data or APIs and produce different results. Thus, it is a subset of model-view-controller patterns without the controller. The pattern does not have to be limited to the object-oriented programming. For example, different XSLT templates could render the same XML data and produce different outputs. C++ templates also make it possible to code the algorithms (i.e. views) without having to use abstract classes or interfaces.

In object-oriented programming, first a class is created that provides the basic steps of an algorithm design. These steps are implemented using abstract methods. Later on, subclasses change the abstract methods to implement real actions. Thus the general algorithm is saved in one place but the concrete steps may be changed by the subclasses.

The template method thus manages the larger picture of task semantics, and more refined implementation details of selection and sequence of methods. This larger picture calls abstract and non-abstract methods for the task at hand. The non-abstract methods are completely controlled by the Template method. The expressive power and degrees of freedom occur in abstract methods that may be implemented in subclasses. Some or all of the abstract methods can be specialized in the subclass, the abstract method is the smallest unit of granularity, allowing the writer of the subclass to provide particular behavior with minimal modifications to the larger semantics. In contrast the template method need not be changed and is not an abstract operation and thus may guarantee required steps before and after the abstract operations. Thus the template method is invoked and as a consequence the subordinate non-abstract methods and abstract methods are called in the correct sequence.

The template method occurs frequently, at least in its simplest case, where a method calls only one abstract method, with object oriented languages. If a software writer uses a polymorphic method at all, this design pattern may be a rather natural consequence. This is because a method calling an abstract or polymorphic function is simply the reason for being of the abstract or polymorphic method. The template method may be used to add immediate present value to the software or with a vision to enhancements in the future.

The template method is strongly related to the NVI (Non-Virtual Interface) pattern. The NVI pattern recognizes the benefits of a non-abstract method invoking the subordinate abstract methods. This level of indirection allows for pre and post operations relative to the abstract operations both immediately and with future unforeseen changes. The NVI pattern can be deployed with very little software production and runtime cost. Many commercial frameworks employ the NVI pattern.

Usage

The template method is used to:

  • let subclasses implement (through method overriding) behaviour that can vary
  • avoid duplication in the code: you look for the general code in the algorithm, and implement the variants in the subclasses
  • control at what point(s) subclassing is allowed.

The control structure (inversion of control) that is the result of the application of a template pattern is often referred to as the Hollywood Principle: "Don't call us, we'll call you." Using this principle, the template method in a parent class controls the overall process by calling subclass methods as required. This is shown in the following example:

Example (in Java)

/**
 * An abstract class that is common to several games in
 * which players play against the others, but only one is
 * playing at a given time.
 */
 
abstract class Game {
 
    private int playersCount;
 
    abstract void initializeGame();
 
    abstract void makePlay(int player);
 
    abstract boolean endOfGame();
 
    abstract void printWinner();
 
    /* A template method : */
    final void playOneGame(int playersCount) {
        this.playersCount = playersCount;
        initializeGame();
        int j = 0;
        while (!endOfGame()) {
            makePlay(j);
            j = (j + 1) % playersCount;
        }
        printWinner();
    }
}
 
//Now we can extend this class in order to implement actual games:
 
class Monopoly extends Game {
 
    /* Implementation of necessary concrete methods */
 
    void initializeGame() {
        // ...
    }
 
    void makePlay(int player) {
        // ...
    }
 
    boolean endOfGame() {
        // ...
    }
 
    void printWinner() {
        // ...
    }
 
    /* Specific declarations for the Monopoly game. */
 
    // ...
 
}
 
class Chess extends Game {
 
    /* Implementation of necessary concrete methods */
 
    void initializeGame() {
        // ...
    }
 
    void makePlay(int player) {
        // ...
    }
 
    boolean endOfGame() {
        // ...
    }
 
    void printWinner() {
        // ...
    }
 
    /* Specific declarations for the chess game. */
 
    // ...
 
}

Example (in C++)

In C++ it is not necessary to use inheritance and abstract (pure virtual) methods. For example, the Standard Library (STL) has been conceived using another paradigm: the templatization. Here is an example using the "traits" feature on which the STL relies.

  /**
  * The use of traits class to implement the Template Method Pattern
  * Note: this method has been heavily used in the Standard Library, the example below is just a bit simpler
  */
 
  "example.h"
 
  template <class T>
  class example_traits
  {
  public:
    /**
    * Typedefs
    */
    typedef T value;
    typedef const T const_value;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef T& reference;
    typedef const T& const_reference;
 
    /**
    * Methods
    */
    static pointer Clone(const_pointer iClonee)
    {
      return new T(*iClonee);
    } // Clone
  }; // class example_traits
 
  template <class T, class U = example_traits<T> >
  class example
  {
  public:
    /**
    * Typedefs
    */
    typedef typename U::value value;
    typedef typename U::const_value const_value;
    typedef typename U::pointer pointer;
    typedef typename U::const_pointer const_pointer;
    typedef typename U::reference reference;
    typedef typename U::const_reference const_reference
 
    /**
    * Default constructors and such are not shown
    */
    // We just add a constructor that takes a pointer to the object to initialize its attribute
    example(pointer object); // definition not shown
 
    /**
    * Methods
    */
    example clone()
    {
 
      // Some code to log that we clone the object
 
      pointer aClone = U::Clone(object_); // actual cloning
 
      // Some code to clean up the object or change its state if we want
 
      return example(aClone);
    } // clone
 
  private:
    /**
    * object
    */
    pointer object_;
  }; // example
 
  "myClass.h"
 
  class MyClass
  {
  public:
    MyClass* duplicateMe() const; // method to obtain a clone
    /** stuff **/
  }; // MyClass
 
  /**
  * Two different methods
  */
 
  // specialization of the traits class
  template <>
  class example_traits<MyClass> 
  {
    /**
    * Typedefs
    */
    typedef MyClass value;
    typedef const MyClass const_value;
    typedef MyClass* pointer;
    typedef const MyClass* const_pointer;
    typedef MyClass& reference;
    typedef const MyClass& const_reference;
 
    /**
    * Methods
    */
    static pointer Clone(const_pointer iClonee)
    {
      return iClonee->duplicateMe(); // This line is changed to use the clone method of MyClass
    } // Clone
  }; // example<MyClass>
 
  // creation of a brand new class
  class MyClassExampleTraits
  {
    /**
    * Typedefs
    */
    typedef MyClass value;
    typedef const MyClass const_value;
    typedef MyClass* pointer;
    typedef const MyClass* const_pointer;
    typedef MyClass& reference;
    typedef const MyClass& const_reference;
 
    /**
    * Methods
    */
    static pointer Clone(const_pointer iClonee)
    {
      return iClonee->duplicateMe(); // This line is changed to use the clone method of MyClass
    } // Clone
  }; // MyClassExampleTraits
 
 
  "main.cpp"
 
  int main()
  {
    // Using the first method
    example<MyClass> aFirstExample; // the default parameter is set to example_traits<MyClass> which is our specialization
    example<MyClass> aFirstClone = aFirstExample->clone();
 
    // using the first method, but precising the second parameter
    example<MyClass, example_traits<MyClass> > aSecondExample;
    aFirstClone = aSecondExample->clone(); // Note that the type of aFirstClone is compatible
                                           // in fact it is exactly the same type (we have just explicitely precised the argument)
 
    // Using the second method
    example<MyClass, MyClassExampleTraits> aThirdExample; // the traits class is a user defined one
    example<MyClass, MyClassExampleTraits> aSecondClone = aThirdExample->clone();
 
    return 0;
  } // main

See also

External links

v • d • e
Design patterns in the book Design Patterns
Creational
Structural
Behavioral
Chain of responsibility · Command · Interpreter · Iterator · Mediator · Memento · Observer · State · Strategy · Template method · Visitor
Retrieved from "http://en.wikipedia.org/wiki/Template_method_pattern"

No comments have been added.



Your name:

City:

Country:

Your comments:

Security check *
(Please enter the number into adjoining box)