University:
Boston University
Course:
MET CS 201 | Introduction to Programming
Academic year:

2023
Views:

217

Pages:

18
Author:

pubicswprv

Default constructors and destructors  The two methods created by C::B automatically are explicit versions of the default C++ constructors and destructors.  You must define your own constructor when you want to initialize an object with arguments (as done here)  Every class has them – if you don’t define them then empty ones that do nothing will be created for you by the compiler.  A custom destructor is always needed when internal members in the class need special handling.  If you really don’t want the default constructor you can delete it with the delete keyword. Also in the header file you can use the default keyword if you like to be clear.  Examples: manually allocated memory, open files, hardware drivers, database or network connections, custom data structures, etc. Destructors  Destructors are called when an object is destroyed.  There is only one destructor allowed per class.  Objects are destroyed when they go out of scope.  Destructors are never called explicitly by the programmer. Calls to destructors are inserted automatically by the compiler. Note the destructor has no return type and is named with a ~. This class just has 2 floats as members which are automatically removed from memory by the compiler. Rectangle::~Rectangle() { //dtor } ~House() destructor House object Scope  Scope is the region where a variable is valid.  Constructors are called when an object is created.  Destructors are only ever called implicitly. int main() { // Start of a code block // in main function scope float x ; // No constructors for built-in types ClassOne c1 ; // c1 constructor ClassOne() is called. if (1){ // Start of an inner code block // scope of c2 is this inner code block ClassOne c2 ; //c2 constructor ClassOne() is called. } // c2 destructor ~ClassOne() is called. ClassOne c3 ; // c3 constructor ClassOne() is called. } // leaving program, call destructors for c3 and c1 ~ClassOne() // variable x: no destructor for built-in type Copy, Assignment, and Move Constructors  The compiler will automatically create constructors to deal with copying, assignment, and moving.  Moving occurs, for example, when an object is created and added to a list in a loop.  Moving is an optimization feature that’s part of C++11.  Dealing with the details of these constructors is outside of the scope of this tutorial  How do you know if you need to write one?  When you move, assign, or copy an object in your code and the code won’t compile!  OR you move, assign, or copy an object, it compiles, but unexpected things happen when running.  You may require custom code when...     dealing with open files inside an object The class manually allocated memory Hardware resources (a serial port) opened inside an object Etc. Rectangle rT_1(1.0,2.0) ; // Now use the copy constructor Rectangle rT_2(rT_1) ; // Do an assignment, with the // default assignment operator rT_2 = rT_1 ; So Far…  Define a C++ class  Adding members and methods  Use separate header and source files for a C++ class.  Class constructors & destructors  OOP concept: Encapsulation The formal concepts in OOP Polymorphism  Next up: Inheritance Encapsulation OOP Inheritance Abstraction Inheritance  Inheritance is the ability to form a hierarchy of classes where they share common members and methods.  Helps with: code re-use, consistent programming, program organization Molecule  This is a powerful concept! Inorganic Mineral Organic Protein Inheritance Superclass Base Class  The class being derived from is referred to as the base, parent, or super class.  The class being derived is the derived, child, or sub class.  For consistency, we’ll use superclass and subclass in this tutorial. A base class is the one at the top of the hierarchy. Molecule Inorganic Mineral Subclass Organic Protein Inheritance in Action  Streams in C++ are series of characters – the C+ I/O system is based on this concept.  cout is an object of the class ostream. It is a write-only series of characters that prints to the terminal.  There are two subclasses of ostream:  ofstream – write characters to a file  ostringstream – write characters to a string  Writing to the terminal is straightforward: cout << some_variable ;  How might an object of class ofstream or ostringstream be used if we want to write characters to a file or to a string? Inheritance in Action  For ofstream and ofstringstream the << operator is inherited from ostream and behaves the same way for each from the programmer’s point of view.  The ofstream class adds a constructor to open a file and a close() method.  ofstringstream adds a method to retrieve the underlying string, str()  If you wanted a class to write to something else, like a USB port…  Maybe look into inheriting from ostream!  Or its underlying class, basic_ostream which handles types other than characters… Inheritance in Action #include // cout #include // ofstream #include // ostringstream using namespace std ; void some_func(string msg) { cout << msg ; // to the terminal // The constructor opens a file for writing ofstream my_file("filename.txt") ; // Write to the file. my_file << msg ; // close the file. my_file.close() ; ostringstream oss ; // Write to the stringstream oss << msg ; // Get the string from stringstream cout << oss.str() ; } Single vs Multiple Inheritance  C++ supports creating relationships where a subclass inherits data members and methods from a single superclass: single inheritance  C++ also support inheriting from multiple classes simultaneously: Multiple inheritance  This tutorial will only cover single inheritance.  Generally speaking… A C B D  With multiple inheritance a hierarchy like this is possible to create. This is  Multiple inheritance requires a large amount of design effort nicknamed the Deadly Diamond of Death as it creates ambiguity in the code.  It’s an easy way to end up with overly complex, fragile code  Java, C#, and Python (all came after C++) exclude multiple  We will briefly address creating interfaces in C++ later on which gives most of the inheritance on purpose to avoid problems with it. desired functionality of multiple inheritance without the headaches. “There are only two things wrong with C++: The initial concept and the implementation.” – Bertrand Meyer (inventor of the Eiffel OOP language) Public, protected, private  These keywords were added by C::B to our Rectangle class. class Rectangle { public: Rectangle(); Rectangle(float width, float length) ; virtual ~Rectangle(); float m_width ; float m_length ;  These are used to control access to different parts of the class during inheritance by other pieces of code. float Area() ; protected: private: }; C++ Access Control and Inheritance  A summary of the accessibility of members and methods: Access class Super { public: int i; protected: int j ; private: int k ; }; public protected private Same class Yes Yes Yes Subclass Yes Yes No Outside classes Yes No No Inheritance class Sub : public Super { // in methods, could access // i and k from Parent only. }; Outside code Sub myobj ; Myobj.i = 10 ; // ok Myobj.j = 3 ; // Compiler error Abstraction  Having private (internal) data and methods separated from public ones is the OOP concept of abstraction. C++ Inheritance Syntax  Inheritance syntax pattern: class SubclassName : public SuperclassName  Here the public keyword is used.  Methods implemented in class Sub can access any public or protected members and methods in Super but cannot access anything that is private.  Other inheritance types are protected and private. class Super { public: int i; protected: int j ; private: int k ; }; class Sub : public Super { // ... }; It is now time to inherit  The C::B program will help with the syntax when defining a class that inherits from another class.  With the Shapes project open, click on File  New  Class  Give it the name Square and check the “Inherits another class” option.  Enter Rectangle as the superclass and the include as “rectangle.h” (note the lowercase r)  Click Create! square.cpp square.h #ifndef SQUARE_H #define SQUARE_H #include "rectangle.h" class Square : public Rectangle { public: Square(); virtual ~Square(); protected: private: }; #include "square.h" Square::Square() { //ctor } Square::~Square() { //dtor }  Note that subclasses are free to add any number of new methods or members, they are not limited to those in the superclass. #endif // SQUARE_H  2 files are automatically generated: square.h and square.cpp  Class Square inherits from class Rectangle