Class and Objects

1. Class and Objects

2. Introduction • Object-oriented programming (OOP) • Encapsulates data (attributes) and functions (behavior) into packages called classes • Information hiding • Class objects communicate across well-defined interfaces • Implementation details hidden within classes themselves • User-defined (programmer-defined) types: classes • Data (data members) • Functions (member functions or methods) • Similar to blueprints – reusable • Class instance: object

3. Introduction (Cont.) • Classes • Model objects • Attributes (data members) • Behaviors (member functions) • Defined using keyword class • Member functions • Methods • Invoked in response to messages • Member access specifiers • public: • Accessible wherever object of class in scope • private: • Accessible only to member functions of class • protected:

4. Class constructor • A function with the same name as the class. • Used to create an instance of a class (object) and initialize the data members of the object. • A constructor function is called automatically when an object of that class is created. • A constructor can not have a return value.

5. Class constructor (Cont ..) • If you do not declare a constructor for a class, one will be declared for you automatically. • This constructor will have no arguments. • A constructor with no argument (or with all arguments with default values) is called a default constructor.

6. Multiple constructors • A single class can have more than one constructor. • The compiler chooses which constructor to invoke by the signature of the constructor (the number and type of arguments). • If no arguments are given, the default constructor is used.

7. Example class Foo { public: Foo(); Foo(int j, float x, string s); Foo(int j, string s); Foo(int k, string s, int j); ... }; // which constructor will be called? Foo obj1; Foo obj2(2, "Happy"); Foo obj3(4, "Joe", 0); Foo obj4(5, 4.3, "Joe");

8. Constructor with default argument values • Default values for constructor arguments may be assigned in the constructor prototype. • If no argument value is provided in the class object declaration, the default value is used.

9. Example class Foo { public: Foo(int j=0, float x=3.14, string s="Hello"); ... }; ... // what happens? Foo obj1; Foo obj2(1); Foo obj3(1, 2.5); Foo obj4(1, 2.5, "Joe");

10. Example class Foo { public: Foo(); Foo(int j=0, float x=3.14, string s="a"); ... }; ... Foo obj1; // which constructor would be called?

11. Example class Foo { public: Foo(int i); Foo(int j=0, float x=3.14, string s="a"); ... }; ... // what happens? Foo obj1; Foo obj2(5); Foo obj3(5, 4.2);

