Object-Oriented Programming

and Data Structures

COMP2012: Data Abstraction & Classes

Gary Chan
Brian Mak
Desmond Tsoi

Department of Computer Science & Engineering

The Hong Kong University of Science and Technology
Hong Kong SAR, China

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.1

 Part I

A Revision Example: Person and Family

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.2

A Revision Example: Person & Family
It consists of the class Person, from which families are built.
A person, in general, has at most 1 child, and his/her father
and mother may or may not be known.
The information of his/her family includes him/her and
his/her parents and grandparents from both of his/her
parents.

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.3

Revision Example: Expected Output
Name: Arthur
Father: unknown
Mother: unknown
Grand Fathers: unknown, unknown
Grand Mothers: unknown, unknown

Name: Becky
Father: unknown
Mother: unknown
Grand Fathers: unknown, unknown
Grand Mothers: unknown, unknown

Name: Claire
Father: Arthur
Mother: Becky
Grand Fathers: unknown, unknown
Grand Mothers: unknown, unknown

Name: Eddy
Father: unknown
Mother: Claire
Grand Fathers: unknown, Arthur
Grand Mothers: unknown, Becky

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.4

Revision Example: Person Class — Header File
#include <iostream> /* File: person.h */
using namespace std;

class Person
{
private:
char* _name;
int _age;
Person *_father, *_mother, *_child;

public:
Person(const char* my_name, int my_age, Person* my_father = nullptr,
Person* my_mother = nullptr, Person* my_child = nullptr);
˜Person();

Person* father() const;

Person* mother() const;
Person* child() const;
void have_child(Person* baby) ;
void print_age() const;
void print_name() const;
void print_family() const;
};

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.5

Revision Example: Person Class — Implementation File

#include "person.h" /* File: person.cpp */

#include <cstring>

Person::Person(const char* my_name, int my_age, Person* my_father,

Person* my_mother, Person* my_child)
{
_name = new char [strlen(my_name)+1];
strcpy(_name, my_name);
_age = my_age;
_father = my_father;
_mother = my_mother;
_child = my_child;
};

Person::˜Person() { delete [] _name; }

Person* Person::father() const { return _father; }

Person* Person::mother() const { return _mother; }

Person* Person::child() const { return _child; }

void Person::have_child(Person* baby) { _child = baby; }

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.6
Revision Example: Person Class — Implementation File ..

void Person::print_age() const { cout << _age; }

void Person::print_name() const

{
cout << (_name ? _name : "unknown");
}

// Helper function
void print_parent(Person* parent)
{
if (parent)
parent->print_name();
else
cout << "unknown";
}

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.7

Revision Example: Person Class — Implementation File ..
void Person::print_family() const
{
Person *f_grandfather = nullptr, *f_grandmother = nullptr,
*m_grandfather = nullptr, *m_grandmother = nullptr;

if (_father) {
f_grandmother = _father->mother();
f_grandfather = _father->father();
}

if (_mother) {
m_grandmother = _mother->mother();
m_grandfather = _mother->father();
}

cout << "Name: "; print_name(); cout << endl;

cout << "Father: "; print_parent(_father); cout << endl;
cout << "Mother: "; print_parent(_mother); cout << endl;

cout << "Grand Fathers: "; print_parent(f_grandfather);

cout << ", "; print_parent(m_grandfather); cout << endl;
cout << "Grand Mothers: "; print_parent(f_grandmother);
cout << ", "; print_parent(m_grandmother); cout << endl;
}
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.8
Revision Example: Family Building Test Program

#include "person.h" /* File: family.cpp */

int main()
{
Person arthur("Arthur", 65, nullptr, nullptr, nullptr);
Person becky("Becky", 63, nullptr, nullptr, nullptr);
Person claire("Claire", 32, &arthur, &becky, nullptr);
Person eddy("Eddy", 4, nullptr, &claire, nullptr);

arthur.have_child(&claire);
becky.have_child(&claire);
claire.have_child(&eddy);

arthur.print_family(); cout << endl;

becky.print_family(); cout << endl;
claire.print_family(); cout << endl;
eddy.print_family(); cout << endl;
return 0;
}

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.9

 Part II

Data Abstraction

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.10

Data Abstraction: What is a Chair?

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.11

Data Abstraction: What is a Stack?

A data abstraction is a simplified view of an object that

