This document summarizes key concepts from Chapter 2 of the book "Data Structures and Algorithms in C++". It covers object-oriented design principles like inheritance, polymorphism, and templates. It also discusses exceptions, recursion, and design patterns. Specific topics covered include inheritance hierarchies, abstract base classes, class templates, throwing and catching exceptions, and recursive functions.

1. Data Structures and
Algorithms in C++
Michael T. Goodrich Roberto Tamassia David M. Mount
Chapter 2
Object-Oriented Design

2. Contents
• 2.1 Goals and Principles
• 2.2 Inheritance and Polymorphism
• 2.3 Templates
• 2.4 Exceptions
• 2.5 Recursion and Other Design Patterns
• 2.6 Exercises

3. 2.1 Goals and Principles
• Goals
Robustness
Adaptability
Reusability
• Principles
Abstraction
Encapsulation
Modularity

4. 2.2 Inheritance and Polymorphism
2.2.1 Inheritance in C++
class Person {
private:
string name;
string ssn;
public:
//…
void print();
string getName();
};

5. 2.2 Inheritance and Polymorphism
class Student : public Person {
private:
string major;
int gradYear;
public:
//…
void print();
void changeMajor( string newMajor);
};

6. 2.2 Inheritance and Polymorphism
Member Functions
void Person::print() {
cout << “Name “ << name << ‘n’;
cout << “SSN “ << ssn << ‘n’;
}
void Student::print() {
Person::print();
cout << “Major “ << major << ‘n’;
cout << “Year “ << gradYear << ‘n’;
}

7. 2.2 Inheritance and Polymorphism
Protected Members
class <class_name> {
private:
//…
protected:
//…
public:
//…
};

8. 2.2 Inheritance and Polymorphism
Constructors and Destructors
Person::Person(const string &nm, const string &ss)
: name(nm), // initialize name
ssn(ss) { } // initialize ssn
Student::Student(const string &nm, const string &ss,
const string &maj, int year)
: Person(nm, ss), // initialize Person members
major(maj), // initialize member
gradYear(year) { } // initialize graduation year
Student* s = new Student(“John Smith”,”123-45-6789”,”Physics”,2010);
Person::~Person() //Person destructor
{…}
Student::~Student() //Student destructor
{…}
delete s; //calls ~Student() then ~Person()

9. 2.2 Inheritance and Polymorphism
Static Binding
Person* pp[100];
pp[0] = new Person(…);
pp[1] = new Student(…);
cout << pp[1] ->getName() <<‘n’; //okay
pp[0] ->print();
pp[1] ->print();
pp[1] ->changeMajor(“English”); //ERROR!

10. 2.2 Inheritance and Polymorphism
Dynamic Binding and Virtual Functions
class Person {
virtual void print() {….}
//…
};
class Student : public Person {
virtual void print() {….}
//…
};

11. 2.2 Inheritance and Polymorphism
2.2.3 Examples of Inheritance in C++

12. 2.2 Inheritance and Polymorphism
Arithmetic and Geometric Progression Classes

13. 2.2 Inheritance and Polymorphism
A Fibonacci Progression Class

14. 2.2 Inheritance and Polymorphism

15. 2.2 Inheritance and Polymorphism
2.2.4 Multiple Inheritance and Class Casting
class Base {
protected: int foo;
public: int bar;
};
class Derive1 : public Base {
//foo is protected and bar is public
};
class Derive2 : protected Base {
//both foo and bar are protected
};
class Derive3 : private Base {
// both foo and bar are private
};

16. 2.2 Inheritance and Polymorphism
2.2.5 Interfaces and Abstract Classes
class Stack {
public:
bool isEmpty( ) const;
void push(int x);
int pop( );
};

17. 2.2 Inheritance and Polymorphism
Interfaces and Abstract Base Classes
class Stack {
public:
virtual bool isEmpty( ) const = 0;
virtual void push(int x) = 0;
virtual int pop( ) = 0;
};
class ConcreteStack : public Stack {
pribate: //….
public:
virtual bool isEmpty( ) {…}
virtual void push(int x) {…}
virtual int pop( ) {…}
};

18. 2.3 Templates
2.3.1 Function Templates
int min(int a, int b)
{ return (a < b ? a : b); }
template <typename T>
T min( T a, T b)
{ return (a < b ? a : b); }

19. 2.3 Templates
2.3.2 Class Templates
template <typename Object>
class BasicVector {
Object* a;
int capacity;
public:
BasicVector(int capac = 10) {
capacity = capac;
a = new Object[ capacity ];
}
Object& elemAtRank(int r)
{ return a[r]; }
//…
};

20. 2.3 Templates
2.3.2 Class Templates
BasicVector<int> iv(5);
BasicVector<double> dv(20);
BasicVector<string> sv(10);
//…
iv. elemAtRank(3) = 8;
dv. elemAtRank(14) = 2.5;
sv. elemAtRank(7) = “hello”;

21. 2.3 Templates
Templated Arguments
BasicVector<BasicVector<int> > xv(5);
//…
xv. elemAtRank(2). elemAtRank(8) = 15;
Templated Members
template <typename Object>
Object& BasicVector<Object>::elemAtRank(int r) {
return a[r];
}

22. 2.4 Exceptions
2.4.1 Exceptions Object
class MathException {
private:
string errMsg;
public:
MathException(const string& err)
{ errMsg = err; }
};

23. 2.4 Exceptions
Using Inheritance to Define New Exception Types
class ZeroDivideException : public MathException {
public:
ZeroDivideException(const string& err)
: MathException(err) { }
};
class NegativeRootException : public MathException {
public:
NegativeRootException(const string& err)
: MathException(err) { }
};

24. 2.4 Exceptions
2.4.2 Throwing and Catching Exceptions
try {
if (divisor == 0 )
throw ZeroDivideException(“Divide by zero in
Module X”);
}
catch (ZeroDivideException& zde) {
//…
}
catch (MathException& me) {
//…
}

25. 2.4 Exceptions
2.4.3 Exceptions Specification
void calculator( ) throw(ZeroDivideException,
NegativeRootException ) {
//function body…
}

26. 2.4 Exceptions
Generic Exception Class
class RuntimeException {
private:
string errorMsg;
public:
RuntimeException( const string& err)
{errorMsg = err; }
string getMessage() const { return errorMsh; }
};
inline std::ostream& operator <<(std::ostream& out,
const RuntimeException& e)
{ return out << e.getMessage(); }

27. 2.5 Recursion and Other Design Patterns
int recursiveFactorial(int n) {
if (n==0) return 1;
else return n*recursiveFactorial(n-1);
}

28. 2.6 Exercises
• R-2.11
• R-2.12