2. Objects and Classes

Objective: We'll show

• how C++ uses the class to achieve encapsulation and information hiding;

• how classes are implemented; and

• several examples of classes, including classes used to manipulate rational numbers and strings.

Reference: Weiss, Chapter Two.

2.1 Basic class Syntax

#ifndef _IntCell_H_
#define _IntCell_H_

// A class for simulating an integer memory cell.
//
// File: IntCell.h
//
class IntCell
{
public:
   // Constructor.  Initial value is initialValue.
   explicit IntCell(int initialValue = 0)
     : storedValue(initialValue) {}

   // Copy constructor.
   IntCell(const IntCell& rhs)
     : storedValue(rhs.storedValue) {}

   // Destructor.
   ~IntCell() {}

   const IntCell& operator=(const IntCell& rhs);

   // Accessor (or inspector) method.
   int read() const { return storedValue; }

   // Mutator method.
   void write(int x) { storedValue = x; }

private:
   int storedValue;
};
#endif

//
// File: IntCell.cpp
//

const IntCell& IntCell::operator=(const IntCell& rhs)
{
   if (this != &rhs)  // standard alias test
   {
      storedValue = rhs.storedValue;
   }
   return *this;
}

• A class like IntCell is a user-defined type.

• An instantiation of a class, i.e. a variable whose type is a class is called an object.

• The separation of interface, the .h file, and implementation, the .cpp file.

• A function declared inside the class without the friend keyword is called a member function (or a method).

• A class type encapsulates both member data and member functions.

• All member functions, except for those declared with static, must be invoked via a host object.

• Each instance of the class, i.e. an object, has its own copy of the data members, except for those declared with static.

• Access control: Members can be declared as public, private, or protected.

• A private member is accessible only to member functions or friend's of the class, while a public member can be used by any function. A protected member of a class is like a private member except that it is accessible to its derived classes' member functions.

• To enforce encapsulation, member data are almost always declared to be private. Accessor functions and mutator functions can be provided as means to access/change member data.

• The const keyword following the parameters list tells that the member function does not change any data member.

• A constructor, which has the same name as the class, describes how an instance of the class is created.

• Constructors should not have a type.

• A default constructor which takes no parameters is generated if no user-defined constructors are provided. If any constructor is defined in a class, be sure also to define one that takes no parameters.

• By default the copy constructor is applying copy constructor to each data member. Copy constructor is called
  • for a declaration with initialization, such as

            IntCell B = C;
            IntCell B(C);
    

    but not

            B = C;  // assignment
    

  • when an object is passed by value.
  • when an object is returned by value.

• A parameter with default value specified is an optional parameter. Optinal parameters may not appear before any mandatory parameters.

• The explicit keyword prevents implicit type conversions. It makes the following declaration illegal.

        IntCell obj1 = 37;
  

• Initializer list, which is like assignments, is used to specify nondefault initialization of each data member in an object directly. It is required in these situations:
  • Any data member does not have a zero-parameter constructor.
  • Initialize constant data members.
  • Initialize reference data members.

• The destructor, whose name is '~' followed by the name of the class, is called whenever an object goes out of scope or is subjected to delete. The destructor has no type.

• By default, the destructor destroys all data members of the object.

• The scope operator :: is used to specify scope.

• By default, the operator= is applying operator= to each data member.

• The operator= usually returns a constant reference.

• The pointer this is pointing to the host object.

• Use macro guard to avoid multiple inclusion of a file.

• A member function with a body in the class definition is inline.

• Aliasing occurs when the same object plays in more than one role in a member function.

2.2 An IntCell Test Program

#include "intCell.h"

int main()
{
  IntCell m;  // or, IntCell m(0); but not IntCell m();
  m.write(5);
  cout << "Cell contents: " << m.read() << endl;
  return 0;
}

2.3 Defaults may not work

class IntCell
{
public:
  explicit IntCell(int initialValue = 0)
    { storedValue = new int(initialValue); }

  int read() const
    { return *storedValue; }

  void write(int x)
    { *storedValue = x; }

private:
  int *storedValue;
};

int f()
{
   IntCell a(2);
   IntCell b = a;
   IntCell c;

   c = b;
   a.write(4);
   cout << a.read() << endl << b.read()
        << endl << c.read << endl;

   return 0;
}

• The output is three 4's: The copies are shallow.

