CMSC 341 Project Organization

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

• 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.
  • Avoid global or file-scope variables. You may use const variables globally - nothing else.
  • Avoid macros (#define) for constants. Use const variables for constants.
  • 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 matrix;
       int arraySize;
       

  • Class data members underscored and lower case. Example:
    int _length. Remember, all class data members must be private.
• Comments and whitespace -- The readability of code is an important, but often overlooked aspect of good programming. For this course, we will will adopt the following commenting and whitespace standards. The standards listed below are in addition to those listed above.
  
  • Prefer C++ style (ie // ) comments for in-line commenting, but C style comments are acceptable
  • All in-line comments must be above the code to which they apply and indented to the same level. DO NOT place comments at the end of the line. For example // proper inline comment here for (....) for (...) // not here
  • In-line comments tell us what the code is doing, not HOW it's doing it
  • Avoid worthless comments.
  • Use 3 or 4 spaces for each level of indent. xemacs can be configured to do this for you.
  • use whitespace around all operators
  • use blank lines to separate each major section of code

• The use of global variables is strictly forbidden. Constants with module scope are acceptable if absolutely necessary.
• You may not change the public interface of any class specified in any project description. In particular this means you may not add any new public methods to the class definition.
• No more than one private, protected or public section in a class definition.
• Every data member of a class must be private.
• 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)
    

• The principles of data hiding and encapsulation must be followed in all classes.
• Avoid the use of friends.

All students must use the g++ compiler in /usr/local/bin. You should do the following to avoid using the wrong compiler

1. In your project makefiles, explicitly specify the compiler as /usr/local/bin/g++ rather than simply as g++
2. Modify your .cshrc file (found in your home directory -- note the leading dot) by adding the line alias g++ /usr/local/bin near the bottom.

Further, the compiler switches -ansi and -Wall must be used when compiling. These should be included in your makefile rules and used whenever you compile "by hand".

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.

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

   Array ADT
     An improved array that allows dynamic resizing, range checking, and
   assignment to another Array.  An Array "knows" its own size.
*********************************************************/

#ifndef ARRAY_H
#define ARRAY_H


#include <iostream>

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