• Canonical: "conforming to well-established rules or patterns"
• Having a canonical form provides a concrete set of guidelines for creating a robust, fully-featured, properly functioning class
  • It's not that there won;t be any errors, but many of the well-known pitfalls are addressed by the canonical form.

The C++ Canonical Class Template Form

• All code for the template go in the .h file
  • The name of the file should be close if not identical to the name of the class
• Use the preprocessor's conditional compilation facility to eliminate the duplicate inclusion of the .h file
• Define a default constructor for the class
  • Arrays of objects of the class cannot be created easily if there is no default constructor
• Define a destructor
• Define a copy constructor
• Define an assignment (=) operator
• Define an equality (==) operator (strongly recommended)
• Define a stream insertion (<< operator (strongly recommended)
• Define a stream extraction (>>) operator (optional)

file adt.h

#ifndef ADT_H
#define ATD_H

#include <iostream>

using namespace std;

class ADT {
	friend ostream &operator <<(ostream &, const ADT &);
	friend istream &operator >>(istream &, ADT &);		
public:
	ADT(void);
	ADT(const ADT &);
	~ADT();
	ADT &operator =(const ADT &)
	bool operator ==(const ADT &);
	...
private:
	...	
};
#endif
		

file adt.cpp

#include <iostream>

#include "adt.h"

ostream &operator <<(ostream &os, const ADT &adt) {
	...
	return os;
}

istream &operator >>(istream &is, ADT &adt) {
	...
	return is;
}
		
ADT::ADT(void) {...}

ADT::ADT(const ADT &source) {...}

ADT::~ADT() {...}

ADT &ADT::operator =(const ADT &rhs) {
	if (this == &rhs) return *this;
	...
	return *this;
}

bool ADT::operator ==(const ADT &rhs) {...}

#endif
		

file adt.h

#ifndef ADT_H
#define ATD_H

#include <iostream>

using namespace std;

template <typename E>
class ADT {
	friend ostream &operator <<<>(ostream &, const ADT<E> &);
	friend istream &operator >><>(istream &, ADT<E> &);		
public:
	ADT(void);
	ADT(const ADT<E> &);
	~ADT();
	ADT &operator =(const ADT<E> &)
	bool operator ==(const ADT<E> &);
	...
private:
	...	
};

//---------------- Method template definitions

template <typename E>
ostream &operator <<(ostream &os, const ADT &adt) {
	...
	return os;
}

template <typename E>
istream &operator >>(istream &is, ADT &adt) {
	...
	return is;
}
		
template <typename E>		
ADT<E>::ADT(void) {...}

template <typename E>
ADT<E>::ADT(const ADT &source) {...}

template <typename E>
ADT<E>::~ADT() {...}

template <typename E>
ADT<E> &ADT<E>::operator =(const ADT &rhs) {
	if (this == &rhs) return *this;
	...
	return *this;
}

template <typename E>
bool ADT<E>::operator ==(const ADT &rhs) {...}

#endif