CSCI 201 Study Aid: Classes

Objects and Classes

Object-oriented programming (OOP) is an approach to programming where the data and the operations for manipulating that data come in a tidy package called an object.
In C++ the mechanism to create objects is the class.
A class is a user defined data type. Each class you define contains the data and functions to manipulate that data.
Classes support information hiding. A programmer who uses a class may have no idea of how the class is implemented. The implementor of a C++ class can completely hide the knowledge of how a class is implemented. Information hiding is one of the features of classes that supports code reuse.

A Class Consists of:

The interface or definition is contained in a header file (filename.h). The definition consists of:
- Declarations of the data members
- The prototypes for the member functions
The implementation is written in a source code file (filename.cpp). The implementation file contains:
- code for the member functions
- code for any auxiliary functions required to overload standard operators such the extraction operator.
You could put both the definition and the implementation be in same file but that would defeat the purpose of information hiding.

The Class Interface or Definition

The parts of the class definition are:

the class keyword followed by the name of the new class
the public section lists the prototypes of the member functions
there are two kinds of public member functions:
1. those that modify the state of the class (modify the member variables), these are called mutator functions
2. constant member functions that examine the status of the data members but are forbidden to change them. The prototypes for these functions are followed by the keyword const
the private section contains the data members (also called the member variables). These variables can't be directly accessed by programmers who use the class (but the class member functions can access these variable).

Simple example

The throttle class---a new data type that manipulates and stores the status of a throttle. A toy example of a class that might be used in a flight simulator. There are 4 throttle functions:

a function to set the throttle to the shutoff position
a function to shift a throttle's position by a given amount
a function that returns the fuel flow (percentage of max flow).
a function to verify that the throttle is currently on.
```
	class Throttle
	{
	public:
		// Mutator functions
		void shut_off( );
		void shift(int amount);
		// Inspector functions
		double flow( ) const;
		bool is_on( ) const;
	private:
		int position, max_position;
	};
```
The header file and the implementation file
- Information hiding is accomplished by using 2 separate files to define and implement a class:
  1. A header file provides all the information a programmer needs to use a class
  2. An implementation file provides the actual implementation of the class's member functions.
- The header file name uses the extension ".h" and the implementation file name uses the extension ".cpp; they usually have the same base name:
```
	header file: throttle.h
	implementation file: throttle.cxx
```
- At the top of the header file place all the documentation that the programmer needs to use the class. The class definition follows the documentation. (Don't include the implementation!).
- Place pre-processor commands around the entire class definition to prevent accidental duplication of the definition:
```
	#ifndef THROTTLE_H
	#define THROTTLE_H
		class Throttle
		{
			...
		}
	#endif
```
Using a class

As with any other data type, you declare variables of that type. These variables are called objects or instances.
```
	Throttle plane, car;
```
Calling member functions:
```
	car.shift(3);
       /   |   \   \
      /    |    \  actual parameter
 object    |     \  
  name   member  member 
         access  function
        function
```
Implementing member functions
- Writing the definition of the function is like writing any other function with one exception: In the head of the function definition, the class name must appear before the function name separated by 2 colons. The 2 colons called the scope operator tell the compiler that it is a member function of a particular class.
```
	Void Throttle::shut_off( )
	{
		position = 0;
	}

	double Throttle::flow( ) const
	{
		return position/max_position;
	}
```
- Each object has its own copy of all member variables. When a member function implementation refers to a member variable, then the actual member variable used comes from the object whose member function has been activated.
```
     
	Throttle car, plane;
	car.shut_off( );     // sets car's position variable to 0
	plane.shut_off ( );   // sets plane's position variable to 0
```
- Member functions can call (activate) other member functions.
```
  
     	bool Throttle::is_on( ) const
	{
		return (flow( ) > 0);
	}
```
- Constant member functions can not call non-constant member functions. Also, the const keyword must be used in both the declaration and the definition.
Constructors
- Constructors provide an initialization function that is guaranteed to be called. A constructor is a member function with these special properties:
  - If the class has a constructor then it is automatically called when a variable of that class is declared.
  - The name of the constructor must be the same as the name of the class
  - A constructor does not have any return value
  - If the constructor has parameters then the calling arguments must be given after the object name
- Example constructor declaration:
```
     	class Throttle
	{
	public:
		// Constructor
		Throttle(int size);
		// Modification member functions
		....
```
- Constructor Implementation
```
     	Throttle::Throttle(int size )
	{
		max_position=size;
		position = 0;
	}
```
- If you write a class with no constructor, then the compiler automatically creates a simple default constructor. It just calls the default constructors for the member variables. Because the data members in the throttle class are type int, the default constructor does not initialize these variables. The default constructor has no parameters.
- Multiple constructors: Multiple constructors can be provided, one for each different kind of initialization. Each constructor must have a unique signature (i.e., parameter list) so the compiler can tell them apart.
```
     	class Throttle
	{
	public:
		// Constructors
		Throttle ( );    // the default constructor
		Throttle (int size);   // one parameter constructor
		Throttle (int size, int start);   // two parameter constructor
		.....
```
- In this case you could use default arguments to get the same effect
```
	class Throttle
	{
	public:
		// Constructor
		Throttle (int size=5, int start=0);    
```
- A default argument is a value that will be used for a parameter when there is no actual calling argument.
- Default arguments are specified only once in the prototype, not in the function's implementation.
- Defaults do not need to be specified for all parameters, but if only some are specified then they must be rightmost in the parameter list.
```
	int set_date(int year, int month=1, int day=1);
```
- When the function is called, arguments with default values may be omitted from the right end of the calling argument list
```
	set_date(1997,12,5);  or  set_date(1997, 12);  or  set_date(1997);
```
Exercises
1. Here is the start of a class declaration:
```
    class Foo
    {
    public:
       Foo(int num);
       void fun1(Foo f);
       void fun2(const Foo f);
       void fun3(Foo f) const;
       ...
    }
```
  Which of the member functions can alter the PRIVATE member variables of the Foo object that activates the function?
  1. Only Foo can alter the private member variables of the object that activates the function.
  2. Two of the functions can alter the private member variables of the object that activates the function.
  3. Three of the functions can alter the private member variables of the object that activates the function. <==
  4. All of the functions can alter the private member variables of the object that activates the function.
2. What is the primary purpose of a constructor?
  1. To initialize the data members of an object as it is declared. <==
  2. To allow multiple classes to be used in a single program.
  3. To copy an actual calling argument to a function's parameter.
  4. To free the dynamic memory used by an object.
3. Which kind of functions can access private member variables of a class?
  1. Friend functions of the class
  2. Private member functions of the class
  3. Public member functions of the class
  4. All of the above can access private member variables <==
  5. None of the above
  solution to 1 through 3
4. Write the definition of a class that allows you to set and get the time of day in hours, minutes and seconds.
  solution
5. Modify the class definition given above to include a constructor that has 3 parameters corresponding to the time in hours, minutes and seconds. The constructor should specify default values for these parameters.
  solution
6. Write the implementation of the constructor describe above.
  solution
7. Write the definition of a class to represent a rectangle. This class should allow you to both set and get the dimensions of the rectangle. It should also provide facilitators for calculating the area and the perimeter of the rectangle.
  solution
8. Write the implementation of the class describe above.
  solution

CSCI 201 Study Aid: Classes

Objects and Classes

A Class Consists of:

The Class Interface or Definition

Simple example

The header file and the implementation file

Using a class

Implementing member functions

Constructors

Exercises