1. Object-Based Programming Mostly Review

2. Objects Review what is object? class? member variables? member functions? public members? private members? friend function? 2

3. Object-Based Programming Terminology object-based programming – using objects in programming but no inheritance (extended/derived classes) –object-oriented programming – this plus inheritance features – member variables and member functions –class attributes (UML term)/fields - member variables –class operators (UML)/methods - member functions (class) interface – public class features (class) implementation – private class features accessor (inspector) member function – does not change the state of the object mutator (modifier) member function – changes the state of the object 3

4. Accessors member functions that do not modify the state of the object signature should contains const int getNumber() const{ return number_; // returns value of private attribtue } reasons for const –visually designates accessor –generates compile-time error if modifies object –if invokes another method, it has to be constant – const-ness cannot be lost through function invocation –only accessors can be invoked on constant objects such as const myBirthDate(1,14,2014); 4

5. Declarations vs. Definitions C++ syntax rule: a construct may declared multiple times (provided signatures match), defined only once –variable declaration is preceded with extern useful for global variable declaration in header file extern int myGlobalVar; only single definition –function declaration: prototype, multiple prototypes okay definition: implementation, only single implementation –class (forward) declaration (incomplete type), multiple times allowed, but can be used only to declare pointers/references class myClass; definition – only once class myClass{}; 5

6. Style Guide start class name with a capital letter name class according to its use list class access modifiers in this order: public, protected, private, i.e. interface first, implementation last use underscore_ to end names of private attributes – distinguishes them from local variables in methods int x_; define every accessor (query) with const header file should include declarations only: class (?), standalone functions, constants 6

7. Copying Objects what are objects with dynamically allocated members? –why are they special? –why are constructor,destructor,copy constructor called big three? –what is this ? shallow copy – memberwise copying of object attributes –may be inadequate in case object has dynamically allocated members and passing of object by reference returning an object object assignment deep copy – recursive (including attributes) copying of entire object 7

8. Constructor method invoked automatically at object creation to initialize it –same name as class can be overloaded and can use default parameters default/no-arg constructor – either has no parameters or has default values for all existing parameters either –explicitly defined by programmer –generated automatically does not initialize attributes of basic types, pointers or references invokes default constructors on all non-static attributes of class types 8

9. Destructor method automatically invoked when object goes out of scope to deallocate resources used by object –same name as class with tilde cannot be overloaded, cannot have parameters, cannot be const used to release dynamic memory used by object –note: need to call destructors on dynamically allocated objects pointed to by the objects going out of scope 9

10. Copy Constructor invoked when initialing a new object using an existing object –when passing object by vaue as a parameter –when returning object used to implement deep copy signature: ClassName(const ClassName&); 10

11. Overloaded Assignment invoked when one object is assigned to anther used to implement deep copy, of right-hand-side object and preserve meaning of assignment operator –need to deallocate old object –need to create a copy of the new object copy and swap idiom – common idiom to implement overloaded assignment: terser, re-uses copy-constructor need to define a friend swap function myClass& operator=(myClass rhs){ swap(*this, rhs); return(*this); } –invokes copy-constructor to create the copy of the right-hand-side object –implicitly uses destructor to deallocate old object –no need to check for self-assignment 11

12. Member Initialization List terse initialization of member variables, allows to initialize const and reference members comma-separated list of initalizers of the form variableName(value) appears in constructor definition between function head and function body following colon primitive types: equivalent to assignment objects: constructor is invoked class Student{ public: Student(long, string); private: long number_; string name_; }; Student::Student (long number, string name) : number_(number), name_(name) //initialization list {} // empty body caution, initalizers invoked in order members are listed in class definition 12

13. Inline Functions inline - request to compiler to replace invocation with implementation keyword inline inline int min(int i, int j){ return i < j ? i : j; } potentially very efficient whether request is honored is implementation dependent all functions defined inside class definition are inline – don’t do it because it confuses interface and implementation, problematic for placing class definitions in header file 13