Lecture Notes for Advanced Programming II

25 April 2002 - Handling Missing Member Functions

Outline

• The Missing Function Problem

• Handling Missing Functions

  • Wrapping Whole Classes

  • Wrap Missing Functions

    • Template Specialization

The Missing Function Problem

• Template classes may call member functions on template parameters that the actual classes don't support.

  • And sometimes "Oh well" isn't a good enough answer.

• We need to develop techniques that solve this problem.

• Template functions also have this problem.

Handling Missing Functions

• Add the missing functions to the actual template parameters.

  • For example, adding clone() to the widget class.

  • It's an obvious solution, but

    • You may not have access to the source (wrapping object-only library classes).

    • You may not be allowed to change the source.

    • It may be expensive and risky to change the source.

• Can't change the parameter class? Wrap it.

  • Wrap the whole class.

  • Wrap the missing behaviors.

Wrapping Whole Classes

• If a class is missing functions, wrap it in a class that provides the missing functions.

  • The wrapping class forwards the non-missing functions to the wrapped class.

• For example, given a class without clone()

  $ cat t.cc
  class turtle {
    public:
      turtle(const string &) { }
      void draw(unsigned){ }
    };
  
  int main() {
    handle<turtle> t1h = new turtle("+ [ - f f]");
    handle<turtle> t2h = t1h;
    }
  
  $ g++ -c -ansi -pedantic -Wall t.cc
  t.cc: In copy constructor handle<T>::handle(const handle<T>&) 
        [with T = turtle]:
  t.cc:69: instantiated from here
  t.cc:17: no matching function for call to turtle::clone()
  
  $ 
  

A Whole Class Wrapped

$ cat t.cc
class wrapped_turtle {
  public:
    wrapped_turtle(const string & s) : t(s) { }

    void draw(unsigned i) { t.draw(i); }

    wrapped_turtle * clone(void) {
      return new wrapped_turtle(*this);
      }

  private:
    turtle t;
  };

int main() {
  wrapped_turtle * wt1p = new wrapped_turtle("+ [ - f f]");
  wrapped_turtle * wt2p = wt1p->clone();
  }


$ g++ -o t -ansi -pedantic -Wall t.cc

$ ./t

$ 

Problems With Whole-Class Wrapping

• Whole class wrapping may be difficult to do.

  • It may be difficult to implement the expected functions using the existing functions.

  • It may be difficult to understand the wrapped class.

  • Oh, and don't forget exceptions.

  • Need to track interface changes in the wrapped class.

• Whole class wrapping may be expensive to do.

  • Many functions to forward to the wrapped class.

  • Another level of indirection adds more overhead.

Wrap Missing Functions

• Rather than wrap the whole class, wrap the missing functions as template functions.

  • This moves function resolution out of the class and into a separate template function.

  • Function resolution can then be controlled individually using template specialization.

Template Specialization

• A template function may be redefined with some or all of the template parameters filled in.

  • Copy the definition and replace in the template parameters with types.

  // definition 1
  template < typename T1, typename T1 >
  void f(T1 a1, T2 a2) { 
    T1 v1;
    }
  
  // definition 2
  template < >
  void f(int * a1,  pair<double, double> a2) {
    int * v1;
    }
  

  Here T1 is replaced by int * and T2 is replaced by pair<double,double>.

• These substitutions appear throughout the function definition.

Specialized Template Matching

• The compiler uses the most specific template-function match when there is more than one match.

• Count the number of non-template, exact-type matches; the higher the number, the more specific the match.

  • It's much more complicated than this.

• For example, given f(&i, make_pair(1.0, 3.14))

  • Definition 1 matches with no exact type matches.

  • Definition 2 matches with 2 exact type matches.

  • Definition 2 is more specific.

• This process is known as template specialization.

• Template classes may be specialized too.

Function Wrapping, Step 1

• Create a template function for each missing function in the wrapper class.

  template < typename T >
  T * clone(const T * tp) {
    return tp->clone();
    }
  

• Replace the class-specific member function calls with a call to the template function.

  Replace

  handle < template T >
  handle<T>::handle(const handle & th) 
    : tp(th.tp ? th.tp->clone() : 0) { }
  

  with

  handle < template T >
  handle<T>::handle(const handle & th) 
    : tp(th.tp ? clone(th.tp) : 0) { }
  

• The choice of clone() instance has been moved outside the handle class.

Function Wrapping, Step 2

• Specialize the template function for classes not supporting clone().

  template < >
  turtle * clone(const turtle * tp) {
    return new turtle(*tp);
    }
  

• Specialize the template function for each class not supporting the function.

• That's it.

  
  $ cat t.cc
  class turtle {
    public:
      turtle(const string &) { }
      void draw(unsigned){ }
    };
  
  int main() {
    handle<turtle> t1h = new turtle("+ [ - f f]");
    handle<turtle> t2h = t1h;
    }
  
  $ g++ -o t -ansi -pedantic -Wall t.cc
  
  $ ./t
  
  $ 
  
  

  See the complete code.

Points to Remember

• Template classes and functions may be called with template parameters that don't support all required functions.

  • And sometimes you can't ignore it.

• Add the missing functions to the template parameter class.

• If you can't change the class, use wrapping instead.

  • You can't have too many levels of indirection.

• Wrap the parameter class to supply the missing functions.

  • Effective, but potentially expensive and hard.

• Wrap the missing functions and use template specialization.

• Template specialization is the basis for many advanced C++ design and programming techniques.

This page last modified on 28 April 2002.