Wyo C++ Ch. 12 Notes

Computer Science Using C++

Ch. 12 Notes

Objective #1: Understand the difference between procedural programming and object-oriented programming (OOP).

For the first several decades of computer programming, languages were written to support a procedural paradigm of programming. Programs were mainly composed of functions that performed specific tasks to process data. Programmers were able to manipulate the data by using global variables and passing parameters. As long as the programmer understood how the data was stored and how the algorithms worked, everything worked well. However, sometimes data can be corrupted due to bad logic or input if a programmer forgets certain details.
Procedural programming is still useful and will probably always be used in many situations and languages. However the popularity of the object-oriented programming (OOP) is increasing as hybrid languages like C++ and pure OOP languages like Java & Smalltalk become used more widely.
The object-oriented paradigm of programming is based on the idea that a program is really a collection of objects, not functions. Each object is contains its own members consisting of methods and member variables (often called "data") . Methods perform the processes that functions perform in procedural programming however the fact that the data is also part of the object protects its integrity.

Objective #2: Understand the principles of object-oriented programming.

Object-oriented programs are built with objects. Objects contain members which include methods and variables (also called member variables or data). (Remember, we studied member variables as part of structs earlier.) The methods detail processes that occur with the data that is stored in the object's variables. Usually, the variables are designated as private and cannot be directly referenced by programmers who use the object. This principle of "hidden" data is called encapsulation. However, a programmer can use an object's public methods in order to indirectly change its underlying, private data. Written into the object's definition (known as a class) are rules and constraints that keep programmers from using the methods inappropriately.
When using an object's methods to manipulate data, messages are exchanged with the object. You could say that calling an object's method is like sending a message.
The definition for an object is called a class. You can crudely compare a class to a basic C++ data type. But it is a The class prescribes instructions to the compiler regarding memory allocations for its object. When you actually declare an object in a program, its called instanciating the object. The object (essentially a variable) is called an instance of the class.

Objective #3: Learn how to read classes and use objects in C++.

A class definition looks similar to a struct definition. Instead of using the keyword struct, you use the keyword class.

#ifndef _STUDENT_H
#define _STUDENT_H

class Student
{
   public:
       // constructors
       Student( );                             // default constructor
       Student(const Student &);   // copy constructor

        // member functions
        double GetGPA( );
        void AssignStudentNum(int);

   private:
        // data
        double GradePointAverage;
        int StudentNum;
};

