<aside> 💡 Recall: aggregation eg. parts in a catalogue, ducks in a pond

Typical Implementation: Pointer fields

class Pond {
	Duck *ducks[MaxDucks];
	...
}

Case Study: Does a pointer field always mean non-ownership?

• No! Let’s take a close look at lists & nodes

  

  • Then a List owns the first Node:

  

  • But these ownerships are implemented with ptrs
  • Another view of Lists & Nodes:

  

  • We could new the List object as owning all of the Nodes within it. What might this suggest about the impl. of Lists & Nodes in this case?
    • Likely - List is taking responsibility copying and construction/desctruction of all Nodes, rather than Node
    • Possible iteration (i.e. loop-based) management of ptrs vs. recursive routines when Nodes nabaged other Nodes. </aside>

<aside> 💡 Inheritance (Specialization)

Suppose you want to track a collection of Books

class Book {
	string title, author;
	int length; // # of pages in a book
public:
	Book(_________);
	...

};

// For textbooks - also a topic:
class Text {
	string title, author;
	int length;
	string topic;
public:
	Text(__________);
	...
};

// For comic books, want the name of the hero:
class Comic {
	string title, author,
	int length;
	string hero;
public:
	Comic(__________);
	...
};

This is OK - but doesn’t capture the relationship among Book, Text, Comic

And how do we create an array (or List) that contains a mixture of these?

(the body for the class Comic)

</aside>

<aside> 💡 Could

1. Use a union

union BookTypes{Book *b; Text *t; Comic *c;};
BookTypes myBooks[20];

1. Array of void * - ptr to anything

• Not good solutions - break the type system

Rather, observe: Texts & Comics are kinds of Books - Books with extra features.

To model in C++ - Inheritance

</aside>

// Bases clss (or **Superclass**)
class Book { 
	string title, author;
	int length;
public:
	Book(________);
	...
};

// Derived classes (or **Subclasses**)
class Text {
	string topic;
public:
	Text(________);
	...
};

class Comic: public Book {
	string hero;
public:
	Comic(________);
	...
};

<aside> 💡 Derived classes inherit fields & methods from the base class

• So Text, comic get title, author, length, fields
• Any method that can be called on Book can be called on Text, comic </aside>

Who can see these members?

• title, author, length - private in Book - outsiders can’t see them
• Con Text, comic see them? → NO!

How do we initialize Text? Need title, author, length, topic (title, author, length initialize Book part)

class Text:public Book {
	...
public:
	Text(string title, string author, int length, string topic):
			title{title}, author{author}, length{length}, topic{topic}{}
	...
};

Wrong!! for 2 reasons

1. title, etc., not accessible in Text(and even if they were, the MIL only lets your mention your own fields)
2. Once ahainm when an object it created:
   1. Space is allocated
   2. Superclass part is constructed New!
   3. Fields constructed
   4. Ctor body runs

So a ctor for Book must run before the fields of Text can be initialized

<aside> 💡 If Book has no default ctor, a ctor for Book must be invoked explicitly:

class Text:public Book {
	...
public:
	Text(string title, string author, int length, string topic):
		Book{title, author, length}, topic{topic}{}
// |_________ Step 2 _________|  |_ Step 3 _||_| <- Step 4
	...
};

</aside>

<aside> 💡 Good reasons to keep superclass fields inaccessible to subclasses:

• If you want to give subclasses access to certain members:

  protected access:
  
  class Book {
  protected:
  	string title, author; // accessble to Book & its subclasses,
  	int length;           // to no one else
  public:
  	Book(________);
  	...
  };
  
  class Text:public Book {
  	...
  public:
  	...
  	void addAuthor(string new Author) {author += newAuthor;}
  };
  
  

  • Not a good idea to give subclasses unlimited access to fields

  Better: keep fields private, provide protected accessors/mutators

  class Book {
  	string title, author;
  	int length;
  protected:
  	string getTitle() const;           // subclasses can
  	void setAuthor(string newAuthor);   // call these
  public:
  	Book(________);
  	bool isHeavy() const;
  };
  

  Relationship among Text, Comic, Book - called “is - a”

  • A Text is a Book
  • A Comic is a Book

  

</aside>

Now consider the method is Heavy - when is a Book heavy?

• for ordinary books - > 200 pages
• for Texts - > 500 pages
• for Comics > 30 pages

class Book {
...
protected:
	int length;
public:
	bool isHeavy() const {return length > 200;}
};

class Comic:public Book {
	...
public:
	...
	bool isHeavy() const {return length > 30;}
	...
};
etc.