20. Inheritance and Polymorphism

Transcription

1 (Expression) Trees 20. Inheritance and Polymorphism Expression Trees, Inheritance, Code-Reuse, Virtual Functions, Polymorphism, Concepts of Object Oriented Programming bend fork 3 -(3-(4-5))*(3+4*5)/6 fork / leaf root 6 parent (w.r.t. 3, ) child (w.r.t. +) 4 5 child (w.r.t. ) Nodes: Forks, Bends or Leaves 690 Nodes (struct tree ) 691 / 6 Value operator tree_ / left operand right operand tree_ struct tree_ { char op; // leaf : op is = // internal : op is +,, or / tree_ left; // == nullptr for unary minus tree_ right; * = 6 : unused tree_(char o, double v, tree_ l, tree_ r) : op(o), val(v), left(l >copy()), right(r >copy()) { // Copy constructor: previous lecture; handout/codeboard ;

2 Size = Count Nodes in Subtrees 696 Count Nodes in Subtrees Size of a leave: 1 Size of other s: 1 + sum of child s size E.g. size of the "+"- is 5 // POST: returns the size (number of s) of // the subtree with root this int tree_::size () const { int s=1; if (left) // shortcut for left!= nullptr s += left >size(); if (right) s += right >size(); return s; Evaluate Subtrees 694 Cloning Subtrees 695 // POST: evaluates the subtree with root this double tree_::eval () const { if (op == = ) return val; leaf... double l = 0;... or fork: if (left) l = left >eval(); op unary, or left branch double r = right >eval(); right branch if (op == + ) return l + r; if (op == ) return l r; if (op == ) return l r; if (op == / ) return l / r; return 0; // POST: a copy of the subtree with root this is // made, and a pointer to its root is // returned tree_ tree_::copy () const { tree_ to = new tree_ (op, val, nullptr, nullptr); if (left) to >left = left >copy(); if (right) to >right = right >copy(); return to;

3 Cloning Subtrees more Compact Notation 700 Felling Subtrees 701 // POST: a copy of the subtree with root this is // made, and a pointer to its root is // returned tree_ tree_::copy () const { return new tree_ (op, val, left? left >copy() : nullptr, right? right >copy() : nullptr); cond? expr1 : expr 2 has value expr1, if cond holds, expr2 otherwise // POST: all s in the subtree with root // this are deleted void tree_::clear() { if (left) { left >clear(); if (right) { + right >clear(); 3 delete this; Using Expression Trees 698 Observations 699 // Construct a tree for 1 ( (3 + 7)) tree_ n1 = new tree_( =, 3, nullptr, nullptr); tree_ n2 = new tree_( =, 7, nullptr, nullptr); tree_ n3 = new tree_( +, 0, n1, n2); tree_ n4 = new tree_(, 0, nullptr, n3); tree_ n5 = new tree_( =, 1, nullptr, nullptr); tree_ root = new tree_(, 0, n5, n4); // Evaluate the overall tree std::cout << "1 ( (3 + 7)) = " << root >eval() << \n ; Class tree_ is the "sum" of all required s Holds for the data representation struct tree_ { char op; tree_ left; tree_ right; // Evaluate a subtree std::cout << "3 + 7 = " << n3 >eval() << \n ;

4 Observations I 704 Disadvantages I 705 Class tree_ is the "sum" of all required s and the code double tree_::eval () const { if (op == = ) if (op == + ) Data representation: Waste of memory Code: Implementation of different evals (and sizes, copys, ) in one member function Increased complexity results in convoluted and thus more error-prone code But: every object (instance of the class) represents exactly one Objects "specialiase themselves" via if statements Observations II 702 Observations II 703 Scenario: extension of the expression tree by mathematical functions abs, sin, avg: Scenario: extension of the expression tree by mathematical functions abs, sin, avg: extension of the class tree_ by even more member variables struct tree_ { char op; // new: op = f > function std::string name; // function name; std::vector<tree_ > children; // for avg Adaption of every single member function double eval () const { else if (op == f ) if (name == "abs") return std::abs(right >eval());

5 Disadvantages II Inheritance: the Idea New types entail modifications of already existing code Consequences: Code complexity and error-proneness increases further Customers/users must have access to source code (originally: distributing libraries as header files plus object files) Split-up of tree_ "is-a" relation: number_ is a xtree_ Specialisation happens top-down: a derived class* may provide more functionality than its base class** Common properties stay in more general ("higher") classes number minus xtree unary binary abs 1) also: child class/sub class 2) also: parent class, superclass Inheritance: the Code 706 Inheritance: Notation 707 struct xtree_ { virtual int size() const = 0; virtual double eval() const = 0; ; erbt von struct number_ : public xtree_ { only for number_ int size () const; double eval () const; ; inheritance visible members of xtree_ are implemented by number_ Erzwingt Impl. in Kindklassen class A { class B: public A{ class C: public B{ Base/Super Class Subclass B and C inherit from A C inherits from B

6 Separation of Concerns: The Number Node A Number Node is a Tree Node... struct number_: public xtree_ { number_ (double v) : val (v) { return val; A (pointer to) an inheriting object can be used where (a pointer to) a base object is required, but not vice versa. number_ num = new number_ (5); xtree_ tn = num; // ok, number_ is // just a special xtree_ int size () const { return 1; ; xtree_ bn = new add_ (tn, num); // ok number_ nn = tn; //error: invalid conversion Polymorphism 710 Separation of Concerns: Binary Nodes 711 struct xtree_ { virtual double eval() = 0; ; double number_::eval() { xtree_ n = new number_(3); std :: cout << n >eval(); // 3 Without Virtual the static type determines which function is executed We do not go into further details 712 struct binary_: public xtree_ { xtree_ left; xtree_ right; binary_ (xtree_ l, xtree_ r) : left (l >copy()), right (r >copy()) { assert (left); size works for all binary assert (right); s. Derived classes (add_,sub_... ) inherit this function! int size () const { return 1 + left >size() + right >size(); ; 713

7 Separation of Concerns: +, -, * Separation of Concerns: +, -, * struct add_: public binary_ { add_ (xtree_ l, xtree_ r) : binary_(l, r) { struct sub_: public binary_ { sub_ (xtree_ l, xtree_ r) : binary_ (l, r) { eval specific for + return left >eval() + right >eval(); ; return left >eval() right >eval(); ; Extension by abs Function 714 Extension by abs Function 715 xtree struct unary_: public xtree_ { xtree_ right; unary number binary unary_ (xtree_ r): right(r >copy()) { assert(right); int size () const { return 1 + right >size(); ; struct abs_: public unary_ { abs_ (xtree_ arg): unary_ (arg) { abs minus add sub mul div 716 return std::abs (right >eval()); ; 717

8 Mission: Monolithic Modular 720 Summary of the Concepts 721 struct tree_ { char op; tree_ left; tree_ right; double eval () const { if (op == = ) return val; else { double l = 0; if (left!= 0) l = left >eval(); double r = right >eval(); if (op == + ) return l + r; if (op == ) return l r; if (op == ) return l r; if (op == / ) return l / r; assert (false); // unknown operator return 0; int size () const { void clear() { tree_ copy () const { ; + struct number_: public xtree_ { return val; ; struct minus_: public unary_ { return right >eval(); ; struct minus_ : public binary_ { return left >eval() right >eval(); struct abs_ : public unary_ { return left >eval() right >eval();.. of Object Oriented Programming Encapsulation (previous two lectures) hide the implementation details of types definition of an interface for access to values and functionality (public area) make possible to ensure invariants and the modification of the implementation Summary of Concepts 718 Summary of Concepts of Object Oriented Programming.. of Object Oriented Programming Inheritance Polymorphism types can inherit properties of types inheriting types can provide new properties and overwrite existing ones allows to reuse code and data A pointer (or reference) may, depending on its use, have different underlying types the different underlying types can react differently on the same access to their common interface makes it possible to extend libraries non invasively