#endif
The member function prototypes are often contained in the public partition of the class definition. This allows programmers to use the member functions to send messages to a Student object in order to manipulate its data (i.e. assign a student number & determine a student's GPA).
While the compiler will automatically create a default constructor in a class definition, it is proper to include one when creating a class. A constructor is a function that allows a programmer to instanciate the object. Without a constructor, the compiler would not now how much memory to reserve for a new Student object. The default constructor is used to instanciate a new object. A copy constructor would be used when the compiler needs to pass an object by value (i.e. copy the object.)
The member variables (data) are often placed (encapsulated) into the private partition of the class definition. Therefore, the data is protected. The technique of hiding the data in the private area is called information hiding.
Notice that the constructors and member functions appear in the class definition only as prototypes. The full details of how these functions work will appear in the class implementation. Return types and parameters are detailed in these prototype statements as are the data types of the member variables.
Often the class definition (as shown above with the example Student class) is placed into a header file and named Student.h, where Student is the name of the class and the .h refers to the file as a header file. This part of the class is called the interface. The actual details of the member functions and constructors are usually placed into a separate file and is called the implementation, which would be named Student.cpp in this case. Though it is not required to separate a class into two such files, it does allow the implementation file to be precompiled and thus hidden from other programmers who might want to "steal" your code. Then, programmers who purchase or license a class could see the function prototypes and know what parameters and return types are involved but would not be able to see the technical details in the functions themselves, protecting the hard work of the person who wrote the class.
The class implementation for the Student class appears below:

#include "student.h" // necessary so that the compiler is aware of the class'
                                   //     header file, where the class definition (member function
                                   //     prototypes, member variable data types, etc.), is presented

//default constructor
Student::Student( )
{
   GradePointAverage = 0;
   StudentNum = 0;
}

// copy constructor
Student::Student(const Student & OriginalObject)
{
   GradePointAverage = OriginalObject.GradePointAverage;
   StudentNum = OriginalObject.StudentNum;
}

//Method to get the GPA of the Student object
double Student::GetGPA( )
{
   return (GradePointAverage);
}

//Method to assign a student number to the Student object
void Student::AssignStudentNum(int NumberToAssign)
{
   StudentNum = NumberToAssign;
}
Notice that the class' separate header file must be included with a #include statement at the top of the implementation file.
The implementation file is essentially a set of member functions. There is no main function and there aren't even any function prototypes since they are contained in the class definition (in the interface header file.)
The scope-resolution operator (::) must be used in the headers of the member functions to join the name of the class to the function's name. This is necessary because it is possible to have two functions with the same name appear in two different classes where one is a base class of the other. For example, the Student class could be a base class of a Freshman class and for some reason the programmer may desire to include a GetGPA member function in both classes. (The Freshman::GetGPA could present the grade as 3.5/4.0 instead of simply 3.5, since freshmen may not be wary that the school uses a 4.0 scale.
For another example of a class with its definition stored in a header file and a separate implementation file, see the Circle class that is illustrated in the textbook.

Circle.h & Circle.cpp
To use objects in a program, you must first instanciate them. This is similar to the idea of declaring variables. To instanciate a Student, you would use the statement,

Student Bill;

where Bill is the name of the object that you created and the identifier Student tells the compiler to use the default constructor of the class Student to instanciate (i.e. reserve memory, initialize member variables, etc.) the object. You can instanciate another Student object with

Student Jane;

which would be called a second instance of the class.
To display Bill's grade point average, one would use the GetGPA public member function of the Bill object.

cout << Bill.GetGPA( );

The period is being used here as the class-member operator (aka member selection operator) similarly to how the dot operator was used with struct variables. Note that if GetGPA was a private member function, it would be illegal for the programmer to use the GetGPA function in a program. Also, realize that I did not include any way of assigning a grade point average to a Student object in the trivial Student class example above. An object's GradePointAverage is initialized to zero within the default and copy constructors though!
To assign the student number 12 to the instance Jane, you would use the statement,

Jane.AssignStudentNum(12);

Objective #4: Understand how objects help programmers reuse code.

It is very efficient to build and use classes in object-oriented programming. The fact that objects can be defined and created and then passed onto (or sold) to other programmers encourage the careful and thorough development of more classes. Reusing code in this way is called reusability. For example, you can use the Microsoft Foundation Classes (MFC) to manipulate common objects such as dialogue boxes, toolbars, and windows that are considered to be standard to the Windows GUI (graphical user interface.) So, actually programming (at least in the desktop environment) is becoming more high-level than ever. One doesn't have to master the Assembly language and obscure hardware technical requirements in order to write a commercial, user-friendly program. However, you may have to pay a few dollars to use some classes.

Objective #5: Understand containment and inheritance in C++ object-oriented programming.

Containment is the relationship between certain objects in classes. An object can use another class to instanciate objects within itself. For example, a programmer could use the ClassPeriod class to instanciate 8 ClassPeriod objects within one SchoolDay object. This arrangement is also referred to as a has-a relationship because the SchoolDay object has a ClassPeriod object.
Inheritance allows programmers to reuse code. If you have written one class and later need to develop another class that would have a lot of the same properties, you can use inheritance to extend the common properties into the new class. This prevents you from having to separately code the common properties a second time. The relationship between objects of these two classes is called an is-a relationship. The original class is called the parent class and the second one with the derived (or inherited properties) is called the child (or derived) class. If your purpose for creating a class is to extend it into several different child classes, you can call it a base class.
Multiple inheritance allows objects to inherit properties from multiple objects. In that case, an object could have two or more parent objects. Multiple inheritance is not allowed in some pure OOP languages and is rarely used.
Note that inheritance is not included on the AP Computer Science exam but is still important with regard to OOP.

Computer Science Using C++ Home Page | Mr. Minich's Wyo Home Page