object oriented programmingmain/supplements/pdf/notes...1. how an array of characters can be used as...

1

This lecture is an introduction to classes, telling what classes are andhow they are implemented in C++. The introduction is basic, notcovering constructors or operators that are covered in the text. The besttime for this lecture is just before students read Chapter 2--perhaps asearly as the second day of class.

Before this lecture, students should have a some understanding of

1. How an array of characters can be used as a string in C++programming, and

2. The meaning of the strlen and strcpy functions from string.h.

❐ Chapter 2 introduces ObjectOriented Programming.

❐ OOP is a relatively newapproach to programmingwhich supports the creationof new data types andoperations to manipulatethose types.

❐ This presentation introducesOOP.

Object OrientedProgramming

Data Structuresand Other ObjectsUsing C++

2

This lecture will introduce you to object-oriented programming by usingone example, which we'll call a "thinking cap".

What is this Object ?

❐ There is no realanswer to the question,but we’ll call it a“thinking cap”.

❐ The plan is to describea thinking cap bytelling you whatactions can be done toit.

3

The important thing about this thinking cap is that there are threeactions which may happen to it. The three actions are described here.

Using the Object’s Slots

❐ You may put a piece ofpaper in each of the twoslots (green and red), with asentence written on each.

❐ You may push the greenbutton and the thinking capwill speak the sentencefrom the green slot’s paper.

❐ And same for the redbutton.

4

Here's an example of how the first action works. Messages are writtenon two slips of paper, and the messages are inserted in the two slots.

Example

5

Once the messages have been inserted, either of the buttons may bepressed. When the green button is pressed, the message from thegreen slip of paper is spoken.

Example

That test was a breeze !

6

When the red button is pressed, the message from the red slip of paperis spoken.

By the way, what would be an appropriate precondition for pressing thered button? Answer: Before the button is pressed, the slips of papershould be inserted in the slots.

Example

I shouldstudy harder !

7

We will implement the thinking cap in C++ using a feature called aclass.

Thinking Cap Implementation

❐ We can implement thethinking cap using adata type called aclass.

class ThinkingCap{

. . .

};

8

The particular class we have in mind has two components that store thetwo sentences that are inserted in those slots. These components canbe declared arrays of characters in C++. As you may know, an array ofcharacter can be used in C++ to store a string. In this case, the stringmay be up to 49 characters (because we must save at least one spotfor the “end of string” marker).

Some of you may have used classes before in your programming.Others might have used “structs”, which are similar to classes. But aC++ class has two new features that are not available in ordinary structtypes...


❐ The class will havetwo components calledgreen_string andred_string. Thesecompnents are stringswhich hold theinformation that isplaced in the two slots.

❐ Using a class permitstwo new features . . .

class ThinkingCap{ . . . char green_string[50]; char red_string[50];

};

9

The first class feature is that class components are allowed to beprivate components. The advantage of private components is that theyprevent certain programmers from accessing the components directly.Instead, programmers are forced to use only through the operationsthat we provide.


➊ The two componentswill be privatemember variables.This ensures thatnobody can directlyaccess thisinformation. Theonly access is throughfunctions that weprovide for the class.

class ThinkingCap{ . . .private: char green_string[50]; char red_string[50];};

10

In a class, the operations to manipulate the data are actually part of theclass itself. A prototype for each function is placed as part of the classdefinition.


➋ In a class, thefunctions whichmanipulate the classare also listed.

class ThinkingCap{public: . . .private: char green_string[50]; char red_string[50];};Prototypes for the

thinking capfunctions go here,after the wordpublic:

11

In the jargon of OOP programmers, the class’s functions are called it’smember functions, to distinguish them from ordinary functions that arenot part of a class.


➋ In a class, thefunctions whichmanipulate the classare also listed.

class ThinkingCap{public: . . .private: char green_string[50]; char red_string[50];};Prototypes for the

thinking capmember functionsgo here

12

The implementations of member functions do not normally appearwithing the class definition. We’ll see where they do appear later, but fornow, let's just concentrate on this part of the class, which is called theclass definition.


class ThinkingCap{public: void slots(char new_green[ ], char new_red[ ]); void push_green( ) const; void push_red( ) const;private: char green_string[50]; char red_string[50];};

Our thinking cap has at least three member functions:

Functi

on bo

dies

will be

else

where

.

13

One thing that you might have noticed in the definition is a keyword,const, which appears after two of my prototypes. This keyword meansthat these two functions will not change the data stored in aThinkingCap. In other words, when you do use these two functions, aThinkingCap remains “constant”.


class ThinkingCap{public: void slots(char new_green[ ], char new_red[ ]); void push_green( ) const; void push_red( ) const;private: char green_string[50]; char red_string[50];};

The keyword const appears after two prototypes:

This means that thesefunctions will not changethe data stored in aThinkingCap.

14

Typically, a class definition is placed in a separate header file alongwith documentation that tells how to use the new class. Theimplementations of the member functions are placed in a separate filecalled the implementation file.

