1. Chapter 2 introduces Object
Chapter 2 introduces Object
Oriented Programming.
Oriented Programming.
OOP is a relatively new
OOP is a relatively new
approach to programming
approach to programming
which supports the creation
which supports the creation
of new data types and
of new data types and
operations to manipulate
operations to manipulate
those types.
those types.
This presentation introduces
This presentation introduces
OOP.
OOP.
Object Oriented
Programming
Data Structures
Data Structures
and Other Objects
and Other Objects
Using C++
Using C++
2. What is this Object ?
There is no real
There is no real
answer to the question,
answer to the question,
but we’ll call it a
but we’ll call it a
“thinking cap”.
“thinking cap”.
The plan is to describe
The plan is to describe
a thinking cap by
a thinking cap by
telling you what
telling you what
actions can be done to
actions can be done to
it.
it.
3. Using the Object’s Slots
You may put a piece of
You may put a piece of
paper in each of the two
paper in each of the two
slots (green and red), with a
slots (green and red), with a
sentence written on each.
sentence written on each.
You may push the green
You may push the green
button and the thinking cap
button and the thinking cap
will speak the sentence from
will speak the sentence from
the green slot’s paper.
the green slot’s paper.
And same for the red
And same for the red
button.
button.
7. Thinking Cap Implementation
We can implement the
We can implement the
thinking cap using a
thinking cap using a
data type called a
data type called a
class
class.
.
class thinking_cap
{
. . .
};
8. Thinking Cap Implementation
The class will have
The class will have
two components called
two components called
green_string
green_string and
and
red_string
red_string. These
. These
compnents are strings
compnents are strings
which hold the
which hold the
information that is
information that is
placed in the two slots.
placed in the two slots.
Using a class permits
Using a class permits
two new features . . .
two new features . . .
class thinking_cap
{
. . .
char green_string[50];
char red_string[50];
};
9. Thinking Cap Implementation
The two components
The two components
will be
will be private
private
member variables
member variables.
.
This ensures that
This ensures that
nobody can directly
nobody can directly
access this
access this
information. The
information. The
only access is through
only access is through
functions that we
functions that we
provide for the class.
provide for the class.
class thinking_cap
{
. . .
private:
char green_string[50];
char red_string[50];
};
10. Thinking Cap Implementation
In a class, the
In a class, the
functions which
functions which
manipulate the class
manipulate the class
are also listed.
are also listed.
class thinking_cap
{
public:
. . .
private:
char green_string[50];
char red_string[50];
};
Prototypes for the
thinking cap
functions go here,
after the word
public:
11. Thinking Cap Implementation
In a class, the
In a class, the
functions which
functions which
manipulate the class
manipulate the class
are also listed.
are also listed.
class thinking_cap
{
public:
. . .
private:
char green_string[50];
char red_string[50];
};
Prototypes for the
thinking cap
member functions
go here
12. Thinking Cap Implementation
class thinking_cap
{
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:
Function
bodies
will be elsewhere.
13. Thinking Cap Implementation
class thinking_cap
{
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 these
functions will not change
the data stored in a
thinking_cap.
14. Files for the Thinking Cap
The thinking_cap class
The thinking_cap class
definition, which we have
definition, which we have
just seen, is placed with
just seen, is placed with
documentation in a file called
documentation in a file called
thinker.h
thinker.h, outlined here.
, outlined here.
The implementations of the
The implementations of the
three
three
member functions will be
member functions will be
placed in a separate file
placed in a separate file
called
called thinker.cxx
thinker.cxx, which we
, which we
will examine in a few
will examine in a few
Documentation
Class definition:
•thinking_cap class
definition which we
have already seen
15. Using the Thinking Cap
A program that
A program that
wants to use the
wants to use the
thinking cap
thinking cap
must
must include
include the
the
thinker header
thinker header
file (along with
file (along with
its other header
its other header
inclusions).
inclusions).
#include <iostream.h>
#include <stdlib.h>
#include "thinker.h"
...
16. Using the Thinking Cap
Just for fun, the
Just for fun, the
example program
example program
will declare two
will declare two
thinking_cap
thinking_cap
variables named
variables named
student and fan.
student and fan.
#include <iostream.h>
#include <stdlib.h>
#include "thinker.h"
int main( )
{
thinking_cap student:
thinking_cap fan;
17. Using the Thinking Cap
Just for fun, the
Just for fun, the
example program
example program
will declare two
will declare two
thinking_cap
thinking_cap
objects
objects named
named
student and fan.
student and fan.
#include <iostream.h>
#include <stdlib.h>
#include "thinker.h"
int main( )
{
thinking_cap student;
thinking_cap fan;
18. Using the Thinking Cap
The program
The program
starts by
starts by
calling the
calling the
slots member
slots member
function for
function for
student.
student.
#include <iostream.h>
#include <stdlib.h>
#include "thinker.h"
int main( )
{
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
19. Using the Thinking Cap
The program
The program
starts by
starts by
activating
activating the
the
slots
slots member
member
function
function for
for
student.
student.
#include <iostream.h>
#include <stdlib.h>
#include "thinker.h"
int main( )
{
thinking_cap student:
thinking_cap fan;
student.slots( "Hello", "Goodbye");
20. Using the Thinking Cap
The member
The member
function
function
activation
activation
consists of four
consists of four
parts, starting
parts, starting
with the object
with the object
name.
name.
int main( )
{
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
Name of the object
21. Using the Thinking Cap
The instance
The instance
name is followed
name is followed
by a period.
by a period. int main( )
{
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
A
P
e
r
i
o
d
22. Using the Thinking Cap
After the period
After the period
is the name of
is the name of
the member
the member
function that you
function that you
are activating.
are activating.
int main( ) {
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
Name of the
Function
23. Using the Thinking Cap
Finally, the
Finally, the
arguments for
arguments for
the member
the member
function. In this
function. In this
example the first
example the first
argument
argument
(new_green) is
(new_green) is
"Hello" and the
"Hello" and the
second argument
second argument
(new_red) is
(new_red) is
"Goodbye".
"Goodbye".
#include "thinker.h"
int main( ) {
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
A
r
g
u
m
e
n
t
s
24. A Quiz
How would you
How would you
activate student's
activate student's
push_green
push_green
member function ?
member function ?
What would be the
What would be the
output of student's
output of student's
push_green
push_green
member function
member function
at this point in the
at this point in the
program ?
program ?
int main( )
{
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
25. A Quiz
Notice that the
Notice that the
push_green
push_green member
member
function has no
function has no
arguments.
arguments.
At this point,
At this point,
activating
activating
student.push_green
student.push_green
will print the string
will print the string
Hello
Hello.
.
int main( ) {
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
student.push_green( );
26. A Quiz
Trace through this
Trace through this
program, and tell
program, and tell
me the complete
me the complete
output.
output.
int main( )
{
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
fan.slots( "Go Cougars!", "Boo!");
student.push_green( );
fan.push_green( );
student.push_red( );
. . .
27. A Quiz
Hello
Hello
Go Cougars!
Go Cougars!
Goodbye
Goodbye
int main( )
{
thinking_cap student;
thinking_cap fan;
student.slots( "Hello", "Goodbye");
fan.slots( "Go Cougars!", "Boo!");
student.push_green( );
fan.push_green( );
student.push_red( );
. . .
28. What you know about Objects
Class = Data + Member Functions.
Class = Data + Member Functions.
You know how to define a new class type, and
You know how to define a new class type, and
place the definition in a header file.
place the definition in a header file.
You know how to use the header file in a
You know how to use the header file in a
program which declares instances of the class
program which declares instances of the class
type.
type.
You know how to activate member functions.
You know how to activate member functions.
But you still need to learn how to write the
But you still need to learn how to write the
bodies of a class’s member functions.
bodies of a class’s member functions.
29. Thinking Cap Implementation
class thinking_cap
{
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 bodies
Remember that the member function’s bodies
generally appear in a separate .cxx file.
generally appear in a separate .cxx file.
Function
bodies
will be in
.cxx
file.
30. Thinking Cap Implementation
class thinking_cap
{
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 its
We will look at the body of slots, which must copy its
two arguments to the two private member variables.
two arguments to the two private member variables.
31. Thinking Cap Implementation
void thinking_cap::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 different
For the most part, the function’s body is no different
than any other function body.
than any other function body.
But there are two special features about a
But there are two special features about a
member function’s body . . .
member function’s body . . .
32. Thinking Cap Implementation
In the heading, the function's name is preceded by the
In the heading, the function's name is preceded by the
class name and :: - otherwise C++ won't realize this
class name and :: - otherwise C++ won't realize this
is a class’s member function.
is a class’s member function.
void thinking_cap::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);
}
33. Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}
34. Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}
But, whose member
variables are
these? Are they
student.green_string
student.red_string
fan.green_string
fan.red_string
?
35. Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}
If we activate student.slots:
student.green_string
student.red_string
36. Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}
If we activate
fan.slots:
fan.green_string
fan.red_string
37. Thinking Cap Implementation
void thinking_cap::push_green
{
cout << green_string << endl;
}
Here is the implementation of the push_green
Here is the implementation of the push_green
member function, which prints the green message:
member function, which prints the green message:
38. Thinking Cap Implementation
void thinking_cap::push_green
{
cout << green_string << endl;
}
Here is the implementation of the push_green
Here is the implementation of the push_green
member function, which prints the green message:
member function, which prints the green message:
Notice how this member function implementation
uses the green_string member variable of the object.
39. A Common Pattern
Often, one or more member functions will
Often, one or more member functions will
place data in the member variables...
place data in the member variables...
class thinking_cap {
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 that
data.
slots push_green & push_red
40. Classes have member variables and member
Classes have member variables and member
functions. An object is a variable where the data
functions. An object is a variable where the data
type is a class.
type is a class.
You should know how to declare a new class type,
You should know how to declare a new class type,
how to implement its member functions, how to
how to implement its member functions, how to
use the class type.
use the class type.
Frequently, the member functions of an class type
Frequently, the member functions of an class type
place information in the member variables, or use
place information in the member variables, or use
information that's already in the member variables.
information that's already in the member variables.
In the future we will see more features of OOP.
In the future we will see more features of OOP.
Summary
41. THE END
Presentation copyright 2010, Addison Wesley Longman
Presentation copyright 2010, Addison Wesley Longman
For use with
For use with Data Structures and Other Objects Using C++
Data Structures and Other Objects Using C++
by Michael Main and Walter Savitch.
by Michael Main and Walter Savitch.
Some artwork in the presentation is used with permission from Presentation Task Force
Some artwork in the presentation is used with permission from Presentation Task Force
(copyright New Vision Technologies Inc.) and Corel Gallery Clipart Catalog (copyright
(copyright New Vision Technologies Inc.) and Corel Gallery Clipart Catalog (copyright
Corel Corporation, 3G Graphics Inc., Archive Arts, Cartesia Software, Image Club
Corel Corporation, 3G Graphics Inc., Archive Arts, Cartesia Software, Image Club
Graphics Inc., One Mile Up Inc., TechPool Studios, Totem Graphics Inc.).
Graphics Inc., One Mile Up Inc., TechPool Studios, Totem Graphics Inc.).
Students and instructors who use
Students and instructors who use Data Structures and Other Objects
Data Structures and Other Objects Using C++
Using C++ are
are
welcome to use this presentation however they see fit, so long as this copyright notice
welcome to use this presentation however they see fit, so long as this copyright notice
remains intact.
remains intact.
Editor's Notes
#1:This lecture is an introduction to classes, telling what classes are and how they are implemented in C++. The introduction is basic, not covering constructors or operators that are covered in the text. The best time for this lecture is just before students read Chapter 2--perhaps as early 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.
#2:This lecture will introduce you to object-oriented programming by using one example, which we'll call a "thinking cap".
#3:The important thing about this thinking cap is that there are three actions which may happen to it. The three actions are described here.
#4:Here's an example of how the first action works. Messages are written on two slips of paper, and the messages are inserted in the two slots.
#5:Once the messages have been inserted, either of the buttons may be pressed. When the green button is pressed, the message from the green slip of paper is spoken.
#6:When the red button is pressed, the message from the red slip of paper is spoken.
By the way, what would be an appropriate precondition for pressing the red button? Answer: Before the button is pressed, the slips of paper should be inserted in the slots.
#7:We will implement the thinking cap in C++ using a feature called a class.
#8:The particular class we have in mind has two components that store the two sentences that are inserted in those slots. These components can be declared arrays of characters in C++. As you may know, an array of character can be used in C++ to store a string. In this case, the string may be up to 49 characters (because we must save at least one spot for 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 a C++ class has two new features that are not available in ordinary struct types...
#9:The first class feature is that class components are allowed to be private components. The advantage of private components is that they prevent certain programmers from accessing the components directly. Instead, programmers are forced to use only through the operations that we provide.
#10:In a class, the operations to manipulate the data are actually part of the class itself. A prototype for each function is placed as part of the class definition.
#11:In the jargon of OOP programmers, the class’s functions are called it’s member functions, to distinguish them from ordinary functions that are not part of a class.
#12:The implementations of member functions do not normally appear withing the class definition. We’ll see where they do appear later, but for now, let's just concentrate on this part of the class, which is called the class definition.
#13:One thing that you might have noticed in the definition is a keyword, const, which appears after two of my prototypes. This keyword means that these two functions will not change the data stored in a thinking_cap. In other words, when you do use these two functions, a thinking_cap remains “constant”.
#14:Typically, a class definition is placed in a separate header file along with documentation that tells how to use the new class. The implementations of the member functions are placed in a separate file called the implementation file.
At this point, I still haven't shown you exactly what those three implementations of member functions look like -- and I want to continue to postpone that. Instead, I will next show you an example program which uses this ThinkerCap class.
#15:Any program that uses a class requires an include statement indicating the name of the header file that has the class definition. Note that we include only thinker.h, which is the header file, and do not include the implmentation file.
#16:After the include statement, we may declare and use variables of the thinking_cap data type.
This example actually has two thinking_cap variables, named student and fan.
#17:In object-oriented terminology, we would call these two variables objects of the thinking_cap class.
#18:This illustrates how we call one of the thinking_cap functions for the student object.
#19:But, again, let's use the usual OOP terminology, so that instead of saying that we are calling a function we say that we are activating a member function. In particular, we are activating the slots member function of the student object. (If you go to a cocktail party and tell your OOP friends that today you called a function for an object, they will laugh behind your back. It is better to impress them by saying that you activated a member function, even though it’s just jargon.)
#20:The complete activation consists of four parts, beginning with the object name.
#22:After the period is the name of the member function that you are activating.
#23:And finally there is the argument list. In the case of the slots member function, there are two string arguments: new_green (which is given the actual value "Hello" in this example) and new_red (which is given the actual value "Goodbye" in this example).
#24:Go ahead and write your answers before I move to the next slide.
#25:Remember that the push_green member function does not have any arguments, so the argument list is just a pair of parentheses.
#26:Here's a longer program. What is the complete output? Again, write your answers before I move to the next slide.
#27:The important thing to notice is that student and fan are separate objects of the thinking_cap class. Each has its own green_string and red_string data. Or to throw one more piece of jargon at you: Each has its own green_string and red_string member variables. Member variables are the data portion of a class. The activation of student.slots fills in the green_string and red_string data for student, and the activation of fan.slots fills in the green_string and red_string data for fan.
Once these member variables are filled in, we can activate the push_green and push_red member functions. For example, student.push_green accesses the green_string member variable of student, whereas fan.push_green accesses the green_string member variable of fan.
#28:You now know quite a bit about OOP -- but the key missing piece is how to implement a class’s member functions.
#29:You already know the location of these implementations: in a separate “implementation file” called thinker.cxx.
#30:We'll start by looking at the implementation of the slots member function. The work which the function must accomplish is small: Copy the two arguments (new_green and new_red) to the two private member variables of the object (green_string and red_string).
#31:For the most part, all that's needed is a pair of calls to strcpy to copy the two arguments (new_green and new_red) to the two member variables (green_string and red_string). By the way, how many of you have 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 the strcpy statements work like assignment statements, copying from the right to the left. Also, you might notice that we have checked to make sure 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 special features that you need to know about.
#32:First of all, in the member function’s heading you must include the name 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 thinking_cap class.
#33:Within the body of the member function, we may access any of the members of the object. In this example, we are accessing both the green_string and the red_string member variables, by assigning values to these member variables.
#34:The use of these member variables is a bit confusing. Which member variables are we talking about? student.green_string and student.red_string? Or are we referring to fan.green_string and fan.red_string? Or member variables of some other object?
#35:The answer depends on which object has activated its member function. If student.slots is activated, then these two member variables will refer to student.green_string and student.red_string.
#36:But if fan.slots is activated, then the two member variables refer to fan.green_string and fan.red_string.
#37:Here's the implementation of the push_green member function.
#38:The important thing to notice is how the member function’s implementation uses the green_string member variable of the object. If we activate student.push_green, then the member function will use student.green_string. And if we activate fan.push_green, then the member function will use fan.green_string.
#39:The member functions of the thinking_cap are all simple, but they do illustrate a common pattern: Often a member function (such as slots) will place information in the private member variables, so that other const member functions (such as push_green and push_red) may access the information in those member variables.
#40:A quick summary . . . This presentation has only introduced classes. You should read all of Chapter 2 to get a better understanding of classes. Pay particular attention to the notion of a constructor, which is a special member function that can automatically initialize the member variables of an object. Also pay attention to the more advanced features such as operator overloading with the Point class given in Chapter 2.
![Thinking Cap Implementation
The class will have
The class will have
two components called
two components called
green_string
green_string and
and
red_string
red_string. These
. These
compnents are strings
compnents are strings
which hold the
which hold the
information that is
information that is
placed in the two slots.
placed in the two slots.
Using a class permits
Using a class permits
two new features . . .
two new features . . .
class thinking_cap
{
. . .
char green_string[50];
char red_string[50];
};](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-8-320.jpg)
![Thinking Cap Implementation
The two components
The two components
will be
will be private
private
member variables
member variables.
.
This ensures that
This ensures that
nobody can directly
nobody can directly
access this
access this
information. The
information. The
only access is through
only access is through
functions that we
functions that we
provide for the class.
provide for the class.
class thinking_cap
{
. . .
private:
char green_string[50];
char red_string[50];
};](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-9-320.jpg)
![Thinking Cap Implementation
In a class, the
In a class, the
functions which
functions which
manipulate the class
manipulate the class
are also listed.
are also listed.
class thinking_cap
{
public:
. . .
private:
char green_string[50];
char red_string[50];
};
Prototypes for the
thinking cap
functions go here,
after the word
public:](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-10-320.jpg)
![Thinking Cap Implementation
In a class, the
In a class, the
functions which
functions which
manipulate the class
manipulate the class
are also listed.
are also listed.
class thinking_cap
{
public:
. . .
private:
char green_string[50];
char red_string[50];
};
Prototypes for the
thinking cap
member functions
go here](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-11-320.jpg)
![Thinking Cap Implementation
class thinking_cap
{
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:
Function
bodies
will be elsewhere.](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-12-320.jpg)
![Thinking Cap Implementation
class thinking_cap
{
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 these
functions will not change
the data stored in a
thinking_cap.](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-13-320.jpg)
![Thinking Cap Implementation
class thinking_cap
{
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 bodies
Remember that the member function’s bodies
generally appear in a separate .cxx file.
generally appear in a separate .cxx file.
Function
bodies
will be in
.cxx
file.](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-29-320.jpg)
![Thinking Cap Implementation
class thinking_cap
{
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 its
We will look at the body of slots, which must copy its
two arguments to the two private member variables.
two arguments to the two private member variables.](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-30-320.jpg)
![Thinking Cap Implementation
void thinking_cap::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 different
For the most part, the function’s body is no different
than any other function body.
than any other function body.
But there are two special features about a
But there are two special features about a
member function’s body . . .
member function’s body . . .](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-31-320.jpg)
![Thinking Cap Implementation
In the heading, the function's name is preceded by the
In the heading, the function's name is preceded by the
class name and :: - otherwise C++ won't realize this
class name and :: - otherwise C++ won't realize this
is a class’s member function.
is a class’s member function.
void thinking_cap::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);
}](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-32-320.jpg)
![Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-33-320.jpg)
![Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}
But, whose member
variables are
these? Are they
student.green_string
student.red_string
fan.green_string
fan.red_string
?](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-34-320.jpg)
![Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}
If we activate student.slots:
student.green_string
student.red_string](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-35-320.jpg)
![Thinking Cap Implementation
Within the body of the function, the class’s member
Within the body of the function, the class’s member
variables and other member functions may all be
variables and other member functions may all be
accessed.
accessed.
void thinking_cap::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);
}
If we activate
fan.slots:
fan.green_string
fan.red_string](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-36-320.jpg)
![A Common Pattern
Often, one or more member functions will
Often, one or more member functions will
place data in the member variables...
place data in the member variables...
class thinking_cap {
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 that
data.
slots push_green & push_red](https://image.slidesharecdn.com/chapt02-250220053339-28508cd4/85/object-oriented-programming-concept-ppt-39-320.jpg)
