Object-Oriented Programming: Inheritance Basics

Part III: Inheritance

• Inheritance is a technique in object-oriented programming.
• It allows one class to inherit properties from another.
• Base classes provide foundational elements, derived classes build upon them.
• Derived classes can add or modify existing features.

Basic Cases

• Diagrams illustrate different shape classes (Square, Rectangle, Circle, Triangle).
• Each shape has attributes like center point, width, height, radius.
• Methods (functions) like draw, get_center, get_sides and erase are associated with each shape.

Look more closer

• Tables demonstrate attributes and methods for each shape class.
• Attributes typically begin with an underscore (_).
• Shape-specific methods, illustrated as a table, include the get_center, draw, erase methods.

Class hierarchy

• Diagrams show inheritance hierarchy among shape classes.
• Figure is a base class, with derived classes like Square, Rectangle, Circle, Triangle, Polygon.
• Methods are inherited and redefined, or "overridden," in derived classes.
• All classes inherit from the Figure class, excepting the constructor, destructor, and assignment operator.

Defining class hierarchy

• Figure class is a base class.
• Circle class inherits from the Figure class, adding specific attributes like radius.
• Derived classes do not include all members of the base class (constructor, destructor, assignment operator).

Public Inheritance

• A class inheriting publicly from another inherits both private and public members.
• Private members of the base class are only accessible from that class.
• Public members of the base class are accessible from derived and other classes.

Protection revisited

• The protected access modifier in a base class grants access to derived class only.
• Unlike private, protected members are not accessible from outside the class hierarchy.

Composition of protection

• Three types of inheritance are discussed: public, private, and protected.
• Public inheritance creates a sub-type relationship, private and protected hide implementation details.
• Members' access modifiers, determined by the base and derived class types, control their visibility.

Constructor

• Constructors initialize objects, ensuring data is ready for use when created.
• The derived class constructor first invokes the base class constructor.
• Initialization of base class members happens before derived class members.

Destructor

• The destructor is the counterpart to the constructor.
• Objects are cleaned up when deallocated.
• The derived class destructor executes after the base class destructor.

Constructors

• Constructors are functions that initialize the objects as they come into existence.
• Base class constructors are called before the derived class constructors.
• Derived classes often have constructors that invoke the base class constructor.

Example - use

• An example demonstrates the usage of the Figure class and derived shape classes. (code provided)
• Function calls are made to operate on the objects.
• Examples illustrate draw_picture and compare functions.

Static cast

• Casting with compilers.
• Casts know the type at compile time.
• Casting is used to treat objects as a different type.

Dynamic cast 1

• Dynamic casts are type-safe.
• Casting objects (pointers and references) to different types during runtime.
• Casting between classes that inherit (A and B, where B inherits from A).

Dynamic cast 2

• Dynamic casting is performed during runtime and checks if the type can support the cast.
• Using dynamic cast dynamic_cast<type>(object)
• It returns NULL or throws an exception if the cast is not possible.

An other example

• An example of how polymorphism is used to call different draw methods for different Figure types.

Polymorphism

• Polymorphism enables code reuse.
• Objects of different classes use the same function.
• Real object type only known at run time.

Virtual function

• Virtual functions support runtime method selection.
• Call function on derived object and determine which one matches
• It's declared virtual in the base class, re-declared in derived (no need to be virtual)

Abstract class

• Abstract classes act as blueprints that must be implemented.
• They encourage uniform class design, avoiding incomplete class hierarchies. (e.g. using =0 in a virtual function).

Multiple inheritance

• Allows a class to inherit from multiple base classes.
• Order of inheritance matters for constructors and destructors.
• Ambiguities may arise when multiple base classes have the same member.

Resolving ambiguities

• Resolving conflicts in inheritance where multiple base class definitions could exist (e.g., A::func or B::func).
• Scope resolution operator (A::func) can be used to resolve ambiguities.

Part IV: The Stream Library

• Streams manage input and output operations.
• Input/output is separated from other components, and performed through a library.

I/O stream

• A library (iostream) is used for input and output operations.
• Stream objects represent data sources (files, keyboard) or destinations.
• Associated with physical devices like files, consoles, or keyboards.

Class hierarchy

• The I/O library uses inheritance.
• Base classes like istream and ostream deal with the inputs and outputs.
• Derived classes add specific functionality.

The class stream

• Explains the class structure of the I/O library.
• Includes various formatting options (precision, flags, etc.).

The class stream - example

• Demonstrates usage of the iostream library.
• Demonstrates setting parameters and using formatting manipulators.

The class input and output stream

• I/O stream (iostream, istream, ostream) classes and functionalities.
• Data insertion and extraction methods using format operators.
• Standard streams cerr, clog, cout along with other types.

Manipulators

• Manipulators modify how the input/output stream functions operate.
• Examples show use cases for flags such as hex, uppercase, precision which are included in the manipulators header (iomanip).

This quiz explores the concept of inheritance in object-oriented programming, focusing on class hierarchies and the relationship between base and derived classes. It includes practical examples using shape classes like Square, Rectangle, Circle, and Triangle. Test your understanding of attributes and methods associated with these shapes!