At this point, I still haven't shown you exactly what those threeimplementations of member functions look like -- and I want to continueto postpone that. Instead, I will next show you an example programwhich uses this ThinkerCap class.

Files for the Thinking Cap

❐ The ThinkingCap classdefinition, which we havejust seen, is placed withdocumentation in a file calledthinker.h, outlined here.

❐ The implementations of thethree member functions willbe placed in a separate filecalled thinker.cxx, which wewill examine in a fewminutes.

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA









Documentation

Class definition:• ThinkingCap class definition which we have already seen

15

Any program that uses a class requires an include statement indicatingthe name of the header file that has the class definition. Note that weinclude only thinker.h, which is the header file, and do not include theimplmentation file.

Using the Thinking Cap

❐ A program thatwants to use thethinking capmust include thethinker headerfile (along withits other headerinclusions).

#include <iostream.h>#include <stdlib.h>#include "thinker.h"

...

16

After the include statement, we may declare and use variables of theThinkingCap data type.

This example actually has two ThinkingCap variables, named studentand fan.


❐ Just for fun, theexample programwill declare twoThinkingCapvariables namedstudent and fan.


int main( ){ ThinkingCap student: ThinkingCap fan;

17

In object-oriented terminology, we would call these two variablesobjects of the ThinkingCap class.


❐ Just for fun, theexample programwill declare twoThinkingCapobjects namedstudent and fan.


int main( ){ ThinkingCap student; ThinkingCap fan;

18

This illustrates how we call one of the ThinkingCap functions for thestudent object.


❐ The programstarts bycalling theslots memberfunction forstudent.



student .slots( "Hello", "Goodbye");

19

But, again, let's use the usual OOP terminology, so that instead ofsaying that we are calling a function we say that we are activating amember function. In particular, we are activating the slots memberfunction of the student object. (If you go to a cocktail party and tell yourOOP friends that today you called a function for an object, they willlaugh behind your back. It is better to impress them by saying that youactivated a member function, even though it’s just jargon.)


❐ The programstarts byactivating theslots memberfunction forstudent.


int main( ){ ThinkingCap student: ThinkingCap fan;


20

The complete activation consists of four parts, beginning with the objectname.


➊ The memberfunctionactivationconsists of fourparts, startingwith the objectname.

int main( ) { ThinkingCap student; ThinkingCap fan;


Name of the object

21

The object name is followed by a period.


➋ The instancename is followedby a period. int main( )

{ ThinkingCap student; ThinkingCap fan;


A Pe

riod

22

After the period is the name of the member function that you areactivating.


➌ After the periodis the name ofthe memberfunction that youare activating.



Name of the Function

23

And finally there is the argument list. In the case of the slots memberfunction, there are two string arguments: new_green (which is given theactual value "Hello" in this example) and new_red (which is given theactual value "Goodbye" in this example).


➍ Finally, thearguments forthe memberfunction. In thisexample the firstargument(new_green) is"Hello" and thesecond argument(new_red) is"Goodbye".

#include "thinker.h"



Argu

men

ts

24

Go ahead and write your answers before I move to the next slide.

A Quiz

How would youactivate student'spush_greenmember function ?

What would be theoutput of student'spush_greenmember functionat this point in theprogram ?



25

Remember that the push_green member function does not have anyarguments, so the argument list is just a pair of parentheses.

A Quiz

Notice that thepush_green memberfunction has noarguments.

At this point,activatingstudent.push_greenwill print the string

Hello .



student .push_green( );

26

Here's a longer program. What is the complete output? Again, writeyour answers before I move to the next slide.

A Quiz

Trace through thisprogram, and tellme the completeoutput.



fan.slots( "Go Cougars!", "Boo!");


fan.push_green( );

student .push_red( ); . . .

27

The important thing to notice is that student and fan are separateobjects of the ThinkingCap class. Each has its own green_string andred_string data. Or to throw one more piece of jargon at you: Each hasits own green_string and red_string member variables. Membervariables are the data portion of a class. The activation of student.slotsfills in the green_string and red_string data for student, and theactivation of fan.slots fills in the green_string and red_string data forfan.

Once these member variables are filled in, we can activate thepush_green and push_red member functions. For example,student.push_green accesses the green_string member variable ofstudent, whereas fan.push_green accesses the green_string membervariable of fan.

A Quiz

HelloGo Cougars!Goodbye



fan.slots( "Go Cougars!", "Boo!");


fan.push_green( );

student .push_red( ); . . .

28

You now know quite a bit about OOP -- but the key missing piece ishow to implement a class’s member functions.

What you know about Objects

✔Class = Data + Member Functions.

✔You know how to define a new class type, andplace the definition in a header file.

✔You know how to use the header file in aprogram which declares instances of the classtype.

✔You know how to activate member functions.

✖ But you still need to learn how to write thebodies of a class’s member functions.

29

You already know the location of these implementations: in a separate“implementation file” called thinker.cxx.


class ThinkingCap{public: void slots(char new_green[ ], char new_red[ ]); void push_green( ); void push_red( );private: char green_string[50]; char red_string[50];};

Remember that the member function’s bodiesgenerally appear in a separate .cxx file.

Functi

on bo

dies

will be

in .c

xx fi

le.

30

We'll start by looking at the implementation of the slots memberfunction. The work which the function must accomplish is small: Copythe two arguments (new_green and new_red) to the two privatemember variables of the object (green_string and red_string).


class ThinkingCap{public: void slots(char new_green[ ], char new_red[ ]); void push_green( ); void push_red( );private: char green_string[50]; char red_string[50];};

We will look at the body of slots, which must copy itstwo arguments to the two private member variables.

31

For the most part, all that's needed is a pair of calls to strcpy to copythe two arguments (new_green and new_red) to the two membervariables (green_string and red_string). By the way, how many of youhave seen this use of strcpy before? If you haven’t seen it, don’t worry--it will be covered in Chapter 4. For now all you need to know is that thestrcpy statements work like assignment statements, copying from theright to the left. Also, you might notice that we have checked to makesure that the new_green and new_red have fewer than 50 characters(using strlen, which returns the number of characters in a string).

But the more interesting parts of this implementation are two specialfeatures that you need to know about.


void ThinkingCap::slots(char new_green[ ], char new_red[ ]){ assert(strlen(new_green) < 50); assert(strlen(new_red) < 50); strcpy(green_string, new_green); strcpy(red_string, new_red);}

For the most part, the function’s body is no differentthan any other function body.

But there are two special features about amember function’s body . . .

32

First of all, in the member function’s heading you must include thename of the class followed by two colons, as shown here. Otherwise,the C++ compiler will think that this is an ordinary function called slots,rather than a member function of the ThinkingCap class.


➊ In the heading, the function's name is preceded by theclass name and :: - otherwise C++ won't realize thisis a class’s member function.


33

Within the body of the member function, we may access any of themembers of the object. In this example, we are accessing both thegreen_string and the red_string member variables, by assigning valuesto these member variables.


➋ Within the body of the function, the class’s membervariables and other member functions may all beaccessed.


34

The use of these member variables is a bit confusing. Which membervariables are we talking about? student.green_string andstudent.red_string? Or are we referring to fan.green_string andfan.red_string? Or member variables of some other object?




But, whose membervariables arethese? Are they student.green_string student.red_string fan.green_string fan.red_string

?

35

The answer depends on which object has activated its memberfunction. If student.slots is activated, then these two member variableswill refer to student.green_string and student.red_string.




If we activatestudent.slots: student.green_string student.red_string

36

But if fan.slots is activated, then the two member variables refer tofan.green_string and fan.red_string.




If we activatefan.slots: fan.green_string fan.red_string

37

Here's the implementation of the push_green member function.


void ThinkingCap::push_green{

cout << green_string << endl;

}

Here is the implementation of the push_greenmember function, which prints the green message:

38

The important thing to notice is how the member function’simplementation uses the green_string member variable of the object. Ifwe activate student.push_green, then the member function will usestudent.green_string. And if we activate fan.push_green, then themember function will use fan.green_string.


void ThinkingCap::push_green{

cout << green_string << endl;

}

Here is the implementation of the push_greenmember function, which prints the green message:

Notice how this member function implementationuses the green_string member variable of the object.

39

The member functions of the ThinkingCap are all simple, but they doillustrate a common pattern: Often a member function (such as slots)will place information in the private member variables, so that otherconst member functions (such as push_green and push_red) mayaccess the information in those member variables.

A Common Pattern

❐ Often, one or more member functions willplace data in the member variables...

class ThinkingCap {public: void slots(char new_green[ ], char new_red[ ]); void push_green( ) const; void push_red( ) const;private: char green_string[50]; char red_string[50];};

❐ ...so that other member functions may use thatdata.

slots push_green & push_red

40

A quick summary . . . This presentation has only introduced classes.You should read all of Chapter 2 to get a better understanding ofclasses. Pay particular attention to the notion of a constructor, which isa special member function that can automatically initialize the membervariables of an object. Also pay attention to the more advancedfeatures such as operator overloading with the Point class given inChapter 2.

❐ Classes have member variables and memberfunctions. An object is a variable where the datatype is a class.

❐ You should know how to declare a new class type,how to implement its member functions, how touse the class type.

❐ Frequently, the member functions of an class typeplace information in the member variables, or useinformation that's already in the member variables.

❐ In the future we will see more features of OOP.

Summary

41

THE END

Presentation copyright 1997, Addison Wesley LongmanFor use with Data Structures and Other Objects Using C++by Michael Main and Walter Savitch.

Some artwork in the presentation is used with permission from Presentation Task Force(copyright New Vision Technologies Inc.) and Corel Gallery Clipart Catalog (copyrightCorel Corporation, 3G Graphics Inc., Archive Arts, Cartesia Software, Image ClubGraphics Inc., One Mile Up Inc., TechPool Studios, Totem Graphics Inc.).

Students and instructors who use Data Structures and Other Objects Using C++ arewelcome to use this presentation however they see fit, so long as this copyright notice remains intact.

object oriented programmingmain/supplements/pdf/notes...1. how an array of characters can be used as...

Documents