Today’s Objectives
Structures
• Keeping track of data
• C-style structure
Classes: a Deeper Look, Part 1
• Class
• The public interface
• Encapsulation
• Information hiding
• Constructor
• Destructor
• Separating interface and implementation
• Inline functions
• Default memberwise assignment
1
Structs
Chapter 22.2
2
Structs
Keeping Track of Data
Variables are used to keep track of data in the
computer’s memory.
Regular variable – keeps track of the value of
one data element
Pointer variable – keeps track of the memory
address of a data element
Array – keeps track of a collection of related
data elements of the same data type
3
Structs (Deitel, 1058–1061)
Struct
Struct – keeps track of a collection of related
data elements that may have different data
types
• Each element is called a “member” or “field”
• Each field has a name and data type
Defining a struct
Name
struct Person{
int ID;
string firstName; Fields – always “public”
string lastName;
};
Remember the ‘;’ ! 4
Structs (Deitel, 1058–1061)
Using Structs
The struct’s definition creates a new data type
We can use it to declare a structure variable
Person alan;
To initialize the struct variable, each field can be
accessed by the “.” operator
alan.ID = 1001;
alan.firstName = "Alan";
alan.lastName = "Turing";
cout << alan.firstName << endl;
5
Structs
Dynamically Allocated Structs
We can dynamically create a struct with “new”
Use “new” to allocate memory and return a pointer
Person *pDonald = new Person;
When a pointer is used to get values stored in a struct,
each field must be accessed by the “->” operator
pDonald->ID = 1005;
pDonald->firstName = "Donald";
pDonald->lastName = "Knuth";
cout << pDonald->firstName << endl;
delete pDonald;//Always delete after new
Optional syntax: cout << (*pDonald).firstName;
6
Classes: a Deeper Look, Part 1
Chapter 9
7
Classes, Part 1 (Deitel, 77–110)
Class
Another collection of related data elements that
may have different data types
Like a struct, but better – a class also includes
all the operations that can be performed with its
data
Definition
• Class = a collection of related elements that may
have different data types and the operations that can
be performed on them
8
Classes, Part 1 (Deitel, 77–110)
Declaring a Class
Name
class Person{
public:
Person();
int getID();
void setID( int id );
string getFirstName(); Member functions
void setFirstName( string nm ); (also called methods
string getLastName();
void setLastName( string nm ); or operations)
string toString();
private:
int ID;
string firstName; Data Members
string lastName;
};
Remember the ‘;’ ! 9
Classes, Part 1 (Deitel, 77–110)
Using a Class
Instantiate an object
After a class is declared, it creates a new data
type
We can use it to “declare a variable,” but we use
a different terminology. We say that a class is
used to create an “object” that is an instance of
the class.
Instantiating an object
int main(){
Person donald;
} Object
10
Classes, Part 1 (Deitel, 77–110)
Using an Object
Call the member functions
All of the operations that an object can perform
are defined by its public member functions,
called its “public interface”
int main(){
Person donald;
donald.setFirstName("Donald");
donald.setLastName("Knuth");
cout << donald.toString();
} Argument
Object Parentheses are
“Dot” operator Member required
function
11
Classes, Part 1 (Deitel, 77–110)
The Public Interface
All of the public member functions are collectively called
the “public interface” of the class
The public interface is defined first in the design stage
After the class implementation is finished, the user of the
objects of the class has an outside view, and has access
only to the public interface
• The user knows what the objects of the class can do because
the names of the member functions, the return data type, and
the argument data types are all public
12
Classes, Part 1 (Deitel, 77–110)
Information Hiding
The implementation of the class is not always accessible
• The user does not know how the member functions work and
does not need to know
Data members are always made private
• The user of an object in your program cannot change the data by
accessing it directly
• So that we can control how the data can be changed
– We can validate a requested change
– Example: The ID member cannot be a negative number, it has to be an
integer, and it should not be a number that is already in use
• Also, so we can control how we store the data inside the class
– Example: We may decide to store the ID as a string instead of an int
The user of an object can still get the data and change it, but only by
using a public member function
13
Classes, Part 1 (Deitel, 77–110)
Encapsulation
One of the three principle features of object-oriented
programming
Means that we keep both the data and the
operations that can be done with that data inside a
single entity, the class
In addition, the user of the objects of the class has an
outside view, and has access only to the operations.
14
Classes, Part 1 (Deitel, 77–110)
Advantages
Advantages to encapsulation in a single entity that has a
public interface:
• Teamwork during development is supported – Each member
of the development team can develop a class independently.
When a developer’s class needs to interact with a class
developed by another team member, the first developer only
needs to know its public interface
• Easy to improve your program – The programmer has the
freedom to implement the operations and change them in any
way, as long as the public interface works correctly
• Reuse and program maintenance are easier
– Easier for future programmers to understand the way it works
– Easier to make improvements, e.g. speeding up a searching
function by storing the data in a sorted array instead of an unsorted
array 15
Classes, Part 1 (Deitel, 491)
Private Member Functions
Not all member functions have to be
public
If a member function is only used by
other functions in the class, it can be
private
Called utility functions
16
Classes, Part 1 (Budd)
Message Passing
Using an object’s member functions is called “message
passing”
The user of the object sends a message to the object,
asking it to perform an action
Write the name of the receiver of the message, the dot
operator, the message, and any arguments that are
required
Person james;//instantiating an object
james.setID( 1006 );//sending a message to james
james.setFirstName( "James" );
james.setLastName( "Gosling" );
cout << james.toString() << endl;
17
Classes, Part 1 (Deitel, 77–110, 493–502)
Constructor
Public member function with the same name as the class and with
no return value
Called automatically to initialize the data members whenever an
object is instantiated
Implement it in one of two ways
1. Either assign values in the constructor body
Person( int id = 0, string fn = "", string ln = "" ){
setID(id);
setFirstName(fn); Appropriate if the set function does
setLastName(ln); more than simple assignment
}
2. Or use an initializer list
Person( int id = 0, string fn = "", string ln = "" )
: ID(id), firstName(fn), lastName(ln) { }
Initializer list 18
Classes, Part 1 (Deitel, 77–110, 493–502)
Instantiating an object with
default values
When an object is instantiated, the constructor
automatically initializes the data members
The constructor will initialize the data members to default
values if the object is instantiated with this syntax:
Person james; //Invokes the default constructor
If there is a version of the constructor with parameters,
then the initial values can be passed as arguments
Person james( 1006, "James", "Gosling" );
19
Classes, Part 1 (Deitel, 489)
Inline Functions
Placing the function definition inside the class
declaration instead of defining it externally
Appropriate only for small functions
Program execution is speeded up when member
functions are defined as inline functions
The compiler will have the option of placing the code
for the function inside the main program code instead
of making a function call
20
Classes, Part 1 (Deitel, 486, 489)
Separate Implementation
Outside of and below the declaration of the member function in the
class
Class name Binary scope operator
Return type
Member function name
string Person::toString(){
return firstName + " " + lastName; Implementation
}
21
Classes, Part 1 (Deitel, 486, 489)
Separate Files for
Interface and Implementation
In C++, this is the normal approach
• Declaration goes in the header file (Person.h) – this part is
considered the “interface”
• Definition goes in the source file (Person.cpp) – this part is
considered the “implementation”
main.cpp Person.h Person.cpp
#include "Person.h" #include <string> #include "Person.h"
using std::string; string Person::getName()
int main(){ class Person{ {
Person james; public: return name;
void setName(string);
james.setName("James"); }
string getName();
} private: void Person::setName(string nm)
string name; {
}; name = nm;
}
Advantages
• Smaller header files – header files are included with the source
file
• Developer can hide the implementation details 22