• The int allocated by a's constructor needs to be reclaimed.

• The int allocated by c's constructor is lost.

2.4 Rational Number Test Program

#include "Rational.h"
#include <iostream>
using namespace std;

int main()
{
   Rational x;
   Rational sum = 0;
   Rational max = 0;
   int n = 0;

   cout << "Type as many rationals as you want" << endl;
   while (cin >> x)
   {
      cout << "Read " << x << endl;
      sum += x;
      if (x > max)
      {
         max = x;
      }
      n++;
   }
   cout << "Read " << n << rationals << endl;
   if (max > IntType(0))
   {
      cout << "Largest number is " << max << endl;
   }
   if (n > 0)
   {
      cout << "Average is " << sum/IntType(n) << endl;
   }
   return 0;
}

2.5 The Rational Class Interface

//
// File: Rational.h
//
#include <iostream>
using namespace std;

typedef long IntType;

class Rational
{
public:
   Rational(const IntType& numerator = 0)
     : numer(numerator), denom(1) {}

   Rational(const IntType& numerator, const IntType& denominator)
     : numer(numerator), denom(denominator)
     { fixSigns(); reduce(); }

   Rational(const Rational& rhs) : numer(rhs.numer), denom(rhs.denom) {}

   ~Rational() {}

   const Rational& operator= (const Rational& rhs);
   const Rational& operator+=(const Rational& rhs);
   const Rational& operator-=(const Rational& rhs);
   const Rational& operator*=(const Rational& rhs);
   const Rational& operator/=(const Rational& rhs);

   Rational operator+(const Rational& rhs) const;
   Rational operator-(const Rational& rhs) const;
   Rational operator*(const Rational& rhs) const;
   Rational operator/(const Rational& rhs) const;

   bool operator< (const Rational& rhs) const;
   bool operator<=(const Rational& rhs) const;
   bool operator> (const Rational& rhs) const;
   bool operator>=(const Rational& rhs) const;
   bool operator==(const Rational& rhs) const;
   bool operator!=(const Rational& rhs) const;

   const Rational& operator++();      // prefix
   Rational operator++(int);          // postfix
   const Rational& operator--();      // prefix
   Rational operator--(int);          // postfix
   const Rational& operator+() const; // unary +
   Rational operator-() const;        // unary -
   bool operator!() const;

   double toDouble() const
     { return static_cast< double >(numer) / denom; }

   friend ostream& operator<<(ostream& out, const Rational& value);

   friend istream& operator>>(ostream& in, Rational& value);

private:
   IntType numer;
   IntType denom;

   void fixSigns();  // ensure denom >= 0
   void reduce();    // ensure lowest form
};

2.6 Initialization and Type Conversion

• Simple initialization of class members using initializer lists is preferable to assignment in the constructor.

• Members are initialized in the order they are declared, not in the order in the initializer list. Don't write code that has dependence on this.

• A type conversion creates an object of a new type.

• If t1 has a one-parameter, of type t2, constructor, then it defines an automatic type conversion from t2 to t1.

• Type conversion is not transitive.

2.7 The Private Member Functions

void Rational::fixSigns()
{
   if (denom < 0)
   {
      denom *= -1;
      numer *= -1;
   }
}

void Rational::reduce()
{
   IntType d = 1;

   if (denom != 0 && numer != 0)
   {
      if ((d = gcd(numer, denom)) > 1)
      {
         numer /= d;
         denom /= d;
      }
   }
}

2.8 Assignment Operators

const Rational& Rational::operator=(const Rational& rhs)
{
   if (this != &rhs)
   {
      numer = rhs.numer;
      denom = rhs.denom;
   }
   return *this;
}

const Rational& Rational::operator+=(const Rational& rhs)
{
   numer = numer * rhs.denom + rhs.numer * denom;
   denom = denom * rhs.denom;
   reduce();
   return *this;
}

2.9 Some Other Operators

Rational Rational::operator+(const Rational& rhs) const
{
   Rational answer(*this);
   answer += rhs;
   return answer;
}

bool Rational::operator==(const Rational& rhs) const
{
   return numer * rhs.denom == denom * rhs.numer;
}

const Rational& Rational::operator++() // prefix
{
   numer += denom;
   return *this;
}

Rational Rational::operator++(int)  // postfix
{
   Rational tmp = *this;
   numer += denom;
   return tmp;
}

