Object-Oriented Programming
in C++
Lecture 2
Classes and Objects
Introduction
Last lecture we
• introduced the module
• introduced C++
This lecture we will
• review the concept of classes and objects
• discuss their representation using UML
class diagrams
• implement and use a simple C++ class
• introduce C++ structures and enumeration
types
Classes and objects
• a class is a programmer-created data type
• it can have member variables (attributes)
– to hold data
• and member functions (methods)
– to manipulate that data
• an object is an instance of a class
– with specific values for the member variables
• normally the member variables are private
– hidden within the object
• we interact with the object via its public methods
• encapsulation
Example – Account class
• consider a class to represent a bank account
• what data do we need to store about a bank
account?
– account balance
– interest rate
• what functions are needed to manipulate this
data?
– get the balance, deposit money, withdraw money,
calculate and add the interest
– create an account with a given initial balance and
interest rate
• each bank account object will have its own
balance
– and interest rate in this example
UML class diagrams
• UML (the Unified Modelling language)
defines 13 standard diagrams for system
modelling
• the class diagram is a useful way to
represent a class
– its member variables and methods
– their type and visibility
• UML diagrams can have different levels of
detail
– from initial ideas (analysis) to implementationlevel documentation
UML diagram of an Account
Account
balance
interest rate
create account
get balance
deposit money
withdraw money
add interest
• the diagram has 3 sections
• the class name is at the top
• the variables are in the
middle
• the functions are at the
bottom
• this is an analysis-level
diagram
• what should the
implementation-level diagram
look like?
Implementation-level diagram of
an Account
Account
-balance: double
-interestRate: double
+Account(initalBalance: double,
rate: double)
+getBalance() : double
+deposit(amount: double)
+withdraw(amount: double)
+addInterest()
• the member visibility
is shown by:
- private
+ public
# protected
• the type of each
member is shown
after the member
name
C++ implementation of the
Account class
class Account {
private: // optional because members are private by default
double balance; // amount of money held by this account
double interestRate; // a monthly or yearly interest rate
public:
// create an account with an initial amount and a specified interest rate
Account(double initialBalance, double rate) : balance(initialBalance),
interestRate(rate){ }
// return the account's balance
double getBalance(){ return balance;}
// add money to the account
void deposit(double amount) {
balance += amount;
} // continued on next slide
C++ implementation of the
Account class
void withdraw(double amount) {
// implement this method yourself
}
// add money according to the interest rate.
void addInterest() {
balance *= (1 + interestRate/100.0);
// this is the same as balance = balance * (1 +
(interestRate/100) );
}
};
Using the Account class
• create a project
• put the Account class code into a header
file called account.h
– this is the account class definition
• create a source file called bank.cpp
– this will contain the main method
– which will create and test an Account object
bank.cpp
#include <iostream>
#include "account.h"
using namespace std;
void main(void)
{
Account stdAccount(100, 4);
// create an account with £100and 4% interest rate
stdAccount.addInterest();
cout << "Balance: " << stdAccount.getBalance()<< endl;
stdAccount.deposit(50);
cout << "Balance: " << stdAccount.getBalance()<< endl;
stdAccount.withdraw(100);
cout << "Balance: " << stdAccount.getBalance()<< endl;
}
#include directives
#include <iostream>
#include "account.h"
• iostream is a library file
– the angled brackets indicate the file is in the C++
library directory
– path should already been set up in IDE
• account.h was written by the programmer
• the quotes indicate the file path and name
• in this case, it is in the same directory as
bank.cpp
Constructors
• the constructor is called when an object is
first created
– sets up the object in memory
– with space for the member variables
• if the class does not have a constructor, a
default no-argument constructor is used
• a constructor must have the same name
as the class
– and no return value
Account constructor
• the constructor initialises the member variables
balance and interestRate
Account(double initialBalance, double rate) :
balance(initialBalance),interestRate(rate) { }
• this is equivalent to the Java-like constructor
Account(double initialBalance, double rate) {
balance = initialBalance;
interestRate = rate;
}
• the first version initialises the member variables as they
are created
• the second creates the member variables
– then assigns them values within the constructor body
– less efficient
Destructors
• a destructor is called when the object is destroyed
– goes out of scope or is deleted
• a destructor has the same name as the class,
preceded by a ~
– it cannot have any parameters or return value
– it is called automatically – never call it yourself
– a destructor for the Account class:
~Account() {
cout << "Closing the account. Final
balance: " << balance << endl;
}
C++ structures
• C++ structures are similar to classes
– they can have member variables and functions
– however all members are public by default
• no encapsulation
– an Account struct could have its balance changed
directly
– rather through the deposit and withdraw
methods
• structs are useful to group together related
data
Example structures
struct Point3D {
float x;
float y;
float z;
};
int main() {
Point3D A = { 10, 5.3, 6};
Point3D B;
B.x = 2.1;
B.y = 2.4;
B.z = 7.3;
//....
}
Enumeration types
• another useful programmer-defined type is the
enumeration
• defines all possible values of a given type
enum colour {
RED,ORANGE,YELLOW,GREEN,BLUE,VIOLET
};
int main() {
colour hatColour = ORANGE;
colour shirtColour = VIOLET;
// ....
}
• each enum value maps to an integer
• RED is 0, ORANGE is 1….
• less error-prone than using strings or constants
Summary
In this lecture we have
• reviewed the concept of classes
• discussed their representation using UML class
diagrams
• implemented and used a simple C++ class
• introduced C++ structures and enumeration types
In the tutorial we will
• implement the Account class
• add more functionality and a menu-driven
interface
Further reading
• Object Management Group – UML Resource
Page http://www.uml.org/
• MSDN library – C++ language reference
– Classes, structures and unions
http://msdn.microsoft.com/en-us/library/4a1hcx0y.aspx