ECE 10 Dr. Klefstad Classes and Enumerations

Outline

Enumerations
Classes
Member data
Member functions
Class instances (objects)
Defining the << operator

Enumerations

a shorthand for defining a list of constants

instead of

const int MON=0, TUE=1, WED=2, THU=3, FRI=4,
  SAT=5, SUN=6;

enum allows more consice and less error prone definition
```
enum Day {MON, TUE, WED, THU, FRI, SAT, SUN};
```
Day is a new type with values MON, ..., SUN
```
Day d = MON;
```

Introduction to Object-Oriented Design

given a programming problem
first we identify objects
next we identify some likely operations on each kind of object
next we define a class to describe each kind of object
a class definition introduced a new data type
EG class CDPlayer, class Automobile, class Engine

Example Class

the class of all complex numbers

class Complex
{
public:
  float re, im;
  Complex( float newRe = 0.0, float newIm = 0.0 )
    : re( newRe ), im( newIm )
  {
  }
  Complex add( Complex c )
  {
    return Complex( re + c.re, im + c.im );
  }
  void print( ostream & out )
  {
    out << "(" << re << "+" << im << "i)";
  }
  ~Complex()
  {
  }
};

Class Members

definitions made inside a class are called class members
member data is data contained in each object of this class type
- they may be constant or variable
```
float re, im;
```

a member function operates on an object of this class type

int main()
{
  Complex c( 1.0 , 2.5 );
  c.print( cout );
}

The Hidden 'this' Parameter

every member function has a hidden extra parameter
the parameter is named 'this'
'this' points to an object defined by this class
members of 'this' are directly visible (in scope) inside the member function

Accessing Members From Inside the Class

member functions may access members of 'this' directly

class Complex
{
public:
  float re, im;
  void print( ostream & out )
  {
    out << "(";
    out << re;  // re of this
    out << "+";
    out << im;  // im of this
    out << "i)";
  }
  ...
};

Defining a Constructor

a constructor must build and initialize our objects
it is called automatically just after allocation of 'this' object

the constructor's 'init list' allows construction of data members

class Complex
{
public:
  float re, im;
  Complex( float newRe = 0.0, float newIm = 0.0 )
    : re( newRe ), im( newIm )
  {
    cout << "Complex number ";
    print( cout );
    cout << " is born.\n";
  }
};

Defining Member Functions

member functions are similar to regular functions
members of 'this' are directly visible
they may have additional parameters as declared

they may access private and public class members

class Complex
{
public:
  float re, im;
  Complex add( Complex c )
  {
    return Complex( re + c.re, im + c.im );
  }
};

Defining a Destructor

a destructor must clean-up after our objects
it is called automatically just before deallocation of this object

class Complex
{
public:
  float re, im;
  ~Complex()
  {
    cout << "Complex number: ";
    print( cout );
    cout << " has died.\n";
  }
};

Defining Objects Outside the Class

Each instance has its own data members
public members may be accessed using the dot operator

EG Complex

 #include "Complex.h"
int main()
{
  Complex c1( 1.5, 5.3); /// c1 is born
  Complex c2( 2.5, 2.7 ); /// c2 is born
  c1.print( cout );
  c2.print( cout );
  {
    Complex result; /// What happens here?
    result.print( cout );
    result = c1.add( c2 );  /// and here??
    result.print( cout );
  } /// and here???
  c1 = Complex( 2.0, 3.0 ); /// a literal Complex number
  c1.print( cout );
  return 0;
} /// and here????

Defining a << operator

C++ allows us to define a << operator for our new type
operator << can not be a member function!

ostream & operator << ( ostream & out, Complex c )
{
  c.print( out );
  return out;
}

int main()
{
  Complex mySink( 3.4, 2.2 );
  cout << "Sink at location: " << mySink << endl;
  ...
}

Public and Private

public: section defines the class interface (controls)
- these members are accessible to everyone
private: section defines the class implementation (internals)
- these members are accessible only to class member functions
simple rule for now:
- make member data private
- make member functions (and constructors/destructors) public

Declaring a Class

classes are typically declared in a .h file
class declarations are analogous to function prototypes

EG Complex.h

class Complex
{
private:
  float re, im;
public:
  Complex( float newRe, float newIm );
  Complex add( Complex c );
  void print( ostream & out );
  ...
};
ostream & operator << ( ostream & out, Complex c );

Defining Class Member Functions

We prefer to define class member functions in the .cpp file using the scope qualifier :: to qualify their name
scope rules are the same as when you define them inside the class declaration

EG Complex.cpp

 #include "Complex.h"
Complex :: Complex( float newRe, float newIm )
  : re( newRe ), im( newIm )
{
}
Complex Complex :: add( Complex c )
{
  return Complex( re + c.re, im + c.im );
}
void Complex :: print( ostream & out )
{
  out << "(" << re "+" << im << "i)";
}
...

Complete Example: Integer

EG Integer.h

 #include <iostream.h>
class Integer
{
private:
  int value;
public:
  Integer( int i = 0 );
  void print( ostream & out );
  int getValue();
  void setValue( int i );
  ~Integer();
};
ostream & operator << ( ostream & out, Integer i );

EG Integer.cpp

 #include "Integer.h"
Integer :: Integer( int i )
  : value(i)
{
  cout << "Integer " << value << " was just born.\n";
}
void Integer :: print( ostream & out )
{
  out << value;
}
int Integer :: getValue()
{
  return value;
}
void Integer :: setValue( int i )
{
  value = i;
}
Integer :: ~Integer()
{
  cout << "Integer " << value << " has just died.\n";
}
ostream & operator << ( ostream & out, Integer i )
{
  i.print( out );
  return out;
}

EG main.cpp

 #include "Integer.h"
int main()
{
  Integer i(20);
  {
    Integer j(30);
    {
      Integer k(40);
      k.setValue( i.getValue() + j.getValue() );
      cout << "k is " << k << endl;
    }
    cout << "j is " << j << endl;
  }
  cout << "i is " << i << endl;
  return 0;
}

EG console output

Integer 20 was just born.
Integer 30 was just born.
Integer 40 was just born.
k is 50
Integer 50 has just died.
j is 30
Integer 30 has just died.
i is 20
Integer 20 has just died.