For projects in this class, use the following coding standard:

• No more than one private, protected or public section in a class definition.
• Every data member of a class must be private.
• Avoid global or file-scope variables. You may use const variables globally - nothing else.
• Avoid macros (#define) for constants. Use const variables for constants.
• Every class must define a default constructor, even if it does nothing.
• Every class must define a destructor, even if it does nothing.
• Every class must define an appropriate copy constructor.
• Every class must define an appropriate assignment operator.
• If a class has any virtual methods, provide a virtual destructor.
• If an accessor is provided for a data member, it must be a const method. Example:

  int getSize() const
  

• If a mutator is provided for a data member, it must return void. Example:

  void setSize(int newsize)
  

• Here are some suggested naming conventions. The important thing is that your naming is consistent. Following these conventions will help consistency. If you don't like these, adopt your own, but be consistent.
  • Constants all upper-case. Example:
    const int MAXSIZE
  • Class names begin with an upper-case letter. Join multiple words by capitalizing each one. Examples:
    class DoubleLinkNode
    class Matrix
  • The names of functions, methods, ordinary variables, and parameters begin with a lower case letter. Join multiple words by capitalizing each one. Examples:
    

    void setSize(int)
    int inverse(int)
    Matrix mat
    int arraySize
    

  • Class data members underscored and lower case. Example:
    int _length. Remember, all class data members must be private.

The grading script will compile your submitted project by using your makefile, so your makefile must correctly make your project. This includes correct naming of the executable. A sample makefile for Project 1 is provided:

/afs/umbc.edu/users/e/d/edelman/pub/CMSC-341/Proj1/Makefile

The example makefile can be used to obtain a nice-looking printout of your code. Just type make print and a Postscript file will be produced, ready for printing on any Postscript printer.

The makefile can also be used to submit your project. As long as you have SOURCES correctly defined, it will submit all the required files. Just type make submit to submit your project.

Remember that the command lines following the target line are indented by the TAB character, not by spaces. Sometimes the copying process converts TAB to spaces. Check your copy to be sure you have tabs.

/* 
   Array.H
   CMSC-341  Fall 2000 Project 1
   Array ADT 
   Penny Rheingans, Section 4, 999-99-9999, rheingan
   Created:  1 September 2000
   Current:  8 September 2000
*/

#ifndef ARRAY_H
#define ARRAY_H

template <class T> class Array; // forward declaration

#include <iostream.h>

/*
  Improved array that allows dynamic resizing, range checking, and
  assignment to another Array.  An Array "knows" its own size.
  Author: Penny Rheingans
  Version: 8 September 2000
*/
template <class T>
class Array
{
public:
  // Default constructor.  Array size is zero.
  Array();      

  // Construct new Array of size sz, elements unspecified.
  // Param sz: the size of this Array.
  // Precondition: sz > 0.  If sz <= 0, Array size will be
  // taken as zero.
  Array(int sz);

  // Construct new Array of size sz_bi with initial
  // elements from bi_aray (a built-in array of size sz_bi)
  // Param bi_aray: a built-in array from which to draw the
  //    initial elements of this Array
  // Param sz_bi: the size of bi_aray
  // Precondition: bi_aray must really be of size sz_bi.  If
  // sz_bi <= 0, an empty Array is constructed.  If sz_bi 
  // exceeds the actual size of bi_aray, errors may occur due
  // to array access boundary violations.  If sz_bi is less than
  // the actual size of bi_aray, initialization of the Array
  // will be incomplete.
  Array(T* bi_aray, int sz_bi);

  // Copy constructor
  // Param arr: the Array to copy
  Array(const Array<T>& arr);

  // Destructor
  ~Array();

  // Accessor for size of this Array.
  // Return: the size of this Array.
  int getSize() const;

  // Increase this Array's size.
  // Param delta:  the amount by which to increase this 
  //   Array's size
  // Pre-condition: delta greater than or equal to zero. This
  // is enforced by an assertion.
  void grow(int delta);

  // Decrease this Array's size.
  // Elements are removed from the right (elements from
  // A[size - delta] through A[size - 1] are lost).
  // Param delta: the amount by which to decrease this 
  //   Array's size.
  // Pre-condition: delta greater than or equal to zero and
  //      no greater than present size of this Array. This is
  // enforced by an assertion.
  void shrink(int delta);

  // Assignment operator
  // Assign ar to this Array
  // Param: arr is the Array to assign (the rvalue)
  // Return: this Array after modification.
  Array<T>& operator= ( Array<T> & arr);


  // Index operator.  Retrieve element at the specified index.
  // Param: indx is the index 
  // Return: the element at index in this Array.
  // Pre-condition: 0 <= indx < size.  This is enforced by
  //    an assertion.
  const T & operator[] (int indx) const;

  // Output operator
  // Param: os the stream to which to write arr
  // Param: arr is the Array to write
  // Return: os
  friend ostream& operator<< (ostream& os, const Array<T>& arr);
private:
  int _size;
  T* _array;
};

// for g++ templates, #include the .C file
#include "Array.C"


#endif