includes only features one is interested in while hides away the
unnecessary details.
In programming languages, a data abstraction becomes an
abstract data type or a user-defined type.
In OOP, it is implemented as a class.

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.12

Example: Implement a Stack with an Array

1 data

3
size
top

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.13

Example: Implement a Stack with a Linked List

top

-999

top
(latest item)

-999 1 2

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.14

Information Hiding

An abstract specification tells us the behavior of an object

independent of its implementation.
It tells us what an object does independent of how it works.

Information hiding is also known as data encapsulation, or

representation independence.

The Principle of Information Hiding

Design a program so that the implementation of an object can be
changed without affecting the rest of the program.

E.g., changing the implementation of a stack from an array to

a linked list has no effect on users’ programs.

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.15

Example: A Stack Implementation Using an Array
#include <iostream> /* File: array-int-stack.h */
using namespace std;
const int BUFFER_SIZE = 1000;

class Stack
{
private:
int data[BUFFER_SIZE]; // Use an array to store data
int top_index; // Starts from 0; -1 when empty

public:
// CONSTRUCTOR member functions
Stack(); // Default constructor

// ACCESSOR member functions: const => won't modify data members

bool empty() const; // Check if the stack is empty
bool full() const; // Check if the stack is full
int size() const; // Give the number of data currently stored
int top() const; // Retrieve the value of the top item

// MUTATOR member functions

void push(int); // Add a new item to the top of the stack
void pop(); // Remove the top item from the stack
};
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.16
Example: A Stack Implementation Using a Linked List
#include <iostream> /* File: ll-int-stack.h */
using namespace std;

struct ll_inode
{
int data;
ll_inode* next;
};

class Stack
{
private:
ll_inode* head; // head of a linked list of int's
public:
// CONSTRUCTOR member functions
Stack(); // Default constructor
// ACCESSOR member functions: const => won't modify data members
bool empty() const; // Check if the stack is empty
bool full() const; // Check if the stack is full
int size() const; // Give the number of data currently stored
int top() const; // Retrieve the value of the top item
// MUTATOR member functions
void push(int); // Add a new item to the top of the stack
void pop(); // Remove the top item from the stack
};
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.17
Information Hiding Again

In reality, a third party app programmer who wants to use the

stack class is given only the following from the class developer:

1 the stack class header .h file

2 a binary hardware-specific class library .a file of the stack
implementation
3 class documentation about the use of its various public
member functions of the stack class

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.18

Structure vs. Class
In C++, structures are special classes and they may have member
functions. By default,

struct { . . . } ≡ class { public: . . . }

class { . . . } ≡ struct { private: . . . }

const int BUFFER_SIZE = 1000; /* File: stack-struct.h */

struct Stack
{
int data[BUFFER_SIZE]; // Use an array to store data
int top_index; // Starts from 0; -1 when empty

Stack(); // Default constructor

bool empty() const; // Check if the stack is empty
bool full() const; // Check if the stack is full
int size() const; // Give the number of data currently stored
int top() const; // Retrieve the value of the top item
void push(int); // Add a new item to the top of the stack
void pop(); // Remove the top item from the stack
};

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.19

 Part III

C++ Class Basics & this Pointer

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.20

Class Name: Name Equivalence

A class definition introduces a new abstract data type.

C++ relies on name equivalence (and not structure
equivalence) for class types.

class X { int a; };
class Y { int a; };
class W { int a; };
class W { int b; }; // Error, double definition

X x;
Y y;

x = y; // Error: type mismatch

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.21

Class Data Members

Data members can be any basic type, or any user-defined types if

they are already declared.

Below are special cases:

A class name can be used inside its own definition for a

pointer to an object of the class:

class Cell
{
int info;
Cell* next;
};

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.22

Class Data Members ..

A forward declaration of a class X can be used in the

definition of another class Y to define a pointer to X:

class Cell; // Forward declaration of Cell

class Stack
{
int size;
Cell* data; // Points to a (forward-declared) Cell object
Cell x; // Error: Cell not defined yet!
};

class Cell // Definition of Cell

{
int info;
Cell* next;
};

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.23

Default Initializer for Non-static Members (C++11)
class Complex
{
private:
float real = 1.3; // Note: not allowed before C++11
float imag {0.5}; // Use either = or { } initializer
public:
...
};

You are advised to initialize non-static data member values by

