added review03-24 for chapter12

trapperdot00 · trapperdot00 · commit ee5379e5fa62 · 2025-03-30T17:48:27.000+02:00
diff --git a/Chapter12/README.md b/Chapter12/README.md
@@ -32,3 +32,70 @@ What is an application domain?
 
 ## [Review 2](review/02.txt)
 What are ideals for naming?
+
+## [Review 3](review/03.txt)
+What can we name?
+
+## [Review 4](review/04.txt)
+What services does a `Shape` offer?
+
+## [Review 5](review/05.txt)
+How does an abstract class differ from a class that is not abstract?
+
+## [Review 6](review/06.txt)
+How can you make a class abstract?
+
+## [Review 7](review/07.txt)
+What is controlled by access control?
+
+## [Review 8](review/08.txt)
+What good can it do to make a data member `private`?
+
+## [Review 9](review/09.txt)
+What is a virtual function and how does it differ from a non-virtual function?
+
+## [Review 10](review/10.txt)
+What is a base class?
+
+## [Review 11](review/11.txt)
+What makes a class derived?
+
+## [Review 12](review/12.txt)
+What do we mean by object layout?
+
+## [Review 13](review/13.txt)
+What can you do to make a class easier to test?
+
+## [Review 14](review/14.txt)
+What is an inheritance diagram?
+
+## [Review 15](review/15.txt)
+What is the difference between a `protected` member and a `private` one?
+
+## [Review 16](review/16.txt)
+What members of a class can be accessed from a class derived from it?
+
+## [Review 17](review/17.txt)
+How does a pure virtual function differ from other virtual functions?
+
+## [Review 18](review/18.txt)
+Why would you make a member function virtual?
+
+## [Review 19](review/19.txt)
+Why would you not make a member function virtual?
+
+## [Review 20](review/20.txt)
+Why would you make a virtual member pure?
+
+## [Review 21](review/21.txt)
+What does overriding mean?
+
+## [Review 22](review/22.txt)
+Why should you always suppress copy operations for a class in a class hierarchy?
+
+## [Review 23](review/23.txt)
+How does interface inheritance differ from implementation inheritance?
+
+## [Review 24](review/24.txt)
+What is object-oriented programming?
+
diff --git a/Chapter12/review/03.txt b/Chapter12/review/03.txt
@@ -0,0 +1,2 @@
+We can name member functions, data members of our classes and our types.
+It is important to give meaningful names for public members of our types.
diff --git a/Chapter12/review/04.txt b/Chapter12/review/04.txt
@@ -0,0 +1,6 @@
+Shape is an abstract class that provides the general interface of a graphical object,
+along with the common implementation for visible objects, such as color, line style, etc.
+ - It ties our graphical objects to a Window.
+ - It deals with color and style for our lines and fills.
+ - It holds a sequence of points but leaves it up to our classes to interpret them.
+ - It provides a draw_specifics() function that derived classes must define (since it is a pure virtual function).
diff --git a/Chapter12/review/05.txt b/Chapter12/review/05.txt
@@ -0,0 +1,3 @@
+An abstract class differs from a concrete (non-abstract) class
+in that it is impossible to create an object of an abstract type.
+An abstract class can only be used as a base class.
diff --git a/Chapter12/review/06.txt b/Chapter12/review/06.txt
@@ -0,0 +1,3 @@
+We can make abstract classes by declaring a pure virtual function
+or by making its constructors protected so as to only allow
+derived classes to call it.
diff --git a/Chapter12/review/07.txt b/Chapter12/review/07.txt
@@ -0,0 +1,14 @@
+Access control dictates who has access to class members:
+There are three access groups:
+ - Public:
+	accessible by:
+		- own members
+		- derived class' members
+		- other code
+ - Protected:
+	accessible by:
+		- own members
+		- derived class' members
+ - Private:
+	accessible by:
+		- own members
diff --git a/Chapter12/review/08.txt b/Chapter12/review/08.txt
@@ -0,0 +1,5 @@
+By making a data member private, we make sure that the state of the object
+is valid, since users can only use the public interface to change its values,
+which manages the invariant.
+Also we prevent user code from breaking by accessing members through a well-defined
+interface, not directly, when making changes to our classes by encapsulating the representation.
diff --git a/Chapter12/review/09.txt b/Chapter12/review/09.txt
@@ -0,0 +1,6 @@
+A virtual function is a member function whose definition can be overridden by derived classes.
+Virtual functions are looked up at run-time, when calling the base class' function by the same name,
+the derived class' function will be called based on its dynamic type.
+Non-virtual functions on the other hand are called at compile-time, based on the static type of the object.
+Classes with virtual functions have an additional, hidden member, a vptr, that points to a vtable,
+a container that keeps track of the available virtual functions' definitions for the current type.
diff --git a/Chapter12/review/10.txt b/Chapter12/review/10.txt
@@ -0,0 +1,2 @@
+A base class is a class that a derived class inherits its members from through inheritance.
+A base class is also called a superclass, a derived class is also called a subclass.
diff --git a/Chapter12/review/11.txt b/Chapter12/review/11.txt
@@ -0,0 +1,2 @@
+Specifying the base class to inherit from through inheritance makes a class derived from its base.
+The derived class gets all of the members of its base.
diff --git a/Chapter12/review/12.txt b/Chapter12/review/12.txt
@@ -0,0 +1,5 @@
+Object layout is the layout of the objects in memory.
+Data members are stored contiguously, next to each other,
+in derived classes, first the base's members, then the derived's members are stored.
+In classes with virtual functions, there is also another member, a vptr (virtual pointer),
+that points to a vtbl (virtual function table) as the last member.
diff --git a/Chapter12/review/13.txt b/Chapter12/review/13.txt
@@ -0,0 +1,2 @@
+We can explicitly tell the compiler to override specific functions in derived classes,
+and it will throw an error upon encountering an unmatched override.
diff --git a/Chapter12/review/14.txt b/Chapter12/review/14.txt
@@ -0,0 +1,2 @@
+An inheritance diagram is a graphical illustration of the class hierarchy.
+It shows the direct base classes and derived classes for each class in the figure.
diff --git a/Chapter12/review/15.txt b/Chapter12/review/15.txt
@@ -0,0 +1,3 @@
+The difference between a protected member and a private member is that
+a protected member can be accessed from the class' own members and derived class' members,
+whereas private members can only be accessed from its own members.
diff --git a/Chapter12/review/16.txt b/Chapter12/review/16.txt
@@ -0,0 +1 @@
+Only public and protected members can be accessed from a class derived from it.
diff --git a/Chapter12/review/17.txt b/Chapter12/review/17.txt
@@ -0,0 +1,4 @@
+A pure virtual function is a virtual member function without a definition,
+classes with pure virtual functions are abstract classes, meaning that we can't
+directly create objects of those types, we can only use them as base classes.
+Other virtual functions provide definitions.
diff --git a/Chapter12/review/18.txt b/Chapter12/review/18.txt
@@ -0,0 +1,6 @@
+We would use virtual member functions so as to allow its usage
+through the interfaces provided by its base.
+The base knows about the virtual functions, and it is determined
+at run-time which function is called, according to the object's dynamic type.
+This allows us to modify the behaviour of our objects while keeping the interfaces
+the same.
diff --git a/Chapter12/review/19.txt b/Chapter12/review/19.txt
@@ -0,0 +1,2 @@
+We would not make a member function virtual if we didn't want derived classes
+to override the selected function.
diff --git a/Chapter12/review/20.txt b/Chapter12/review/20.txt
@@ -0,0 +1,2 @@
+We would make a virtual member a pure virtual function so as to make an abstract class
+and let derived classes provide their own definitions for the function.
diff --git a/Chapter12/review/21.txt b/Chapter12/review/21.txt
@@ -0,0 +1,3 @@
+Overriding means that a derived class provides its own definition for a virtual function
+inherited from its base class, and when calling the function through the base class'
+interface, it will call the derived class' function, which is looked up at run-time.
diff --git a/Chapter12/review/22.txt b/Chapter12/review/22.txt
@@ -0,0 +1,8 @@
+We should suppress copy operations for the base class in a class hierarchy
+so as to disallow assignment of derived classes of differing types,
+and preventing object slicing.
+For example, if Shape had defined copy operations, we could assign
+a Rectangle to a Circle, because their bases are common, and due to
+polymorphism, the copy operation that takes a constant reference to
+a Shape is called, and effectively only the Shape part of the object
+is assigned to the other.
diff --git a/Chapter12/review/23.txt b/Chapter12/review/23.txt
@@ -0,0 +1,2 @@
+Interface inheritance allows functions expecting a base class to accept any of its derived classes.
+Implementation inheritance allows derived classes to use the base class' members as well as its own members.
diff --git a/Chapter12/review/24.txt b/Chapter12/review/24.txt
@@ -0,0 +1,11 @@
+Object-oriented programming consists of
+ - Inheritance
+ 	- we can build a class from another so that it can be used in place of the base class
+ - Run-time polymorphism
+ 	- we can define virtual functions which we can override in derived classes
+	- we can call a virtual function from a base class, and the derived class' function will be executed,
+		which is looked up at run-time from the vtable
+ - Encapsulation
+ 	- we can keep the implementation members private or protected to prevent users from directly accessing
+		and modifying the implementation, invalidating the state of our objects
+	- we can provide a public interface to interact with the implementation in well-defined ways

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+We can name member functions, data members of our classes and our types.`
	`2`	`+It is important to give meaningful names for public members of our types.`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+An abstract class differs from a concrete (non-abstract) class`
	`2`	`+in that it is impossible to create an object of an abstract type.`
	`3`	`+An abstract class can only be used as a base class.`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+We can make abstract classes by declaring a pure virtual function`
	`2`	`+or by making its constructors protected so as to only allow`
	`3`	`+derived classes to call it.`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+A base class is a class that a derived class inherits its members from through inheritance.`
	`2`	`+A base class is also called a superclass, a derived class is also called a subclass.`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+Specifying the base class to inherit from through inheritance makes a class derived from its base.`
	`2`	`+The derived class gets all of the members of its base.`