The pattern is very simple: inheriting from a template parameter. It is gaining in popularity, and I see it popping up more and more often in other people's code. One way I use the pattern is to define contract classes, which verify the contractual obligations of another class ( plug: as described in my article on Programming with Contracts in C++ to appear in a future edition of Doctor Dobbs Journal ), Another way I use the pattern, is to define extension classes which introduce operators and helper functions which can be defined in terms of a core set of

Some issues arise in C++ and Java due to constructors not being inherited, but in C++ at least -- and probably Java, though I don't know the syntax -- this can be worked around by parameterizing the constructor. This problem though doesn't occur in Heron because Heron classes automatically inherit constructors.

To work around the problem in C++ I currently use a parameterized constructors:

class Base {
public:
  Base(int x) {
    printf("initializing constructor with int\n");
  }
  Base(char x) {
    printf("initializing constructor with char\n");
  }
};

template
class Wrapper : public Super_T {
public:
  template 
  Wrapper(const T& x) : Super_T(x) {  }
};

int main(int argc, char* argv[])
{
  Wrapper a(5);
  Wrapper b('a');
  getchar();  
};