Distributed Real-Time Control Systems. Chapter 13 C++ Class Hierarchies

Transcription

1 Distributed Real-Time Control Systems Chapter 13 C++ Class Hierarchies 1

2 Class Hierarchies The human brain is very efficient in finding common properties to different entities and classify them according to their properties or behaviour. Example: Mammals summarizes a large set of properties common to a class of animals (have dorsal spine, warm blood, feed from mother s milk in infanthood, etc.). This way, many efforts are saved in the classification and attribute assignment to different animals. How can we do this in C++? 2

3 Designing a Database System Imagine a factory of wooden blocks for kids wants to store their products in a database and be able to display their mass (weight) when queried. Initially the factory produces cylinders and cubes but wants a system that can incorporate new shapes. Cylinder Cube Other?... 3

4 The Cylinder Class FILE simple_cylinder.h #ifndef SIMPLE_CYLINDER_H #define SIMPLE_CYLINDER_H #include <iostream> //need std::cout using namespace std; constexpr double PI {3.1415; //needed to compute the area of the base class SimpleCylinder { float _r, _h, _d; // private: radius, height and density public: SimpleCylinder (float r, float h, float d) // constructor definition (inline) : _r {r, _h {h, _d {d { // initialization of member variables cout << Creating SimpleCylinder << endl; ~SimpleCylinder() { // destructor definition (inline) std::cout << Destroying SimpleCylinder << endl; float CalcMass() { //member function (inline) return PI*_r*_r*_h*_d; ; #endif //SIMPLE_CYLINDER_H 4