class constructors
class member initialization list in a constructor
class member functions
Non-static data members that are not initialized by the 3
ways above will have the values of their default member
initializers if they exist, otherwise their values are undefined.
We’ll talk about static vs. non-static members later. All data
members you’ll see most of the time are non-static.
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.24
Class Member Functions
These are the functions declared inside the body of a class.
They can be defined in two ways:

1. Within the class body, then they are inline functions. The
keyword inline is optional in this case.
class Stack
{
...
void push(int x) { if (!full()) data[++top_index] = x; }
void pop() { if (!empty()) --top_index; }
};
Or,
class Stack
{
...
inline void push(int x) { if (!full()) data[++top_index] = x; }
inline void pop() { if (!empty()) --top_index; }
};
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.25
Class Member Functions ..

2. Outside the class body, then add the prefix consisting of the
class name and the class scope operator ::
(Any benefits of doing this?)
/* File: stack.h */
class Stack
{
...
void push(int x);
void pop();
};

/* File: stack.cpp */
void Stack::push(int x) { if (!full()) data[++top_index] = x; }
void Stack::pop() { if (!empty()) --top_index; }

Question: Can we add data and function declarations to a class

after the end of the class definition?
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.26
Class Scope and Scope Operator ::

C++ uses lexical (static) scope rules: the binding of name

occurrences to declarations are done statically at compile-time.
Identifiers declared inside a class definition are under its scope.
To define the members functions outside the class definition,
prefix the identifier with the class scope operator ::
e.g., Stack::push(), Stack::pop()

int height = 10;

class Weird
{
short height;
Weird() { height = 5; }
};

Q1 : Which “height” is used in Weird::Weird( )?

Q2 : Can we access the global height inside the Weird class body?
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.27
Inline Functions

Function calls are expensive because when a function is called,

the operating system has to do a lot of things behind the
scene to make that happens.
int f(int x) { return 4*x*x + 9*x + 1; }
int main() { int y = f(5); }

For small functions that are called frequently, it is actually

more efficient to unfold the function codes at the expense of
program size (both source file and executable).
int main() { int y = 4*5*5 + 9*5 + 1; }

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.28

Inline Functions ..

But functions have the benefit of easy reading, easy

maintenance, and type checking by the compiler.
You have the benefits of both by declaring the function inline.
inline int f(int x) { return 4*x*x + 9*x + 1; }
int main() { int y = f(5); }

However, C++ compilers may not honor your inline

declaration.
The inline declaration is just a hint to the compiler which still
has the freedom to choose whether to inline your function or
not, especially when it is large!

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.29

Inline Class Member Functions
Class member functions defined inside the class definition
body are automatically treated as inline functions.
To enhance readability, one may also define them outside the
class definition but in the same header file.

/* File: stack1.h */ /* File: stack2.h */

class Stack class Stack
{ {
... ...
inline void pop() inline void pop();
{ };
if (!empty())
--top_index; inline void Stack::pop()
} {
}; if (!empty()) --top_index;
}

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.30

Member Access Control
A member of a class can be:

1 public: accessible to anybody (class developer and application

programmers)
2 private: accessible only to
member functions, and
friends of the class (decided by the class developer)
⇒ class developer enforces information hiding
3 protected: accessible to
member functions and friends of the class, as well as
member functions and friends of its derived classes
(subclasses)
⇒ class developer restricts what subclasses may directly use
(more about this when we talk about inheritance)

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.31

Example: Member Access Control

class Stack /* File: access_control.cpp */

{
private:
int data[BUFFER_SIZE];
int top_index;
public:
void push(int);
...
};

int main()
{
Stack x;
x.push(2); // OK: push( ) is public
cout << x.top_index; // Error: cannot access top_index
return 0;
}

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.32

How Are Objects Implemented?

Each class object gets

Stack x:
its own copy of the top_index
class data members. data
Stack y: top_index
All objects of the same
class share one copy of data

the member functions.

int main()
{
Stack x(2), y(3);
push( )
x.push(1);
y.push(2); pop( )
y.pop();
}

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.33

This Pointer

Each class member function implicitly contains a pointer of its

class type named “this”.
When an object calls the function, this pointer is set to point
to the object.
For example, after compilation, the Stack::push(int x)
function in the Stack class will be translated to a unique
global function by adding a new argument:
void Stack::push(Stack* this, int x)
{
if (!this->full())
this->data[++(this->top_index)] = x;
}

a.push(x) becomes Stack::push(&a, x).

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.34

