A <Basic> C++ Course
|
|
|
- Francis Waters
- 5 years ago
- Views:
Transcription
1 A <Basic> C++ Course 7 Object-oriented programming Julien Deantoni adapted from Jean-Paul Rigault courses
2 Outline Introduction to class derivation: variants of class Paragraph Dynamic typing and virtual functions: Composing various sorts of paragraphs Another example: the Expr class 4-2
3 Document example basic specifications Consider (unstructured) text documents. A Document is composed of: 1. a title, 2. A set of authors, 3. an ordered collection of contained paragraphs, 4. an ordered collection of referenced paragraphs. 3
4 Document example basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; 4
5 Document example basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); //! Copy constructor Document(const Document&); void append(paragraph&, bool); ; 5
6 Document example basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) _title = title; _authors = new_authors; _paragraphs = new_paragraphs; _external_paragraphs = new_external_paragraphs; void Document::append(Paragraph& p, bool isowned) if (isowned == true) _paragraphs.push_back(p); else _external_paragraphs.push_back(&p); document.cpp 6
7 Document example basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) _title = title; _authors = new_authors; _paragraphs = new_paragraphs; _external_paragraphs = new_external_paragraphs; void Document::append(Paragraph& p, bool isowned) if (isowned == true) _paragraphs.push_back(p); else _external_paragraphs.push_back(&p); document.cpp 7
8 Document example basic specifications vs C++ #include "document.h" Document::Document(string title, vector<string> new_authors, vector<paragraph> new_paragraphs, vector<paragraph*> new_external_paragraphs) _title = title; _authors = new_authors; _paragraphs = new_paragraphs; _external_paragraphs = new_external_paragraphs; void Document::append(Paragraph& p, bool isowned) if (isowned == true) _paragraphs.push_back(p); else _external_paragraphs.push_back(&p); document.cpp 8
9 Document example another implementation class Document private: string _title; vector<string> _authors; vector<paragraph*> _paragraphs; vector<paragraph*> _external_paragraphs; public:... 9
10 Document example another implementation #include "document.h" A new place is reserved in the memory and the corresponding pointer is put in the container void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(new Paragraph(p)); else _external_paragraphs.push_back(&p); 10
11 Document example another implementation A new place is reserved in the memory and the corresponding pointer is put in the container #include "document.h" The previous statement is always true: For me, when there is a containment, the object void Document::append(Paragraph& p, bool owned) life is under the responsibility of the container. Otherwise it is not. if (owned == true) _paragraphs.push_back(new Paragraph(p)); else _external_paragraphs.push_back(&p); 11
12 Document example another implementation A new place is reserved in the memory and the corresponding pointer is putted in the container void Document::append(Paragraph& p, bool owned) The previous statement is always true: if (owned == true) For me, when there is a containment, the object life is under the responsibility of the container. _paragraphs.push_back(new Paragraph(p)); else Consequently, the release of the memory _external_paragraphs.push_back(&p); is handled in destructor Document::~Document() for (int i = 0; i < paragraphs.size(); i++) delete _paragraphs.at(i); Otherwise it is not. 12
13 Definition of derived classes We wish to have several sorts of paragraphs titles, sections, enumerations, items... We want to share as much as possible the common properties contents as a string possibility to compose (crude lay out) But specific properties should be possible numbering, bullets... page layout
14 Definition of derived classes We wish to have several sorts of paragraphs titles, sections, enumerations, items... We want to share as much as possible the common properties contents as a string possibility to compose (crude lay out) But specific properties should be possible numbering, bullets... page layout
15 Definition of derived classes class Item_Paragraph : public Paragraph private: string _bullet; public: ; Item_Paragraph(string b = "*"); Item_Paragraph(const string& c, int d = 0, string b="*"); string get_bullet() const return _bullet; void set_bullet(string bullet) _bullet = bullet; //...
16 Definition of derived classes class Item_Paragraph : public Paragraph private: string _bullet; public: ; Item_Paragraph(string b = "*"); Item_Paragraph(const string& c, int d = 0, string b="*"); string get_bullet() const return _bullet; void set_bullet(string bullet) _bullet = bullet; //...
17 Definition of derived classes class Section_Paragraph : public Paragraph private: string _title; public: Item_Paragraph(string t = "default_title"); Item_Paragraph(const string& c, int d = 0, string t="default_title"); string get_title() const return _title; void set_title(string title) _title = title; //... ;
18 Definition of derived classes A Section_Paragraph is a Paragraph A Section_Paragraph inherits Paragraph properties Its underlying C structure contains the Paragraph one plus all data members specific to Section_Paragraph a_section : Section_Paragraph content : string depth : int title : string : Paragraph
19 Definition of derived classes A Section_Paragraph is a Paragraph A Section_Paragraph inherits Paragraph properties Its underlying C structure contains the Paragraph one plus all data members specific to Section_Paragraph One can apply to a Section_Paragraph object all public Paragraph member-functions One may substitute to any instance of Paragraph an instance of Section_Paragraph (Substitutability principle) (semantics known as subtyping)
20 Definition of derived classes A derived class may add new properties data members member-functions friend functions A derived class may redefine (override) some inherited member-functions Derivation depth is unlimited Single and multiple inheritance Single: only one base class Multiple: several distinct base classes
21 Definition of derived classes : What happens in the memory? main() Paragraph p; Item_Paragraph ip; p:paragraph content= depth=
22 Definition of derived classes : What happens in the memory? main() Paragraph p; Item_Paragraph ip; p:paragraph content= Ip: Item_Paragraph :Paragraph content= depth= depth= bullet=
23 Protected members Accessing inherited member in a derived class: Void Section_Paragraph::a_function() _contents.push_back( blabla bla ); ERROR: _contents is private in Paragraph
24 Protected members Accessing inherited member in a derived class: Void Section_Paragraph::a_function() _contents.push_back( blabla bla ); ERROR: _contents is private in Paragraph Protected members: class Paragraph protected: string _contents; public: //... ; A protected member is public to its class and its derivatives Protected data members are as vulnerable as public ones
25 Construction of derived classes Constructors of Item_Paragraph In opposition with other members, constructors are never inherited Item_Paragraph::Item_Paragraph(const string& c="", int d=0, string b = * ) : Paragraph(c,d), _bullet(b) Item_Paragraph::Item_Paragraph(string b = * ) : _bullet(b)
26 Construction of derived classes Constructors of Item_Paragraph Equivalent to super() in java (for single inheritance) Item_Paragraph::Item_Paragraph(const string& c="", int d=0, string b = * ) : Paragraph(c,d), _bullet(b) Item_Paragraph::Item_Paragraph(string b = * ) : _bullet(b)
27 Construction of derived classes Constructors of Item_Paragraph Item_Paragraph::Item_Paragraph(const string& c="", int d=0, string b = * ) : Paragraph(c,d), _bullet(b) Item_Paragraph::Item_Paragraph(string b = * ) : _bullet(b) Ok only if base class members and default constructors are public
28 Construction of derived classes Constructors of Item_Paragraph Item_Paragraph::Item_Paragraph(const string& c="", int d=0, string b = * ) : Paragraph(c,d), _bullet(b) Item_Paragraph::Item_Paragraph(string b = * ) : _bullet(b) equivalent Item_Paragraph::Item_Paragraph(string b = * ) : Paragraph(), _bullet(b)
29 Construction of derived classes Construction of Section_Paragraph Section_Paragraph::Section_Paragraph( const string& c="", int d=0, string t= ) : Paragraph(c,d), _title(t) Section_Paragraph::Section_Paragraph(string t= ) : title(t)
30 Default construction of derived classes If the derived class has no constructor, its members and base class are constructed by default construction Everything is as if C++ creates a default default constructor A class is constructible by default if either it has a default constructor or it has no constructor at all, and its members and immediate base classes are constructible by default If a derived class has no destructor, default destruction applies Everything is as if C++ creates a default destructor
31 Construction order of derived classes Construction order 1. the base class(es) 2. the data members specific to derived class 3. the body of the derived class constructor itself Destruction order: reverse of construction C++ applies these rules recursively A derived class constructor is entirely responsible for the construction of its base class(es) its specific members the derived class itself (constructor body)
32 Default construction of derived classes (2) class B public: B(int = 0);; class A private: int _p; public: A(int = 0); //... ; class A1 : public A protected: B _b1; public: A1(int i = 0, int j = 1) : _b1(i), A(j)... //... ; _p : int class A2 : public A1 private: B _b2;; A1 a1(2, 3);
33 Default construction of derived classes (3) class B public: B(int = 0);; class A private: int _p; public: A(int = 0);... ; class A1 : public A protected: B _b1; public: A1(int i = 0, int j = 1) : b1(i), A(j) ; class A2 : public A1 private: B _b2;; A2 a2; no constructor! A2:A2() : A1(),_b2() default default constructor
34 Using publicly derived classes Standard conversions in case of public derivation derived class instance base class instance pointer to derived class pointer to base class reference to derived class reference to base class //... Item_Paragraph ip1; Section_Paragraph sp2; Paragraph p = ip1; //... cout << ip1 + sp2; // initialization of Paragraph // + and << for Paragraph
35 Using publicly derived classes Standard conversions in case of public derivation derived class instance base class instance pointer to derived class pointer to base class reference to derived class reference to base class //... Item_Paragraph ip1; Section_Paragraph sp2; Paragraph p = ip1; //... cout << ip1 + sp2; // initialization of Paragraph // + and << for Paragraph We do not want to print an Item_Paragraph and a Section_Paragraph in the same way
36 Back to conversion of derived classes What if we redefine a print() member-function in variants of Paragraph? Indeed each sort of paragraph has a different page layout Note that the redefinition should have the same signature in the base and derived classes Paragraph p; Item_Paragraph ip; ip.print(); // Item_Paragraph::print() p = ip; // Paragraph::operator= p.print(); // Paragraph::print() Paragraph *ptr_p = &ip; ptr_p->print(); void f(paragraph& p) p.print(); // standard conversion // Paragraph::print() // Paragraph::print()
37 Virtual Functions class Paragraph //... virtual print() const;... ; class Item_Paragraph : public Paragraph //... virtual print() const;... ; A virtual function is binded at run-time (so called late-binding or dynamic typing) each time we invoke a virtual member-function by accessing the object through a pointer or a reference, the dynamic type of the object determine (at run-time) which version of the member-function is to be used.
38 Virtual functions class Paragraph //... virtual print() const;... ; class Item_Paragraph : public Paragraph //... virtual print() const;... ; One could says : every method must be virtual! It could but it may not... (due to performance issue on specific cases) Having virtual functions indicate that a class is meant to act as an interface to derived classes (Bjarne Stroustrup)
39 Virtual functions class Paragraph //... virtual print() const;... ; class Item_Paragraph : public Paragraph //... virtual print() const;... ; One could says : every method must be virtual! It could but it may not... (due to performance issue on specific cases) Having virtual functions indicate that a class is meant to act as an interface to derived classes (Bjarne Stroustrup) If the destructor is not declared virtual then only the ~BaseClass() destructor is called leaving any allocated memory from the DerivedClass to persist and leak
40 Virtual functions class Paragraph //... virtual print() const;... ; class Item_Paragraph : public Paragraph //... virtual print() const;... ; One could says : every method must be virtual! It could but it may not... (due to performance issue on specific cases) Having virtual functions indicate that a class is meant to act as an interface to derived classes (Bjarne Stroustrup) virtual ~Paragraph(); virtual ~Item_Paragraph(); At least!!!
41 Document example basic specifications vs C++ class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph> new_paragraphs=vector<paragraph>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); void append(paragraph&, bool); ; 42
42 Document example troncature problem Ref to an Item_Paragraph void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(p); else _external_paragraphs.push_back(&p); Ip: Item_Paragraph :Paragraph content= depth= bullet= 43
43 Document example troncature problem Ref to an Item_Paragraph void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back((paragraph)p); else _external_paragraphs.push_back(&p); Ip: Item_Paragraph :Paragraph content= depth= bullet= 44
44 Document example troncature problem void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(paragraph(p)); else _external_paragraphs.push_back(&p); Ip: Item_Paragraph :Paragraph content= depth= bullet= The dynamic type of p is lost _bullet is truncated 45
45 Document example preserving dynamic type class Document private: string _title; vector<string> _authors; vector<paragraph> _paragraphs; vector<paragraph*> _external_paragraphs; public:... 46
46 Document example preserving dynamic type Ref to an Item_Paragraph void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(paragraph(p)); else Address of the Item_Paragraph _external_paragraphs.push_back(&p); The dynamic type of p is NOT lost 47
47 Document example preserving dynamic type class Document private: string _title; vector<string> _authors; vector<paragraph*> _paragraphs; vector<paragraph*> _external_paragraphs; public: /*! constructors */ Document(string title="default_title", vector<string> new_authors= vector<string>(), vector<paragraph*> new_paragraphs=vector<paragraph*>(), vector<paragraph*> new_external_paragraphs=vector<paragraph*>()); void append(paragraph&, bool); ; 48
48 Document example preserving dynamic type Ref to an Item_Paragraph void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(new Paragraph(p)); else Return the address of a new Paragraph _external_paragraphs.push_back(&p); The dynamic type of p is still lost 49
49 Document example preserving dynamic type Ref to an Item_Paragraph void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(new Item_Paragraph(p)); else Return the address of a new Item_Paragraph _external_paragraphs.push_back(&p); What if not an Item_Paragraph? 50
50 Document example preserving dynamic type : polymorphic copy (clone) class Paragraph public: virtual Paragraph* clone() const return new Paragraph(*this); ; class Item_Paragraph : public Paragraph public: virtual Paragraph* clone() const return new Item_Paragraph(*this); ; A virtual function is binded at run-time (so called late-binding or dynamic typing) 51
51 Document example preserving dynamic type : polymorphic copy (clone) class Paragraph public: virtual Paragraph *clone() const return new Paragraph(*this); ; class Item_Paragraph : public Paragraph public: virtual Paragraph *clone() const return new Item_Paragraph(*this); ; void Document::append(Paragraph& p, bool owned) if (owned == true) _paragraphs.push_back(p.clone()); else _external_paragraphs.push_back(&p); The dynamic type of p is NOT lost Return the address of a new Paragraph or a derived class 52
52 Virtual functions and operator overload Only member-function can be virtual How can we overload the printing function (operator<<)
53 Friendship and derivation A derived class does not inherit its base class friends as friend The friends of a derived class are not implicitly friends of its base class Nevertheless, it is possible to use base class friends with an object of a publicly derived class as parameter class A friend void f(a); //... ; class B : public A...; B b; f(b); // OK: equivalent to f((a)b)
54 Virtual functions and operator overload Only member-function can be virtual How can we overload the printing function (operator<<)
55 Virtual functions and operator overload Only member-function can be virtual How can we overload the printing function (operator<<) class Paragraph //... virtual ostream& print(ostream&) const; std::ostream& operator<<(std::ostream& os, Paragraph p) return p.print(os); ; class Item_Paragraph : public Paragraph //... virtual ostream& print(ostream&) const;... ; Est-ce correct?
56 Virtual functions and operator overload Only member-function can be virtual How can we overload the printing function (operator<<) class Paragraph //... virtual ostream& print(ostream&) const; std::ostream& operator<<(std::ostream& os, const Paragraph& p) return p.print(os); ; class Item_Paragraph : public Paragraph //... virtual ostream& print(ostream&) const;... ;
57 Using publicly derived classes By using virtual functions //... Item_Paragraph ip1; vector<paragraph*> vp; vp.push_back(ip1.clone()); //... cout << vp.at(0); delete vp.at(0); // operator<< from Paragraph call print from Item_Paragraph
58 Using publicly derived classes By using virtual functions //... Item_Paragraph ip1; vector<paragraph*> vp; vp.push_back(ip1.clone()); //... cout << vp.at(0); delete vp.at(0); // operator<< from Paragraph call print from Item_Paragraph If the destructor is not declared virtual then only the ~BaseClass() destructor is called leaving any allocated memory from the DerivedClass to persist and leak
A <Basic> C++ Course
adapted from Jean-Paul Rigault courses 1 A C++ Course 7 Object-oriented programming Julien DeAntoni Outline Introduction to class derivation: variants of class Paragraph Dynamic typing and virtual
A <Basic> C++ Course. Julien DeAntoni. 7 - The document example. adapted from Jean-Paul Rigault courses
adapted from Jean-Paul Rigault courses 1 A C++ Course 7 - The document example Julien DeAntoni 2 This Week Just an example... 3 Document example: basic specifications Consider (unstructured) text
A <Basic> C++ Course. Julien Deantoni. 7 - The document example. adapted from Jean-Paul Rigault courses
A C++ Course 7 - The document example Julien Deantoni adapted from Jean-Paul Rigault courses This Week Just an example... Programmation multi paradigmes en C++ 2 Document example: basic specifications
A <Basic> C++ Course
adapted from Jean-Paul Rigault courses 1 A C++ Course 8 Object-oriented programming 2 Julien Deantoni 2 Outline Dynamic Typing Truncature Cast 3 Variants of class Paragraph Definition of derived
VIRTUAL FUNCTIONS Chapter 10
1 VIRTUAL FUNCTIONS Chapter 10 OBJECTIVES Polymorphism in C++ Pointers to derived classes Important point on inheritance Introduction to virtual functions Virtual destructors More about virtual functions
CS105 C++ Lecture 7. More on Classes, Inheritance
CS105 C++ Lecture 7 More on Classes, Inheritance " Operator Overloading Global vs Member Functions Difference: member functions already have this as an argument implicitly, global has to take another parameter.
And Even More and More C++ Fundamentals of Computer Science
And Even More and More C++ Fundamentals of Computer Science Outline C++ Classes Special Members Friendship Classes are an expanded version of data structures (structs) Like structs, the hold data members
What is Polymorphism? Quotes from Deitel & Deitel s. Why polymorphism? How? How? Polymorphism Part 1
Polymorphism Part 1 What is Polymorphism? Polymorphism refers to a programming language s ability to process objects differently depending on their data type or class. Number person real complex kid adult
Polymorphism Part 1 1
Polymorphism Part 1 1 What is Polymorphism? Polymorphism refers to a programming language s ability to process objects differently depending on their data type or class. Number person real complex kid
Data Structures and Other Objects Using C++
Inheritance Chapter 14 discuss Derived classes, Inheritance, and Polymorphism Inheritance Basics Inheritance Details Data Structures and Other Objects Using C++ Polymorphism Virtual Functions Inheritance
OBJECT ORIENTED PROGRAMMING USING C++ CSCI Object Oriented Analysis and Design By Manali Torpe
OBJECT ORIENTED PROGRAMMING USING C++ CSCI 5448- Object Oriented Analysis and Design By Manali Torpe Fundamentals of OOP Class Object Encapsulation Abstraction Inheritance Polymorphism Reusability C++
2 ADT Programming User-defined abstract data types
Preview 2 ADT Programming User-defined abstract data types user-defined data types in C++: classes constructors and destructors const accessor functions, and inline functions special initialization construct
POLYMORPHISM 2 PART. Shared Interface. Discussions. Abstract Base Classes. Abstract Base Classes and Pure Virtual Methods EXAMPLE
Abstract Base Classes POLYMORPHISM 2 PART Abstract Classes Static and Dynamic Casting Common Programming Errors class B { // base class virtual void m( ) =0; // pure virtual function class D1 : public
POLYMORPHISM 2 PART Abstract Classes Static and Dynamic Casting Common Programming Errors
POLYMORPHISM 2 PART Abstract Classes Static and Dynamic Casting Common Programming Errors CSC 330 OO Software Design 1 Abstract Base Classes class B { // base class virtual void m( ) =0; // pure virtual
Multiple and Virtual Inheritance in C++
Multiple and Virtual Inheritance in C++ Initialization of virtual bases Final classes in C++ Multiple inheritance, virtual members and virtual inheritance. Construction order with multiple inheritance
Assignment of Structs
Deep Copy 1 Assignment of Structs 2 Slides 1. Table of Contents 2. Assignment of Structs 3. Dynamic Content 4. Shallow Copying 5. Assignment Operator 6. Deep Assignment Copy 7. Assignment Problems 8. Assignment
Operator Dot Wording
2016-10-16 Operator Dot Wording Bjarne Stroustrup (bs@ms.com) Gabriel Dos Reis (gdr@microsoft.com) Abstract This is the proposed wording for allowing a user-defined operator dot (operator.()) for specifying
Object Oriented Programming. Solved MCQs - Part 2
Object Oriented Programming Solved MCQs - Part 2 Object Oriented Programming Solved MCQs - Part 2 It is possible to declare as a friend A member function A global function A class All of the above What
CS250 Final Review Questions
CS250 Final Review Questions The following is a list of review questions that you can use to study for the final. I would first make sure you review all previous exams and make sure you fully understand
Polymorphism. Zimmer CSCI 330
Polymorphism Polymorphism - is the property of OOP that allows the run-time binding of a function's name to the code that implements the function. (Run-time binding to the starting address of the code.)
Week 7. Statically-typed OO languages: C++ Closer look at subtyping
C++ & Subtyping Week 7 Statically-typed OO languages: C++ Closer look at subtyping Why talk about C++? C++ is an OO extension of C Efficiency and flexibility from C OO program organization from Simula
Instantiation of Template class
Class Templates Templates are like advanced macros. They are useful for building new classes that depend on already existing user defined classes or built-in types. Example: stack of int or stack of double
G Programming Languages - Fall 2012
G22.2110-003 Programming Languages - Fall 2012 Lecture 12 Thomas Wies New York University Review Last lecture Modules Outline Classes Encapsulation and Inheritance Initialization and Finalization Dynamic
Introduction to C++ Part II. Søren Debois. Department of Theoretical Computer Science IT University of Copenhagen. September 12th, 2005
Introduction to C++ Part II Søren Debois Department of Theoretical Computer Science IT University of Copenhagen September 12th, 2005 Søren Debois (Theory, ITU) Introduction to C++ September 12th, 2005
HAS-A Relationship. Association is a relationship where all objects have their own lifecycle and there is no owner.
HAS-A Relationship Association is a relationship where all objects have their own lifecycle and there is no owner. For example, teacher student Aggregation is a specialized form of association where all
C++ Addendum: Inheritance of Special Member Functions. Constructors Destructor Construction and Destruction Order Assignment Operator
C++ Addendum: Inheritance of Special Member Functions Constructors Destructor Construction and Destruction Order Assignment Operator What s s Not Inherited? The following methods are not inherited: Constructors
Intro to OOP Visibility/protection levels and constructors Friend, convert constructor, destructor Operator overloading a<=b a.
Intro to OOP - Object and class - The sequence to define and use a class in a program - How/when to use scope resolution operator - How/when to the dot operator - Should be able to write the prototype
Object-Oriented Languages and Object-Oriented Design. Ghezzi&Jazayeri: OO Languages 1
Object-Oriented Languages and Object-Oriented Design Ghezzi&Jazayeri: OO Languages 1 What is an OO language? In Ada and Modula 2 one can define objects encapsulate a data structure and relevant operations
Conformance. Object-Oriented Programming Spring 2015
Conformance Object-Oriented Programming 236703 Spring 2015 1 What s Conformance? Overriding: replace method body in sub-class Polymorphism: subclass is usable wherever superclass is usable Dynamic Binding:
A <Basic> C++ Course
A C++ Course 5 Constructors / destructors operator overloading Julien DeAntoni adapted from Jean-Paul Rigault courses 1 2 This Week A little reminder Constructor / destructor Operator overloading
CSS 343 Data Structures, Algorithms, and Discrete Math II. Polymorphism. Yusuf Pisan
CSS 343 Data Structures, Algorithms, and Discrete Math II Polymorphism Yusuf Pisan Polymorphism Hierarchy of classes that are related by inheritance static linkage / early binding Decide on function to
C++ Crash Kurs. Polymorphism. Dr. Dennis Pfisterer Institut für Telematik, Universität zu Lübeck
C++ Crash Kurs Polymorphism Dr. Dennis Pfisterer Institut für Telematik, Universität zu Lübeck http://www.itm.uni-luebeck.de/people/pfisterer C++ Polymorphism Major abstractions of C++ Data abstraction
A <Basic> C++ Course
A C++ Course 5 Constructors / destructors operator overloading Julien Deantoni adapted from Jean-Paul Rigault courses This Week A little reminder Constructor / destructor Operator overloading Programmation
Object Oriented Programming
OOP Object Oriented Programming Object 2 Object 1 Object 3 For : COP 3330. Object oriented Programming (Using C++) Object 4 http://www.compgeom.com/~piyush/teach/3330 Piyush Kumar Objects: State (fields),
What s Conformance? Conformance. Conformance and Class Invariants Question: Conformance and Overriding
Conformance Conformance and Class Invariants Same or Better Principle Access Conformance Contract Conformance Signature Conformance Co-, Contra- and No-Variance Overloading and Overriding Inheritance as
Inheritance, Polymorphism, and Interfaces
Inheritance, Polymorphism, and Interfaces Chapter 8 Inheritance Basics (ch.8 idea) Inheritance allows programmer to define a general superclass with certain properties (methods, fields/member variables)
C++ (Non for C Programmer) (BT307) 40 Hours
C++ (Non for C Programmer) (BT307) 40 Hours Overview C++ is undoubtedly one of the most widely used programming language for implementing object-oriented systems. The C++ language is based on the popular
CS304 Object Oriented Programming Final Term
1. Which of the following is the way to extract common behaviour and attributes from the given classes and make a separate class of those common behaviours and attributes? Generalization (pg 29) Sub-typing
Outline. User-dened types Categories. Constructors. Constructors. 4. Classes. Concrete classes. Default constructor. Default constructor
Outline EDAF50 C++ Programming 4. Classes Sven Gestegård Robertz Computer Science, LTH 2018 1 Classes the pointer this const for objects and members Copying objects friend inline 4. Classes 2/1 User-dened
Object Oriented Software Design II
Object Oriented Software Design II Inheritance Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa February 29, 2012 G. Lipari (Scuola Superiore Sant Anna) C++ Intro February
QUIZ. How could we disable the automatic creation of copyconstructors
QUIZ How could we disable the automatic creation of copyconstructors pre-c++11? What syntax feature did C++11 introduce to make the disabling clearer and more permanent? Give a code example. QUIZ How
C++ Inheritance and Encapsulation
C++ Inheritance and Encapsulation Private and Protected members Inheritance Type Public Inheritance Private Inheritance Protected Inheritance Special method inheritance 1 Private Members Private members
Documentation. Programming / Documentation Slide 42
Documentation http://www.math.upb.de/~robsy/lehre/programmierkurs2008/ Programming / Documentation Slide 42 Memory Management (I) There are several types of memory which a program can access: Stack Every
Financial computing with C++
Financial Computing with C++, Lecture 11 - p1/24 Financial computing with C++ LG Gyurkó University of Oxford Michaelmas Term 2015 Financial Computing with C++, Lecture 11 - p2/24 Outline Derived classes
XII- COMPUTER SCIENCE VOL-II MODEL TEST I
MODEL TEST I 1. What is the significance of an object? 2. What are Keyword in c++? List a few Keyword in c++?. 3. What is a Pointer? (or) What is a Pointer Variable? 4. What is an assignment operator?
Special Member Functions
CS 247: Software Engineering Principles Special Member Functions Readings: Eckel, Vol. 1 Ch. 11 References and the Copy Constructor Ch. 12 Operator Overloading ( operator= ) U Waterloo CS247 (Spring 2017)
And Even More and More C++ Fundamentals of Computer Science
And Even More and More C++ Fundamentals of Computer Science Outline C++ Classes Friendship Inheritance Multiple Inheritance Polymorphism Virtual Members Abstract Base Classes File Input/Output Friendship
Polymorphism. Contents. Assignment to Derived Class Object. Assignment to Base Class Object
Polymorphism C++ Object Oriented Programming Pei-yih Ting NTOU CS 26-1 Contents Assignment to base / derived types of objects Assignment to base / derived types of pointers Heterogeneous container and
OBJECT ORIENTED PROGRAMMING USING C++
OBJECT ORIENTED PROGRAMMING USING C++ Overview of C++ Overloading Overloading occurs when the same operator or function name is used with different signatures Both operators and functions can be overloaded
Object Oriented Software Design II
Object Oriented Software Design II Inheritance Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa February 29, 2012 G. Lipari (Scuola Superiore Sant Anna) C++ Intro February
COEN244: Polymorphism
COEN244: Polymorphism Aishy Amer Electrical & Computer Engineering Polymorphism means variable behavior / ability to appear in many forms Outline Casting between objects Using pointers to access objects
Interview Questions of C++
Interview Questions of C++ Q-1 What is the full form of OOPS? Ans: Object Oriented Programming System. Q-2 What is a class? Ans: Class is a blue print which reflects the entities attributes and actions.
Short Notes of CS201
#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system
OOP THROUGH C++(R16) int *x; float *f; char *c;
What is pointer and how to declare it? Write the features of pointers? A pointer is a memory variable that stores the address of another variable. Pointer can have any name that is legal for other variables,
QUIZ. How could we disable the automatic creation of copyconstructors
QUIZ How could we disable the automatic creation of copyconstructors pre-c++11? What syntax feature did C++11 introduce to make the disabling clearer and more permanent? Give a code example. Ch. 14: Inheritance
Review and Recursion
Midterm Exam Review Division of Mathematics and Computer Science Maryville College Outline Midterm Exam Review 1 Midterm Exam Review 2 Questions 1-10 Midterm Exam Review 1 What are some of the main challenges
COMP6771 Advanced C++ Programming
1 COMP6771 Advanced C++ Programming Week 11 Object Oriented Programming 2016 www.cse.unsw.edu.au/ cs6771 2 Covariants and Contravariants Let us assume that Class B is a subtype of class A. Covariants:
Increases Program Structure which results in greater reliability. Polymorphism
UNIT 4 C++ Inheritance What is Inheritance? Inheritance is the process by which new classes called derived classes are created from existing classes called base classes. The derived classes have all the
CS201 - Introduction to Programming Glossary By
CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with
C++ Programming: Polymorphism
C++ Programming: Polymorphism 2018 년도 2 학기 Instructor: Young-guk Ha Dept. of Computer Science & Engineering Contents Run-time binding in C++ Abstract base classes Run-time type identification 2 Function
Recap: Pointers. int* int& *p &i &*&* ** * * * * IFMP 18, M. Schwerhoff
Recap: Pointers IFMP 18, M. Schwerhoff int* int& *p &i &*&* ** * * * * A 0 A 1 A 2 A 3 A 4 A 5 A 0 A 1 A 2 A 3 A 4 A 5 5 i int* p; A 0 A 1 A 2 A 3 A 4 A 5 5 i p int* p; p = &i; A 0 A 1 A 2 A 3 A 4 A 5
Department of Computer science and Engineering Sub. Name: Object oriented programming and data structures Sub. Code: EC6301 Sem/Class: III/II-ECE Staff name: M.Kavipriya Two Mark Questions UNIT-1 1. List
Fast Introduction to Object Oriented Programming and C++
Fast Introduction to Object Oriented Programming and C++ Daniel G. Aliaga Note: a compilation of slides from Jacques de Wet, Ohio State University, Chad Willwerth, and Daniel Aliaga. Outline Programming
Special Member Functions. Compiler-Generated Destructor. Compiler-Generated Default Constructor. Special Member Functions
Special Member Functions CS 247: Software Engineering Principles Special Member Functions Readings: Eckel, Vol. 1 Ch. 11 References and the Copy Constructor Ch. 12 Operator Overloading ( operator= ) C++
Absolute C++ Walter Savitch
Absolute C++ sixth edition Walter Savitch Global edition This page intentionally left blank Absolute C++, Global Edition Cover Title Page Copyright Page Preface Acknowledgments Brief Contents Contents
CGS 2405 Advanced Programming with C++ Course Justification
Course Justification This course is the second C++ computer programming course in the Computer Science Associate in Arts degree program. This course is required for an Associate in Arts Computer Science
3.Constructors and Destructors. Develop cpp program to implement constructor and destructor.
3.Constructors and Destructors Develop cpp program to implement constructor and destructor. Constructors A constructor is a special member function whose task is to initialize the objects of its class.
C++ Important Questions with Answers
1. Name the operators that cannot be overloaded. sizeof,.,.*,.->, ::,? 2. What is inheritance? Inheritance is property such that a parent (or super) class passes the characteristics of itself to children
Problem Solving with C++
GLOBAL EDITION Problem Solving with C++ NINTH EDITION Walter Savitch Kendrick Mock Ninth Edition PROBLEM SOLVING with C++ Problem Solving with C++, Global Edition Cover Title Copyright Contents Chapter
Data Structures and Algorithms
Data Structures and Algorithms Alice E. Fischer Lecture 3 217 Alice E. Fischer Data Structures L3... 1/31 1 Arrays Growing Arrays vectors 2 3 Empty Lists Inserting Data - Unsorted Inserting Data - Sorted
Evaluation Issues in Generic Programming with Inheritance and Templates in C++
Evaluation Issues in Generic Programming with Inheritance and Templates in C++ Emil Vassev, Joey Paquet Department of Computer Science and Software Engineering Concordia University Montreal, Quebec, H3G
ECE 3574: Dynamic Polymorphism using Inheritance
1 ECE 3574: Dynamic Polymorphism using Inheritance Changwoo Min 2 Administrivia Survey on class will be out tonight or tomorrow night Please, let me share your idea to improve the class! 3 Meeting 10:
Evolution of Programming Languages
Evolution of Programming Languages 40's machine level raw binary 50's assembly language names for instructions and addresses very specific to each machine 60's high-level languages: Fortran, Cobol, Algol,
C++_ MARKS 40 MIN
C++_16.9.2018 40 MARKS 40 MIN https://tinyurl.com/ya62ayzs 1) Declaration of a pointer more than once may cause A. Error B. Abort C. Trap D. Null 2Whice is not a correct variable type in C++? A. float
Subtyping (Dynamic Polymorphism)
Fall 2018 Subtyping (Dynamic Polymorphism) Yu Zhang Course web site: http://staff.ustc.edu.cn/~yuzhang/tpl References PFPL - Chapter 24 Structural Subtyping - Chapter 27 Inheritance TAPL (pdf) - Chapter
Classes, Constructors, etc., in C++
Classes, Constructors, etc., in C++ Professor Hugh C. Lauer CS-2303, System Programming Concepts (Slides include materials from The C Programming Language, 2 nd edition, by Kernighan and Ritchie, Absolute
OBJ. ORI.& MULT. PROG., M.C.Q. BANK, FOR UNIT -2, SECOND YEAR COMP. ENGG. SEM-4, 2012 PATTERN, U.O.P. UNIT-2
UNIT-2 Syllabus for Unit-2 Introduction, Need of operator overloading, overloading the assignment, binary and unary operators, overloading using friends, rules for operator overloading, type conversions
Review: C++ Basic Concepts. Dr. Yingwu Zhu
Review: C++ Basic Concepts Dr. Yingwu Zhu Outline C++ class declaration Constructor Overloading functions Overloading operators Destructor Redundant declaration A Real-World Example Question #1: How to
Data Abstraction. Hwansoo Han
Data Abstraction Hwansoo Han Data Abstraction Data abstraction s roots can be found in Simula67 An abstract data type (ADT) is defined In terms of the operations that it supports (i.e., that can be performed
Time(int h, int m, int s) { hrs = h; mins = m; secs = s; } void set(int h, int m, int s) { hrs = h; mins = m; secs = s; }
Inheritance The following class implements time in hh:mm::ss format: class { public: () { = 0; = 0; = 0; (int h, int m, int s) { = h; = m; = s; void set(int h, int m, int s) { = h; = m; = s; void tick()
Comp-304 : Object-Oriented Design What does it mean to be Object Oriented?
Comp-304 : Object-Oriented Design What does it mean to be Object Oriented? What does it mean to be OO? What are the characteristics of Object Oriented programs (later: OO design)? What does Object Oriented
Object-Oriented Principles and Practice / C++
Object-Oriented Principles and Practice / C++ Alice E. Fischer June 3, 2013 OOPP / C++ Lecture 9... 1/40 Const Qualifiers Operator Extensions Polymorphism Abstract Classes Linear Data Structure Demo Ordered
PIC10B/1 Winter 2014 Exam I Study Guide
PIC10B/1 Winter 2014 Exam I Study Guide Suggested Study Order: 1. Lecture Notes (Lectures 1-8 inclusive) 2. Examples/Homework 3. Textbook The midterm will test 1. Your ability to read a program and understand
Object Oriented Paradigm
Object Oriented Paradigm History Simula 67 A Simulation Language 1967 (Algol 60 based) Smalltalk OO Language 1972 (1 st version) 1980 (standard) Background Ideas Record + code OBJECT (attributes + methods)
Modern C++ for Computer Vision and Image Processing. Igor Bogoslavskyi
Modern C++ for Computer Vision and Image Processing Igor Bogoslavskyi Outline Move semantics Classes Operator overloading Making your class copyable Making your class movable Rule of all or nothing Inheritance
G Programming Languages Spring 2010 Lecture 9. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 9 Robert Grimm, New York University 1 Review Last week Modules 2 Outline Classes Encapsulation and Inheritance Initialization and Finalization Dynamic
CS250 Final Review Questions
CS250 Final Review Questions The following is a list of review questions that you can use to study for the final. I would first make sure that you review all previous exams and make sure you fully understand
Where do we go from here?
Where do we go from here? C++ classes and objects, with all the moving parts visible operator overloading templates, STL, standards, Java components, collections, generics language and performance comparisons
COMP 2355 Introduction to Systems Programming
COMP 2355 Introduction to Systems Programming Christian Grothoff christian@grothoff.org http://grothoff.org/christian/ 1 Today Class syntax, Constructors, Destructors Static methods Inheritance, Abstract
Assignment of Objects
Copying Objects 1 Assignment of Objects 2 Slides 1. Table of Contents 2. Assignment of Objects 3. Dynamic Content 4. Shallow Copying 5. Deep Copying 6. this Pointer 7. Improved Deep Copy 8. Passing an
Types. Type checking. Why Do We Need Type Systems? Types and Operations. What is a type? Consensus
Types Type checking What is a type? The notion varies from language to language Consensus A set of values A set of operations on those values Classes are one instantiation of the modern notion of type
Strict Inheritance. Object-Oriented Programming Winter
Strict Inheritance Object-Oriented Programming 236703 Winter 2014-5 1 1 Abstractions Reminder A class is an abstraction over objects A class hierarchy is an abstraction over classes Similar parts of different
Derived Classes in C++
Derived Classes in C++ Professor Hugh C. Lauer CS-2303, System Programming Concepts (Slides include materials from The C Programming Language, 2 nd edition, by Kernighan and Ritchie, Absolute C++, by Walter
The pre-processor (cpp for C-Pre-Processor). Treats all # s. 2 The compiler itself (cc1) this one reads text without any #include s
Session 2 - Classes in C++ Dr Christos Kloukinas City, UoL http://staff.city.ac.uk/c.kloukinas/cpp (slides originally produced by Dr Ross Paterson) A C++ source file may contain: include directives #include
8. Object-oriented Programming. June 15, 2010
June 15, 2010 Introduction to C/C++, Tobias Weinzierl page 1 of 41 Outline Recapitulation Copy Constructor & Operators Object-oriented Programming Dynamic and Static Polymorphism The Keyword Static The
17. Classes. Encapsulation: public / private. Member Functions: Declaration. Member Functions: Call. class rational { int n; int d; // INV: d!
Encapsulation: public / private 7. Classes Classes, Member Functions, Constructors, Stack, Linked List, Dynamic Memory, Copy-Constructor, Assignment Operator, Concept Dynamic Datatype class rational int
Object Oriented Issues in VDM++
Object Oriented Issues in VDM++ Nick Battle, Fujitsu UK (nick.battle@uk.fujitsu.com) Background VDMJ implemented VDM-SL first (started late 2007) Formally defined. Very few semantic problems VDM++ support
Programming in C# Inheritance and Polymorphism
Programming in C# Inheritance and Polymorphism C# Classes Classes are used to accomplish: Modularity: Scope for global (static) methods Blueprints for generating objects or instances: Per instance data
Inheritance and object compatibility
Inheritance and object compatibility Object type compatibility An instance of a subclass can be used instead of an instance of the superclass, but not the other way around Examples: reference/pointer can
CS 6456 OBJCET ORIENTED PROGRAMMING IV SEMESTER/EEE
CS 6456 OBJCET ORIENTED PROGRAMMING IV SEMESTER/EEE PART A UNIT I 1. Differentiate object oriented programming from procedure oriented programming. 2. Define abstraction and encapsulation. 3. Differentiate