diff --git a/notebooks/10_Polymorphic_Classes.ipynb b/notebooks/10_Polymorphic_Classes.ipynb
index df655b198c5ed6c63d80d33f1fb87d8a5999ec1b..9cd604421edd7d7403de0c1615cbbb0a73aa9cfe 100644
--- a/notebooks/10_Polymorphic_Classes.ipynb
+++ b/notebooks/10_Polymorphic_Classes.ipynb
@@ -13,7 +13,7 @@
"id": "7ec80016",
"metadata": {},
"source": [
- "We return to our example from [Go19] and extend it a little."
+ "We return to our example from <a href=\"https://www.hanser-kundencenter.de/fachbuch/artikel/9783446458468\">[Go19]</a> and extend it a little."
]
},
{
@@ -41,7 +41,7 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 2,
"id": "f40024e2",
"metadata": {},
"outputs": [],
@@ -64,7 +64,7 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 3,
"id": "459a1ce0",
"metadata": {},
"outputs": [],
@@ -95,7 +95,7 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 4,
"id": "5ff4684f",
"metadata": {},
"outputs": [],
@@ -127,7 +127,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 5,
"id": "aebeaf35",
"metadata": {},
"outputs": [
@@ -156,7 +156,7 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 6,
"id": "445c4d28",
"metadata": {},
"outputs": [
@@ -187,7 +187,7 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 7,
"id": "4b596bd2",
"metadata": {},
"outputs": [],
@@ -240,7 +240,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 8,
"id": "12bebbf9",
"metadata": {},
"outputs": [
@@ -302,7 +302,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 9,
"id": "ccb162c8",
"metadata": {
"scrolled": true
@@ -378,7 +378,7 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 10,
"id": "99352379",
"metadata": {},
"outputs": [],
@@ -407,10 +407,193 @@
"secretary->all_info();"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "80e7e3b3",
+ "metadata": {},
+ "source": [
+ "Especially in larger code bases it can be come tedious to not loose the overview on which member functions are virtual and which are not. Or whether we are overriding the correct version of a method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "bd457522",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#include <iostream>\n",
+ "\n",
+ "struct A {\n",
+ " void func1() { std::cout << \"A::func1 is executing\" << std::endl; };\n",
+ " virtual void func2( double a ) { std::cout << \"func2 from A: a = \" << a << std::endl; }; \n",
+ "};\n",
+ "\n",
+ "\n",
+ "struct B : public A {\n",
+ " void func1() { std::cout << \"B::func1 is executing\" << std::endl; };\n",
+ " virtual void func2( int a ) { std::cout << \"func2 from B: a = \" << a << std::endl; };\n",
+ "};"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "4a0a85ba",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "A::func1 is executing\n",
+ "func2 from A: a = 2\n"
+ ]
+ }
+ ],
+ "source": [
+ "A* obj = new B;\n",
+ "obj->func1();\n",
+ "obj->func2( 2 );"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6414fc0e",
+ "metadata": {},
+ "source": [
+ "`A::func1` is not virtual, so we don't overide and while `A::func2` is virtual, the interface of `B::func2` is different.\n",
+ "\n",
+ "A smart compiler might warn us on the latter:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "3c824171",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Writing fail.cpp\n"
+ ]
+ }
+ ],
+ "source": [
+ "%%file fail.cpp\n",
+ "\n",
+ "#include <iostream>\n",
+ "\n",
+ "struct A {\n",
+ " void func1() { std::cout << \"A::func1 is executing\" << std::endl; };\n",
+ " \n",
+ " virtual void func2( double a ) { std::cout << \"func2 from A: a = \" << a\n",
+ " << std::endl; }; \n",
+ "};\n",
+ "\n",
+ "\n",
+ "struct B : public A {\n",
+ " void func1() { std::cout << \"B::func1 is executing\" << std::endl; };\n",
+ " virtual void func2( int a ) { std::cout << \"func2 from B: a = \" << a\n",
+ " << std::endl; };\n",
+ "};"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "29c729c5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "fail.cpp:14:16: warning: 'B::func2' hides overloaded virtual function [-Woverloaded-virtual]\n",
+ " virtual void func2( int a ) { std::cout << \"func2 from B: a = \" << a\n",
+ " ^\n",
+ "fail.cpp:7:16: note: hidden overloaded virtual function 'A::func2' declared here: type mismatch at 1st parameter ('double' vs 'int')\n",
+ " virtual void func2( double a ) { std::cout << \"func2 from A: a = \" << a\n",
+ " ^\n",
+ "1 warning generated.\n"
+ ]
+ }
+ ],
+ "source": [
+ "!clang++ -Wall -Wextra -c fail.cpp"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6774e9d0",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "413b3e71",
+ "metadata": {},
+ "source": [
+ "### Pure Virtual Functions and Abstract Classes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ebb14ead",
+ "metadata": {},
+ "source": [
+ "Consider the following application scenario:\n",
+ "\n",
+ "- We want to implement four specialised matrix classes\n",
+ " - `DenseMatrix`\n",
+ " - `DenseSymMatrix`\n",
+ " - `SparseMatrix`\n",
+ " - `SparseSymMatrix`\n",
+ "- They all should be children of a common `BaseMatrix` base class.\n",
+ "- All of them should provide a method `multWithVector()` with the same signature.\n",
+ "- We want to be able to invoke that method on a base class pointer or reference.\n",
+ "\n",
+ " This gives rise to the following questions:\n",
+ " 1. How should `BaseMatrix::multWithVector()` be implemented?\n",
+ " 1. Can we enforce that someone who adds another child, say `DenseSkewMatrix` does not forget to implement `DenseSkewMatrix::multWithVector()`?\n",
+ "\n",
+ "A sensible implementation of `BaseMatrix::multWithVector()` will not be possible, as the base class has no knowledge on the details of how its children store their matrices. We could only do an empty implementation or one that e.g. throws an exception. The latter would at least lead to a runtime crash, if we call `multWithVecotr()` on a base class pointer or reference that targets a `DenseSkewMatrix`.\n",
+ "\n",
+ "The preferred solution, however, would be to make `BaseMatrix::multWithVector()` a **pure virtual function**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "3069e8e2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Vector;\n",
+ "\n",
+ "class BaseMatrix {\n",
+ " virtual void multWithVector( const Vector& src, Vector& dst ) const = 0;\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ec47a18b",
+ "metadata": {},
+ "source": [
+ "* A pure virtual function has no implementation in the class where it is declared. It only describes an **interface**.\n",
+ "* Adding a pure virtual function to a class makes it an **abstract class**, i.e. we cannot instantiate an object of that class.\n",
+ "* The same holds for its children (via inheritance), as long as they do not implement the method."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
- "id": "9f63ea43",
+ "id": "24c9d364",
"metadata": {},
"outputs": [],
"source": []