Example: Return an Object by this — complex.h
class Complex /* File: complex.h */
{
private:
float real; float imag;

public:
Complex(float r, float i) { real = r; imag = i; }
void print() { cout << "(" << real << " , " << imag << ")" << endl; }

Complex add1(const Complex& x) // Return by value

{
real += x.real; imag += x.imag;
return (*this);
}
Complex* add2(const Complex& x) // Return by value using pointer
{
real += x.real; imag += x.imag;
return this;
}
Complex& add3(const Complex& x) // Return by reference
{
real += x.real; imag += x.imag;
return (*this);
}
};
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.35
Example: Return an Object by this — complex-test.cpp
#include <iostream> /* File: complex-test.cpp */
using namespace std;
#include "complex.h"

int main()
{
Complex y(3, 4); y.print();

cout << endl << "Return by value" << endl;

Complex x(1, 2); x.print();
x.add1(y).add1(y).print();
x.print();

cout << endl << "Return its pointer by value" << endl;
x.add2(y)->print();
x.print();

cout << endl << "Return by reference" << endl;

Complex z(1, 2); z.print();
z.add3(y).add3(y).print();
z.print();

return 0;
}
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.36
Return by Value and Return by Reference
There are 2 ways to pass parameters to a function
pass-by-value (PBV)
pass-by-reference (PBR)
lvalue reference: that is what you learned in the past and
we’ll keep just saying reference for lvalue reference.
rvalue reference (C++11)
Similarly, you may return from a function by returning an object’s
value: the function will make a separate copy of the object
and return it. Changes made to the copy have no effect on
the original object.
(lvalue) reference: the object itself is passed back! Any
further operations on the returned object will directly modify
the original object as it is the same as the returned object.
rvalue reference: we’ll talk about this later.
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.37
 Part IV

const-ness

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.38

const

const, in its simplest usage, is used to express a user-defined

constant — a value that can’t be changed.
const float PI = 3.1416;
Some people like to write const identifiers in capital letters.
In the old days, constants are defined by the #define
preprocessor directive:
#define PI 3.1416
Question: Any shortcomings?
const actually may be used to represent more than just
numerical constants, but also const objects, pointers, and
even member functions!
The const keyword can be regarded as a safety net for
programmers: If an object should not change, make it const.

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.39

Example: Constants of Basic Types

#include <iostream> /* File: const-basic-types.cpp */

#include <cstdlib> // Needed for calling rand() etc.
using namespace std;

int main() // To generate 5 random integers in [0, 100] inclusive

{
const int N = 5; // Number of integers to generate
const int MAX_NUM = 100; // Max integer

// Seed the random number generator by current time

srand(time(0));

for (int j = 0; j < N; ++j)

cout << rand() % (MAX_NUM+1) << endl;

return 0;
}

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.40

Example: Constant Object of User-defined Types

/* File: const-object-date.h */

class Date // There are problems with this code; what are they?
{
private:
int year, month, day;

public:
Date() { cin >> year >> month >> day; }
Date(int y, int m, int d) { year = y; month = m; day = d; }

void add_month() { month += 1; }; // Will be an inline function

int difference(const Date& d)

{ /* Incomplete: write this function */ }

void print()
{ cout << year << "/" << month << "/" << day << endl; }
};

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.41

Example: Constant Object of User-defined Types ..
#include <iostream> /* File: const-object-date.cpp */
using namespace std;
#include "const-object-date.h"

int main() // There are problems with this code; what are they?
{
const Date WW2(1945, 9, 2); // World War II ending date
Date today;
WW2.print();
today.print();

// How long has it been since World War II?

cout << "Today is " << today.difference(WW2)
<< " days after WW2" << endl;

// What about next month?

WW2.add_month(); // Error; do you mean today.add_month()??
cout << today.difference(WW2) << " days by next month.\n";

return 0;
}
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.42
const Member Functions

To indicate that a class member function does not modify the

class object — its data member(s), one can (and should!)
place the const keyword after the argument list.

class Date /* File: const-object-date2.h */

{
private:
int year, month, day;

public:
Date() { cin >> year >> month >> day; }
Date(int y, int m, int d) { year = y; month = m; day = d; }
void add_month() { month += 1; }; // Will be an inline function

int difference(const Date& d) const { /* Incomplete */ }

void print() const
{ cout << year << "/" << month << "/" << day << endl; }
};

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.43

const Member Functions and this Pointer