bool Rational::operator!() const
{
   return !numer;
}

const Rational& Rational::operator+() const
{
   return *this;
}

Rational Rational::operator-() const
{
   return Rational(-numer, denom);
}

2.10 I/O Friends

istream& operator>>(istream& in, Rational& value)
{
   in >> value.numer;
   value.denom = 1;

   char ch;
   in.get(ch);
   if (!in.eof())
   {
      if (ch == '/')
      {
         in >> value.denom;
         value.fixSigns();
         value.reduce();
      }
      else
      {
         in.putback(ch);  // unread ch
      }
   }
   return in;
}

ostream& operator<<(ostream& out, const Rational& value)
{
   if (value.denom != 0)
   {
      out << value.numer;
      if (value.denom != 1)
         out << '/' << value.denom;
      return out;
   }

   // messy code for denom == 0
   if (value.numer == 0)
   {
      out << "Indeterminate";
   }
   else
   {
      if (value.numer < 0)
      {
         out << '-';
      }
      out << "Infinity";
   }
   return out;
}

2.11 Operator Overloading

• Only existing operators can be overloaded, and new operators cannot be created.

• All but four C++ operators: ., .*, ?:, and sizeof, can be overloaded.

• Operator precedence and arity cannot be changed.

• There are three choices of return type:
  • by value --
  • by reference --
  • by constant reference --

• Can we make the binary addition return a constant reference? Or can we use a static local variable instead of a temporary, and make it return a constant reference?

• The prefix and postfix ++ or -- must have different signatures.

2.12 Some Common Idioms

• Avoiding Friends -- A class should have as few friends as possible. There are ways to avoid I/O friends of the Rational class.

  istream& operator>>(istream& in, IntCell& val)
  {
     int x;
     in >> x;
     if (!in.fail())
     {
        val = IntCell(x);
     }
     return in;
  }
  
  ostream& operator<<(ostream& out, const IntCell& x)
  {
     x.print(out);
     return out;
  }
  

  where

     void print(ostream& out = cout) const;
  

  outputs in exactly the format required by operator<<.

• Static Class members -- A static data member is a global variable that is shared by all instances of the class. A member function that manipulates no data members except static ones can be declared a static member function}.

  public:
     static int getActiveInstances() const
        { return activeInstances; }
  
  private:
     static int activeInstances;
  

  We can then increment activeInstances in the constructor and decrement it in the destructor. We need to initialize the static data member where we place definitions of gloabl objects like:

  int Rational::activeInstances = 0;
  

  A static member function is invoked directly without a host object. For example,

     cout << Rational::getActiveInstances() << endl;
  

• Use the enum trick to define integer class constants on compilers that do not support constant declaration within a class. E.g.

  public:
     enum { RED = 0, BLACK = 1 };
  

2.13 The string Class (mystring.h)

#ifndef _MY_STRING_H_
#define _MY_STRING_H_

#include <iostream>
using namespace std;

class string
{
public:
   string(char ch);
   string(const char *cstring = "");
   string(const string& str);
   ~string() { delete [] buffer; }

   const string& operator= (const string& rhs);
   const string& operator+=(const string& rhs);

   const char *c_str() const { return buffer; }
   int length() const {return strLength; }

   char  operator[](int k) const;  // accessor
   char& operator[](int k);        // mutator

private:
   int strLength;    // length of string
   int bufferLength; // capacity of buffer
   char *buffer;     // storage for characters
};



ostream& operator<<(ostream& out, const string& str);
istream& operator>>(istream& in, string& str);
istream& getline(istream& in, string& str,
                 char delim = '\n');

bool operator==(const string& lhs, const string& rhs);
bool operator!=(const string& lhs, const string& rhs);
bool operator< (const string& lhs, const string& rhs);
bool operator<=(const string& lhs, const string& rhs);
bool operator> (const string& lhs, const string& rhs);
bool operator>=(const string& lhs, const string& rhs);

#endif

2.14 The string Class (Constructors)

#include <cstring>
#include "mystring.h"

string::string(const char *cstring)
{
   if (cstring == NULL)
   {
      cstring = "";
   }
   strlength = strlen(cstring);
   bufferLength = strLength + 1;
   buffer = new char[bufferLength];
   strcpy(buffer, cstring);
}

