Advanced Programming II CS 509 Class Notes

Lecture Notes for Advanced Programming II

24 April 2003 - 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.
```
template < typename T >
class handle {

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

  };
```
T has to support the clone() function.
- 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.
```
template < typename T >
ostream & 
operator << (ostream & os, const T & t) {
  return os << t;
  }
```
  T has to support <<.

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("+[-ff]");
  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 function for 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("+[-ff]"),
    * 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.

Whole-Class Dependencies

Templates introduce a direct dependency between classes.
Break the dependency with indirection, the programmer's friend.

Wrap Missing Functions

Rather than wrap the whole class, wrap the missing functions as template functions.
- Move function resolution out of the class and into a separate template function.
- Function resolution can then be controlled individually using template specialization.
If C::clone() exists, instantiate Handle.
- cloner() is created via template-function magic.
If C::clone() doesn't exist, create a special cloner() to deal with it.
- Dig that crazy function template syntax, man.

Template Specialization

That crazy function template syntax is 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 T2 >
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 definition 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 ? cloner(th.tp) : 0) { }

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

Function Wrapping, Step 2

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){ }
  };

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

int main() {
  handle<turtle> t1h = new turtle("+[-ff]");
  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 22 April 2003.