12. Example class Foo { public: // No constructor provided ... private: float m; string city; }; ... Foo obj1; // automatic constructor called // no initialization

13. Member initialization list • Member data can be initialized by a constructor in two ways • Code inserted in the constructor • A member initialization list • Member initialization list • Given in constructor definition (not prototype) • Follows the argument list and consists of a colon followed by a comma separated list of member name/argument pairs

14. Example class Foo { public: Foo(int, float); ... private: int k; float z; }; Foo::Foo(int a, float b): k(a), z(b) { // body of the constructor is often empty } Foo obj1(5,15.0); // Instantiate an object

15. Example class Foo { public: Foo(int, float); ... private: int k; float z; string n; }; Foo::Foo(int a, float b): z(b), k(a) { n = "John Doe"; } Foo obj2(5, 15.0); // Instantiate an object

16. Class destructor • A class object is usually destroyed when program execution leaves the "scope" of the declaration. • Many times you will want to write code to specifically deallocate an object’s memory e.g., when dynamic memory allocation is used. • A special member function called destructor is used to accomplish this.

17. Class destructor (Cont ..) • The destructor is called automatically when the class object is destroyed. • The name of the destructor function is the class name preceded by a tilde (~). • The destructor cannot have arguments. • The destructor cannot return a value. • An automatic destructor is defined if you do not define one.

18. Example class Foo { public: ... ~Foo(); // destructor prototype private: ... }; Foo::~Foo( ) // destructor definition { ... // code for destructor }

19. Designing a Class • Data members normally placed in private: section of a class • Function members usually in public: section • Typically public: section followed by private: • although not required by compiler

20. Class Libraries • Class declarations placed in header file • Given .h extension • Contains data items and prototypes • Implementation file • Same prefix name as header file • Given .cpp extension • Programs which use this class library called client programs

21. Translating a Library

22. Constant member functions • Member functions can be made constant. • Based on the Principle of least privilege • This means that they cannot change the value(s) of member data. • The keyword const should follow the argument list and must be used in both the prototype and definition of the member function.

23. Example class Foo { public: ... void Display() const; // prototype ... private: int a, b; }; void Foo::Display() const // definition { a = 10; // illegal code ... }

24. Constant objects • An object can be declared as constant. • The keyword constis used to specify that the object cannot be modified. const Time noon(12,0,0); • Any attempt to modify a const object is a syntax error. • A const object must be initialized by constructor and cannot be modified once declared.

25. Const member data • Member data can be made constant by using the keyword const in the class definition. • Any const member data must be initialized with an initialization list for the constructor. • A const member data cannot be modified by any function.

26. Example class Foo { public: Foo(int, float); ... private: const int k; float z; }; Foo::Foo(int a, float b): k(a), z(b) { k = a; // illegal code }

27. Assignment by default memberwise copy • The assignment operator (=) can be used to assign an object to another object of the same type. • Assignment is done by memberwise copy • Each member in one object is copied to the same member of another object. • This type of copy should be done for objects that only have value members.

28. Shallow Copy • The default member wise copy is called shallow copy • copies only the class data members and not any pointed-to data • Done by default in three situations: • Assignment of one object into another • Passing objects to functions by value • Returning an object from a function

29. Deep Copy • A deep copy copies not only the class data members, but also makes a separate stored copy of any pointed-to data at different locations than the original class object.

30. Copy Constructor • Aconstructor whose only argument is an object of the same class. • The copy constructor is implicitly called in 3 situations: • passing object parameters by value • initializing an object variable in its declaration • returning an object as the return value of a function

31. Copy Constructor • Every class has a default copy constructor that uses a shallow copy. • So when should you implement your own copy constructor and how?

32. Example class Test { public: Test(float = 0, int = 0); Test(const Test &t); // copy constructor float GetMyFloat(); int GetMyInt(); void SetMyFloat(float); void SetMyInt(int); ~Test(); private: float myFloat; int *myInt; };

33. Example Test::Test(float f, int i) { myFloat = f; myInt = new int; *myInt = i; } Test::Test(const Test &t) { // complete the code } Test::~Test() { // complete the code }

34. Example int main() { Test t1(10.5, 5); Test t2 = t1; // copy constructor is called for t2 return 0; }

35. Friend classes • One often uses several classes that work together. • Making the classes friends allows the classes to access one another’s private member data. • For class B to be a friend of class A, A must explicitly declare B as a friend. • Friendship is neither symmetric nor transitive.

36. Example class Foo1 { friend class Foo2; public: ... private: ... }; // This means Foo1 is granting friendship, i.e. // access to private member data, to Foo2.

37. Friend Functions • Making a non-member function a friend of a class allows that function to access private member data of a class. • To declare a non-member function as a friend of a class, precede the function prototype in the class definition with the word friend.

38. Example class Foo { friend void SetX(Foo &, int val); public: ... private: int x; }; //friend function definition void SetX(Foo &f, int val) { f.x = val; }

39. Array of Objects • Just like any built-in data type, a class type can also be used to declare an array. • To declare an array of class objects, the class must have a default constructor . • The default constructor is used to initialize each object of the array since it is not possible to specify different constructors for each object.

40. Example class Rational { public: Rational (int n = 1, int d = 1); void Display(); private: int numerator, denominator; }; Rational::Rational(int n, int d) { numerator = n; denominator = d; } Rational r[10]; // creates an array of 10 objects // data members of each initialized to 1

41. The this Pointer • Every object has access to its own address through a pointer called this. • The this pointer is used implicitly to reference both the data members and member functions of an object. • It can also be used explicitly.

42. Example class Foo { public: Foo(int x = 0); void Display() const; private: int x; }; void Foo::Display() const { cout << this->x << endl; // cout << (*this).x << endl; }

43. Operator Overloading • All unary and binary operators have pre-defined implementations and are automatically available in expressions. • User defined implementations can also be introduced for these operators. • Operator overloading is the process of defining a new meaning for an existing operator.

44. Why overload operators? • We can interact with instances of user-defined class types by invoking member functions and for many classes, this notation may be cumbersome. • For some classes, it would be nice to be able to use operators with instances of these classes.

45. Example • Suppose we have a class for representing time of the day (called Time) and two Time objects time1 and time2. • We want to be able to do things like • compare times if (time1 < time2) • print times to an output stream cout << "The first time is " << time1;

46. What to do? • You have to define functions so that you are able to overload any existing operators. • These functions will implement the overloaded operators.

47. How to overload? • An overloaded operator is nothing but a function. • The name of the function is the keyword operator followed by the symbol for the operator being overloaded. • Example: You will need a function called operator+to overload the + operator.

48. Operators that can be overloaded + - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || ++ -- ->* ‘ -> [ ] ( ) new delete new [ ] delete [ ]

49. Overloading is not automatic • Overloading the operator + allows statements like: object1 + object2 • The above does not allow statements like: object1 += object2 • The += operator must be overloaded separately.

50. Restrictions • The aritiy (number of operands) of the operator cannot change. • You cannot redefine the meaning of operators when applied to built-in data types. • You cannot define new operators, such as **.