A const object can only call const member functions of its

class.
But a non-const object can call both const and non-const
member functions of its class.
The this pointer in const member functions points to const
objects. For example,

B int Date::difference(const Date& d) const; is compiled to

int Date::difference(const Date* this, const Date& d);

B void Date::print() const; is compiled to

void Date::print(const Date* this);

Thus, the object calling const member function becomes

const inside the function and cannot be modified.
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.44
const and const Pointers
When a pointer is used, two objects are involved:
the pointer itself
the object being pointed to
The syntax for pointers to constant objects and constant
pointers can be confusing. The rule is that
any const to the left of the ∗ in a declaration refers to
the object being pointed to.
any const to the right of the ∗ refers to the pointer itself.
It can be helpful to read these declarations from right to left.
/* File: const-char-ptrs1.cpp */
char c = 'Y';
char *const cpc = &c;
char const* pcc;
const char* pcc2;
const char *const cpcc = &c;
char const *const cpcc2 = &c;
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.45
Example: const and const Pointers
#include <iostream> /* File: const-char-ptrs2.cpp */
using namespace std;

int main()
{
char s[] = "COMP2012"; // Usual initialization in the past
char p[] {"MATH1013"}; // C++11 style of uniform initialization

const char* pcc {s}; // Pointer to constant char

pcc[5] = '5'; // Error!
pcc = p; // OK, but what does that mean?

char *const cpc = s; // Constant pointer

cpc[5] = '5'; // OK
cpc = p; // Error!

const char *const cpcc = s; // const pointer to const char

cpcc[5] = '5'; // Error!
cpcc = p; // Error!
return 0;
}
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.46
const and const Pointers ..

Having a pointer-to-const pointing to a non-const object doesn’t

make that object a constant!
/* File: const-int-ptr.cpp */
int i = 151;
i += 20; // OK

int* pi = &i;
*pi += 20; // OK

const int* pic = &i;

*pic += 20; // Error! Can't change i through pic

pic = pi; // OK
*pic += 20; // Error! Can't change *pi thru pic

pi = pic; // Error: Invalid conversion from 'const int*' to 'int*'

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.47

const References as Function Arguments

There are 2 good reasons to pass an argument as a reference.

What are they?
You can (and should!) express your intention to leave a
reference argument of your function unchanged by making it
const.
There are 2 advantages:

1. If you accidentally try to modify the argument in your

function, the compiler will catch the error.
void cbr(int& x) { x += 10; } // Fine

void cbcr(const int& x) { x += 10; } // Error!

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.48

const References as Function Arguments ..
2. You may pass both const and non-const arguments to a
function that requires a const reference parameter.
Conversely, you may pass only non-const arguments to a
function that requires a non-const reference parameter.
#include <iostream>
using namespace std;
void cbr(int& a) { cout << a << endl; }
void cbcr(const int& a) { cout << a << endl; }
int main()
{
int x {50}; const int y {100};
// Which of the following give(s) compilation error?
cbr(x);
cbcr(x);
cbr(y);
cbcr(y);
cbr(1234);
cbcr(1234);
}
{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.49
Pointer vs. Reference

Reference can be thought as a special kind of pointer, but there

are 3 big differences:
1 A pointer can point to nothing (nullptr), but a reference is
always bound to an object.
2 A pointer can point to different objects at different times
(through assignments). A reference is always bound to the
same object.
Assignments to a reference does not change the object it
refers to but only the value of the referenced object.
3 The name of a pointer refers to the pointer object. The * or
-> operators have to be used to access the object.
The name of a reference always refers to the object. There
are no special operators.

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.50

Summary: Good Practice

Objects you don’t intend to change ⇒ const objects

const double PI = 3.1415927;
const Date handover(1, 7, 1997);

Function arguments you don’t intend to change

⇒ const arguments
void print_height(const Large_Obj& LO){ cout << LO.height(): }

Class member functions that don’t change the data members

⇒ const member functions
int Date::get_day() const { return day; }

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.51

Summary

Regarding which objects can call const or non-const member

functions:
const non-const
Calling Object
Member Function Member Function
√
const Object X
√ √
non-const Object

Regarding which objects can be passed to functions with

const or non-const arguments:
const non-const
Passing Object
Function Argument Function Argument
√
literal constant X
√
const Object X
√ √
non-const Object

{gchan, mak, desmond}@cse.ust.hk COMP2012 (Spring 2018) p.52