5 Sidenote: Const and Constexpr Two ways to define constants: Compile time constant expressions (constexpr) Expression that can be computed at compile time. Use when initializations are time consuming : initialization at compile time are done once, rather than every time the program runs. Run time constants (const) A constant that must be initialized at run time (possibly not known at compile time). Use when need non-modifiable variables to be initialized with run-time data. Const s or Constexpr s are preferred to aliases (#define ) because they have explicit type checking. What is the problem with the following code? #define LENGTH 3... cout << LENGTH/2 << endl; EXAMPLES: const int dmv = 17; //dmv is named constant int var = 17; //var is not a constant constexpr double square(double x) { return x x; //constexpr function constexpr double max1=4 square(dmv); //OK. 4*square(dmv) is a constexpr constexpr double max2= 4 square(var); // error: var is not a constant expression const double max3 = 4 square(var); // OK, may be evaluated at run time 5

6 The Cube Class FILE simple_cube.h #ifndef SIMPLE_CUBE_H #define SIMPLE_CUBE_H #include <iostream> //need std::cout using namespace std; class SimpleCube{ float _s, _d; // private: side lenght and material density, resp. public: SimpleCube (float s, float d) // constructor definition (inline) : _s {s, _d{d { // initialization of member variables cout << Creating SimpleCube\n << endl; ~SimpleCube() { // destructor definition (inline) std::cout << Destroying SimpleCube << endl; float CalcMass() { //member function (inline) return _s*_s*_s*_d; ; #endif //SIMPLE_CUBE_H 6

7 Using Cubes and Cylinders FILE simple_blocks.cpp #include <iostream> //need std::cout using namespace std; #include simple_cube.h #include simple_cylinder.h int main() { SimpleCylinder obj1 {2.0,1.0,0.9; SimpleCube obj2 {3.0,0.9; float m1 = obj1.calcmass(); float m2 = obj2.calcmass(); float M = m1+m2; cout << Total Mass << M << endl; Encapsulation: Instead of explicitly computing the mass, our code just asks the class to do the job for us. The client code does not need to know how its mass is computed. The client code does not need to care about how the cylinder class stores data internally. In the future, the class developer can change the class implementation (e.g. to increase efficiency) without breaking the client code. Compile with: g++ -std=c++11 I. simple_blocks.cpp o simple_blocks 7

8 Problems with this approach To add a new object type, we have to rewrite it from scratch. If we want to add a price field to all the blocks, we have to change all classes. Cannot have a collection of arbitrary blocks because their types may differ. 8

9 The Hierarchy Object oriented programming help us think about hierarchies of objects, from the more general to the more specific classes. Having a Solid class representing the common things among all blocks, solves the problems mentioned in the previous slide. How? More general - Superclass Solid Cube Sphere More specific - Subclass 9

10 Inheritance Definition (Inheritance): Inheritance is the mechanism that allows one class A get the properties of another class B. In this case we say that A inherits from B. Objects from class A can access the attributes and methods from class B without having to redefine them. The following definition introduces two terms that deal with the concept of inheritance between classes. Solid (B) Cube (A) Inherit-from Definition (Superclass/Subclass): Case class A inherits from class B, then B is called a Superclass of A. A is denoted the subclass of B. 10

11 The Superclass Also called base class. All solids have density. Let us also add a Constructor and Destructor; Note 1: The density variable (float _d) is protected. This means clients cannot access this variable but derived classes can. Note 2: A constructor is defined. This deletes the default constructor. Since the provided constructor demandsan argument (the solid density) and does not provide a default value, it is not possible to create an empty Solid object. #ifndef SOLID1_H #define SOLID1_H #include <iostream> using namespace std; FILE solid1.h class Solid { protected: //must be used by subclasses float _d; public: Solid( float d ) : _d {d { cout << Creating Solid << endl; ~Solid() { cout << Destroying Solid << endl; ; #endif // SOLID1_H 11

12 The Subclasses Also called derived classes FILE cylinder1.h #ifndef CYLINDER1_H #define CYLINDER1_H #include solid1.h constexpr double PI {3.1415; class Cylinder : public Solid { float _r, _h; public: Cylinder (float r, float h, float d) : _r {r, _h {h, Solid {d { cout<< Creating Cylinder <<endl; ~Cylinder() { cout << DestroyingCylinder <<endl; float CalcMass(){return PI*_r*_r*_h*_d; ; #endif //CYLINDER1_H #ifndef CUBE1_H #define CUBE1_H #include solid1.h FILE cube1.h class Cube : public Solid { float _s; public: Cube (float s, float d) : _s {s, Solid{d { cout << Creating Cube <<endl; ~Cube() { cout << Destroying Cube << endl; float CalcMass(){return _s*_s*_s*_d; ; #endif //CUBE1_H 12

13 Access Protection Inheritance class Cube : public Solid { /* members of Solid maintain the protection level in Cube*/ ; class Cube : protected Solid { /* public members in Solid become protected in Cube, others remain */ ; class Cube : private Solid { /* all members of Solid become private in Cube */ ; It is saidthat class Cube inherits from Solid. Cube can access all members of Solid independently of their protection level. Access public protected private members of the same class members of derived classes not members yes yes yes yes yes no yes no no 13

14 Base Class Initialization Note the base class is initialized in the constructor of the derived classusing member initializer lists. FILE cylinder.h FILE cube.h... Cylinder (float r, float h, float d) : _r {r, _h {h, //member variable init Solid {d //base class init { std::cout << Creating Cylinder\n ; Cube (float s, float d) : _s {s, //member variable init Solid{d //base class init { stc::cout << Creating Cube\n ;... 14

15 Memory Profiles Cylinder (12 bytes) Solid (4 bytes) float _d; Cube (8 bytes) Solid (4 bytes) float _d; float _r; float _s; float _h; 15

16 Construction and Destruction of Derived Objects Constructors are invoked in order from the base classes to the derived classes. Destructors are invoked from the derived classes to the base classes. Objects are destroyed in the inverse order of their creation. What is the output of the following code? FILE blocks1.cpp #include cube1.h #include cylinder1.h int main() { Cube cube {3.0, 0.9; Cylinder cyl {2.0, 1.0, 1.1; Output: Creating Solid Creating Cube Creating Solid Creating Cylinder Destroying Cylinder Destroying Solid Destroying Cube Destroying Solid 16

17 Friend Classes and Functions The friend qualifier allows access to protected or private fields to other classes or functions. Let us define a function Density that accesses the member density of any solid. Let us define a function SameVol that tests if a Cube and a Cylinder have the same volume. //friends.h #include cube1.h #include cylinder1.h float Density(Solid &s) { return s._d; bool SameVol(Cube &a, Cylinder &b) { return a._s*a_s*a._s == PI*b._r*b._r*b._h; These functions must access private data of the solid, cylinder and cube objects, so they must be declared friends in the Corresponding classes. //in class Solid friend float Density(Solid &); //In cylinder1.h class Cube; //forward class declaration //in class Cylinder friend bool SameVol(Cube &, Cylinder &); //In cube1.h class Cylinder; //forward class declaration //in class Cylinder friend bool SameVol(Cube &, Cylinder &); 17

18 Polymorphism We can invoke the function float Density(Solid &) with arguments of the derived classes. This is an example of Polymorphism: a function can accept object of different types. The mechanism allowing this type of polymorphism iscalled Upcasting. FILE blocks1.cpp #include "cube1.h" #include "cylinder1.h" #include "friends.h" int main() { Cube cube {3.0, 0.9; Cylinder cyl {2.0, 1.0, 1.1; cout << Density(cube) << endl; cout << Density(cyl) << endl; Output: Creating Solid Creating Cube Creating Solid Creating Cylinder Destroying Cylinder Destroying Solid Destroying Cube Destroying Solid 18

19 Upcasting and Slicing UPCASTING: A pointer or reference to a derived class can be converted automatically to a pointer or reference of one of its the base classes. Cube cube {3.0, 0.9; Solid &rsolid = cube; //ok - upcasting float f = Density(cube); //ok - upcasting Cylinder &cyl = rs; //not ok: compile error Solid solid {0.8; solid = cube; //ok but dangerous - slicing OBJECT SLICING: An object of a derived class can be sliced into an object of a base class. This is legal but dangerous, because the base object data looses access to derived object data and functions. Use with caution. cube (8 bytes) rsolid (4 bytes) float _d = 0.9; float _s = 3.0; solid (4 bytes) float _d = 0.9; 19

20 Copy and Move Operators The Solid, Cube and Cylinder classes do not manage resources, so they do not need special copy/move constructor/assignment operators. For the sake of teaching C++, let s assume that indeed they have resources to manage, and define their special copy/move constructor/assignment operators. Let us first do this for the base class. We say we make the class move aware. Note: for lack of space, the display functions (cout s) are omitted. class Solid { protected: float _d; public: Solid(float d) : _d {d {... Solid(const Solid & s) : _d {s._d {... Solid(Solid && s) : _d {std::move(s._d) {... Solid & operator=(const Solid & s) { if(this!= &s) {_d = s._d; return *this; Solid & operator=(solid && s) { if(this!= &s) {_d = std::move(s._d); return *this; ~Solid() {... friend float Density(Solid &); ; 20

21 Copy and Move at Derived Classes The invocation of base class (Solid) copy/move constructors and assignment operators is not automatic, must be done explicitly. //COPY CONSTRUCTOR Cube(const Cube & c ) : Solid{c //base class initialization { _s = c._s; //copy cube s part //MOVE CONSTRUCTOR Cube(const Cube && c ) : Solid{std::move(c) //base class initialization { _s = std::move(c._s); //move cube s part //COPY ASSIGNMENT Cube & operator= (const Cube & c ) { if ( this == &c) return (*this) ; Solid::operator=(c); //base class assignment _s = c._s; return (*this); //MOVE ASSIGNMENT Cube & operator= (const Cube && c ) { if ( this == &c) return (*this) ; Solid::operator=(std::move(c)); _s = std::move(c._s); return (*this); 21

22 Private Constructors and Sometimes objects should not be cloned. E.g. when holding unique resources in the system. To prevent object cloning, the copy constructor and the assignment operator should be made private. Cloning can only be done by member functions. Alternativelly, they can be marked as deleted. In this case their cloning is impossible Other member functions can be deleted, e.g. to prevent implicit type conversion in constructors. Deleted Functions // class with private clone operations class A { private: A (const A &); A& operator = (const A & );... ; // class with deleted clone operations class B { A (const A &) = delete; A& operator = (const A & ) = delete; ; //class with deleted contructor for int class C { public: C (double); //can initialize from double C (int) = deleted; //but not from int 22