1 / 17

Object-Oriented programming in C++

Object-Oriented programming in C++. Classes as units of encapsulation Information Hiding Inheritance polymorphism and dynamic dispatching Storage management multiple inheritance. Ancestry. Basis is C language: low-level constructs for systems programming, compact syntax

tatum
Download Presentation

Object-Oriented programming in C++

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Object-Oriented programming in C++ • Classes as units of encapsulation • Information Hiding • Inheritance • polymorphism and dynamic dispatching • Storage management • multiple inheritance

  2. Ancestry • Basis is C language: low-level constructs for systems programming, compact syntax • Major innovation: classes, inspired by Simula. • In Simula classes are objects with state and independent thread of execution. • Syntactic innovation: operator overloading • Later addition : templates • Latest addition: a model of concurrency

  3. Classes • Encapsulation of type and related operations. Provides information hiding. Operations “belong” to the class class point { double x, y; // private data members public: point (int x0, int y0); // public methods point () { x = 0; y = 0;}; /// a constructor void move (int dx, int dy); // formal names optional void rotate (double alpha); int distance (point p); }

  4. A class is a type : objects are instances point p1 (10, 20); // call constructor with given arguments point p2; // call default constructor Methods are functions with an implicit argument p1.move (1, -1); // special syntax to indicate object // in other languages might write move (p1, 1, -1) // special syntax inspired by message-passing metaphor: // objects are autonomous entities that exchange messages.

  5. Implementing methods No equivalent of a package body: each method can be defined separately. Proper style is a separate file for all method bodies. void point::rotate (double alpha) { x = x * cos (alpha) - y * sin (alpha); y = y * cos (alpha) + x * cos (alpha); }; // x and y are the data members of the object on which the // method is being called. // if method is defined in class declaration, it is inlined.

  6. Constructors • One of the best innovations of C++ • special method (s) invoked automatically when an object of the class is declared point (int x1, int x2); point (); point (double alpha; double r); point p1 (10,10), p2; p3 (pi / 4, 2.5); • Name of method is name of class • Declaration has no return type (would be redundant) • Long form: point (int x1, int x2) {x = x1; y = x2} • Syntactic sugar: point (int x1, int x2) :x(x1), y(x2)

  7. The target of an operation • The implicit parameter in a method call can be retrieved through this: class Collection { Collection& insert (thing x) { // return reference … modify data structure return *this; // to modified object }; }; my_collection.insert (x1).insert (x2);

  8. Static members • Need to have computable attributes for class itself, independent of specific object; e.g. number of objects created. • Static qualifier indicates that entity is unique for the class static int num_objects = 0; point ( ) { num_objects++;}; // ditto for other constructors • Can access static data using class name or object name: if (point.num_objects != p1.num_objects) error ( );

  9. Classes and private types • If all data members are private, class is identical to a private type: only methods are visible, including assignment. • A struct is a class with all public members • How much to reveal is up to programmer • define functions to retrieve (not modify) private data int xcoord () { return x;}; int ycoord () { return y;}; p2.x = 15; // error, data member x is private

  10. Destructors • If constructor allocates dynamic storage, need to reclaim it class stack { int* contents; int sz; public: stack (int size) { contents = new int [ sz = size];}; void push ( ); int pop ( ); int size ( ) { return sz;}; } stack my_stack (100); // allocate storage dynamically // when is my_stack.contents released?

  11. If constructor uses resources, class needs a destructor • User cannot deallocate data because data member is private: system must do it ~stack ( ) {delete[ ] contents;}; • inventive syntax: negation of constructor • Called automatically when object goes out of scope • Almost never called explicitly

  12. Copy and assignment point p3 (10,20); point p5 = p3; // componentwise copy • This can lead to unwanted sharing: stack stack1 (200); stack stack2 = stack1; // stack1.contents shared stack2.push (15); // stack1 is modified • Need to redefine assignment and copy

  13. Copy constructor stack (const stack& s) { // reference to existing object contents = new int [ sz = s.size( )]; for (int k = 0; k <sz; k++) contents [k] = s.contents [k]; } stack s1 (100); … stack s2 = s1; // invokes copy constructor

  14. Redefining assignment • assignment can also be redefined to avoid unwanted sharing • operator returns a reference, so it can be used efficiently in chained assignments: one = two = three; stack & operator= (const stack& s) { if (this != &s) { // beware of self-assignment delete [ ] contents; // discard old value contents = new int [sz = s.size ( )]; for (int k = 0; k <sz; k++) contents [k] = s.contents [k]; } return *this; } stack s1 (100), s2 (200); … s1 = s2; // transfer contents

  15. Anomalies • An array whose component type is a class can only be declared if there is a parameterless constructor for the class. There is no way to pass parameters to the constructor. polygon point [10]; // ok turing stack [2]; // illegal

  16. Operator Overloading: indexing • Useful to create range-checked structures: class four_vect { double stor[4]; // private member, actual contents of vector. … double& operator[ ] (int j) { if (j < 0 || I > 3) throw index_error; // defined elsewhere return stor[j]; }; Note: return type is a reference, so can be used on l.h.s

  17. Extending the meaning of subscripting • An associative array: class Assoc { // a map from strings to numbers struct Pair { // an inner class char* name; double val; Pair (char* n = “”, double v = 0) : name (n), val (v) { }; }; pair * contents; // Assoc is a set of pairs public: Assoc ( ) { }; // default constructor double& operator[ ] (const char*); // map string => number };

More Related