subsections:


  public class envelope { 
   envelope  

  
  public envelope() { }
  
  public void message() {
  	System.out.println("hello ... ");
  	}
  };
slide: Hello World
slide: Envelope/Letter Factory
 

  public class envelope { 
   envelope  

  letter impl;
  public envelope() {
  	impl = new letter();
  	}
  
  public void message() {
  	impl.message();
  	}
  };
  


  public class letter { 
   letter  

  
  public letter() { }
  
  public void message() {
  	System.out.println("Message in a letter");
  	}
  };
slide: Envelope/Letter
 

  public class factory { 
   factory  

  
  public factory() { }
  
  letter letter() { return new letter(); }
  envelope envelope() { return new envelope(); }
  };
  

  public class envelope { 
   envelope  

  letter impl;
  public envelope() {
  	factory f = new factory();
  	impl = f.letter();   // obtained from factory
  	}
  
  public void message() {
  	impl.message();
  	}
  };
slide: Factory
 

  public class singleton extends letter {  
   singleton  

  
  static int number = 0;
  
  protected singleton() { }
  
  
  static letter instance() {
  	if (number==0) {
  		theletter = new letter();
  		number = 1;
  		}
  	return theletter;
  	}
  
  public void message() {
  	System.out.println("Message in a letter");
  	}
  
  static letter theletter;
  };
slide: Singleton letter

Overloading

print 



  extern void print(int);
  extern void print(float);

Generic class -- templates

list< T > 


  template< class T > class list { ... }
  list* alist;

Polymorphism by inheritance

shape 



  class shape { ... };
  class circle : public shape { ... } 
  shape* s = new circle;
slide: Polymorphic type declarations

Standard Template Library

STL


slide: The Standard Template Library
 


  double sqrt( double arg ) { 
   sqrt  

  require ( arg >= 0 );
  double r=arg, x=1, eps=0.0001;
  while( fabs(r - x) > eps ) {
     r=x; x=r-((r*r-arg)/(2*r));
     }
  promise ( r - arg * arg <= eps );
  return r;
  }
slide: Using assertions in C++
 

  class counter { 
   counter  

  public:
  counter(int n = 0) : _n(n) {
  	require( n >= 0 );
  	promise( invariant() ); // check initial state
  	}
  
  virtual void operator++() {
  	require( true ); // empty pre-condition
  	hold(); // save the previous state
  	_n += 1;
  	promise( _n == old_n + 1 && invariant() );
  	}
  
  
  int value() const { return _n; }  // no side effects
  
  virtual bool invariant() { return value() >= 0; }
  
  protected:
  int _n;
  int old_n;
  virtual void hold() { old_n = n; }
  };
slide: The counter contract
 

  class bounded : public counter { 
   bounded  

  public:
  bounded(int b = MAXINT) : counter(0), max(b) {}
  void operator++() {
  	require( value() < max ); // to prevent overflow
  	counter::operator++();
  	}
  
  bool invariant() {
  	return value() <= max && counter::invariant();
  	}
  
  private:
  int max;
  };
slide: Refining the counter contract

Canonical class in C++

Abstract data types must be indistinguishable from built-in types

slide: Canonical class