string::string(char ch)
{
   strLength = 1;
   bufferLength = 2;
   buffer = new char[2];
   buffer[0] = ch;
   buffer[1] = '\0';
}

string::string(const string &str)
{
   strLength = str.length();
   bufferLength = strLength + 1;
   buffer = new char[bufferLength];
   strcpy(buffer, str.buffer);
}

2.15 The string Class (Assignments)

const string& string::operator=(const string& rhs)
{
   if (this != &rhs)
   {
      if (bufferLength < rhs.length() + 1)
      {
         delete [] buffer;
         bufferLength = rhs.length() + 1;
         buffer = new char[bufferLength + 1];
      }
      strLength = rhs.length();
      strcpy(buffer, rhs.buffer);
   }
   return *this;
}

const string& string::operator+=(const string& rhs)
{
   if (this == &rhs)  // alias test; important!
   {
      string copy(rhs);
      return *this += copy;
   }

   int newLength = length() + rhs.length();

   if (newLength >= bufferLength)
   {
      bufferLength = 2 * (newLength + 1);
      char *oldBuffer = buffer;
      buffer = new char[bufferLength];
      strcpy(buffer, oldBuffer);
      delete [] oldBuffer;
   }

   strcpy(buffer + length(), rhs.buffer);
   strLength = newLength;
   return *this;
}

2.16 The string Class (Indexing)

char& string::operator[](int k)
{
   if (k < 0 || k >= strLength)
   {
      throw StringIndexOutOfBoundException();
   }
   return buffer[k];
}

char string::operator[](int k) const
{
   if (k < 0 || k >= strLength)
   {
      throw StringIndexOutOfBoundException();
   }
   return buffer[k];
}

2.17 The string Class (I/O)

ostream& operator<<(ostream& out, const string& str)
{
   return out << str.c_str();
}

istream& operator>>(istream& in, string& str)
{
   char ch;
   str = "";
   if (in >> ch)
   {
      do
      {
         str += ch;
         in.get(ch);
      } while(!in.fail() && !isspace(ch));

      if (isspace(ch))
      {
         in.putback(ch);
      }
   }
   return in;
}

istream& getline(istream& in, string& str, char delim)
{
  char ch;
  str = "";
  while (in.get(ch) && ch != delim)
    str += ch;
  return in;
}

2.18 The string Comparisons

bool operator==(const string& lhs, const string& rhs)
{
   return strcmp(lhs.c_str(), rhs.c_str()) == 0;
}

bool operator!=(const string& lhs, const string& rhs)
{
   return strcmp(lhs.c_str(), rhs.c_str()) != 0;
}

bool operator<(const string& lhs, const string& rhs)
{
   return strcmp(lhs.c_str(), rhs.c_str()) < 0;
}

bool operator<=(const string& lhs, const string& rhs)
{
   return strcmp(lhs.c_str(), rhs.c_str()) <= 0;
}

bool operator>(const string& lhs, const string& rhs)
{
   return strcmp(lhs.c_str(), rhs.c_str()) > 0;
}

bool operator>=(const string& lhs, const string& rhs)
{
   return strcmp(lhs.c_str(), rhs.c_str()) >= 0;
}

• Will operator= still work if aliasing test is omitted? What about operator+=?

• Array-doubling is used for performance.

• For the index operator, consider the function:

  void reverseCopy(const string& from, string& to)
  {
     int len = from.size();
     to = from;
     for (int i = 0; i < len; i++)
     {
        to[i] = from[len -1 -i];
     }
  }
  

  • If only return by value is provided, then to[i] cannot appear on the left hand side.
  • If return by reference is provided, then something like from[i] = to[i] would still compile since from[i] is a simple reference, and thus modifiable.

• We need two versions of operator[]: one returns by value and the other by reference. It is possible since const-ness is considered part of the signature.

• The comparison operators are not member operators of string to allow automatic type conversion from C-string to string.

• To avoid creating temporaries, it may be worthwhile to write overloaded versions like:

  bool operation>=(const char *lhs, const string& rhs);
  bool operation>=(const string& lhs, const char *rhs);
  

  and class member functions

  const string& operation=(const char *rhs);
  const string& operation+=(const char *rhs);
  const string& operator+=(char ch)
  

• The line

      throw StringIndexOutOfBoundException();
  

  in the implementations of operator[] is a kind of exception handling which will be discussed later.