• C++ Patterns
• Container Class Patterns
• p-Containers
• a-Containers
• Iterator Patterns
• Random Access Iterators
• Bidirectional Iterators
• Forward Iterators
• Adaptor Patterns
  • Adaptor Classes
  • Adaptor Iterators
• Generic Algorithm Patterns

C++ Patterns

// default constructor for class X
X::X();

// destructor for class X
X::~X();

// copy constructor for class X
X::X(const X&);

// assignment operator for class X
X& X::operator = (const X&);

// assignment operator implementation
X& X::operator = (const X& x2)
{
  if (this != &x2)    // avoid self-assignment
  {
    // clear and clone
  }
  return *this;
}

// assignment operator use
x1 = x2;              // operator syntax
x1.operator = (x2);   // operator function syntax

// I/O operators for class X (non-member)
stream& operator << (stream&, const X&);
stream& operator >> (stream&, X&);

// member operators for class X
return_type X::operator operator_name (operator_parameters);

// non-member operators
return_type operator operator_name (operator_parameters);

// member functions for class X
return_type X::method_name (method_parameters);

// non-member functions
return_type function_name (function_parameters);

Container Class Patterns

// scope is container class X < typename T >
// terminology support
typedef T             value_type;
typedef XIterator<T>  Iterator;

// iterator support
Iterator Begin  () const;
Iterator End    () const;
Iterator rBegin () const;
Iterator rEnd   () const;

// protocol support
void         Clear ();
bool         Empty () const;
unsigned int Size  () const;

// protocol support, p-containers
bool         PushFront  (const T&);
bool         PushBack   (const T&);
bool         PopFront   ();
bool         PopBack    ();
bool         Insert     (Iterator& , const T& );
Iterator     Insert     (const T& );
bool         Remove     (Iterator& );
unsigned int Remove     (const T& );
T*           Front      () const;
T*           Back       () const;

// protocol support, a-containers
bool         Insert     (Iterator& , const T& );
Iterator     Insert     (const T& );
bool         Remove     (Iterator& );
unsigned int Remove     (const T& );
Iterator     LowerBound (const T& ) const;
Iterator     UpperBound (const T& ) const;

Iterator Patterns

// scope is XIterator < typename T > (iterator for container class X<T>)
// terminology support
typedef T value_type;

// initializers
void  Initialize   (const X<T>& L);  // forward
void  rInitialize  (const X<T>& L);  // bidirectional

// information/access
T*  Retrieve       () const; // Return ptr to current Tval 
int Valid          () const; // cursor is valid element

// operators
int            operator == (const XIterator& I2) const;
int            operator != (const XIterator& I2) const;
T&             operator *  () const; // Return reference to current Tval
XIterator<T>&  operator =  (const XIterator <T> & I);
XIterator<T>&  operator ++ ();    // prefix
XIterator<T>   operator ++ (int); // postfix

// additional operators, bidirectional iterators
XIterator<T>&  operator -- ();    // prefix
XIterator<T>   operator -- (int); // postfix

// additional operators, random-access iterators
T& operator [] (unsigned int i) const; // Return reference to Tval at index i

long          operator -  (const XIterator<T> & I2) const;

XIterator<T>& operator += (long n);
XIterator<T>& operator -= (long n);
XIterator<T>  operator +  (long n) const;

XIterator<T>& operator += (int  n);
XIterator<T>& operator -= (int  n);
XIterator<T>  operator +  (int  n) const;

XIterator<T>& operator += (unsigned long n);
XIterator<T>& operator -= (unsigned long n);
XIterator<T>  operator +  (unsigned long n) const;

XIterator<T>& operator += (unsigned int  n);
XIterator<T>& operator -= (unsigned int  n);
XIterator<T>  operator +  (unsigned int  n) const;

// iterator implementation patterns
// scope is global (in some namespace) 

// prefix increment:
template < typename T >
XIterator<T>& XIterator<T>::operator ++ ()
{
  // some action that moves this iterator to the next element
  return *this; // return *this as reference
}

// postfix increment:
template < typename T >
XIterator<T> XIterator<T>::operator ++ (int)
{
  XIterator<T> I = *this; // copy made prior to incrementation
  operator ++();
  return I;     // return copy as value
}

Adaptor Patterns

Generic Algorithm Patterns