Below is an example of how to document a class. If written correctly,
you should have no questions about the details of writing the
definitions for the various class methods. To make things more
readable I put the documentation of a method above the declarations
of the method, and I put a blank line after the definition.

Please note that the declaration is incomplete.

/*Implement the Abstract Data Type (ADT) for a set.
  A set is a "collection" of "elements." Sets and their elements have
  the following operations
  (1) The intersection of two sets (the set of elements common to both)
  (2) The union of two sets (the set of elements consisting of
      elements in either set)
  (3) The complement of a set (the set of elements not in the given
      set)
  (4) The maximum element of a set
  (5) The minimum element of a set

  In this implementation of the Set ADT, the elements are ints in some
  range from "low" to "high," inclusive.
*/
class Set{
public:
  static const int RANGE=100; //The maximum range of elements in a set
                              // Thus, if we have sets in the range
                              // a..b, then RANGE=b-a;
private:
  int low,high;  //The element x can be in the set if and only if
                 // low<=x<=high. This is sometimes called the "universe"
  bool present[RANGE+1];  //If a given int j is in the set then
			  //present[j-low] is true, else it is false.
                          //I need RANGE+1 spaces so that I include
                          //both low and high
public:
  
  /*Preconditions:    a<=b, b-a<=RANGE
    Postconditions:    low=a, high=b, present[j]=false for all j such
                      that j>=low and j<=high  */		      
  Set(int a=0, int b=RANGE);

  /*Return the number of elements in the set, leaving the set
    unchanged.
    Preconditions: low<high, high-low<=RANGE
    Postconditions: return the number of times present[j-low] is true
                    for low<=j<=high
  */
  int size()const;

  /*Purpose: add x to the set, returning a reference to the set
    Preconditions: low<high, high-low<=RANGE
                   low<=x<=high
    Postconditions: low and high are unchanged.
                    if x satisfies the preconditions
		       all values of present[j] are unchanged
                       except that present[x-low]==true, indicating
                       that x is now in the set (present[x-low] might
                       have been true before adding x
		    if x does not satisfy the precondtions, display
		       an error message that diagnoses the error and
                       then exit */		       
  Set & operator+=(int x);

  /*Purpose: return the union of the instance and the set s
    Precondition: low<high, high-low<=RANGE; s.low<s.high,
                  s.high-s.low<=RANGE
		  if x=the miminum of low and s.low and
		     y=the maximum of high and s.high
                  then (of course) x<y and) y-x<=RANGE
    Postcondition: return a Set where some z is in the set if and only if
                   it is either in the instance or in s (or in both
                   sets)
		   If the preconditions are not satisfied, diagnose
		   error and crash.
    
  */
   Set operator+(const Set &s);
};