1. Class and Objects

2. Introduction Object-oriented programming (OOP) Information hiding
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 Member access specifiers 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 const is 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
A constructor 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()

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 **.

51. Implementing operator overloading
The functions must have access to the private member data of the class.
Two ways to write operator overloading functions:
Member functions
Non-member (friend) functions

52. Using member functions
If the first operand of the operator is an object (or a reference to an object) of the class type (for which we want to overload), the overloaded operator is typically implemented as a member function.
Member functions must be used for overloading:
() [] -> =
Function prototypes for binary/unary operators:
retType operator op(const Type &);
retType operator op();

53. Example
Suppose we want to overload the * operator for the Rational class so that we can write statements like:
rObj = rObj1 * rObj2;
Required prototype:
Rational operator*(const Rational &) const;
The previous statement will be translated by the compiler to:
rObj = rObj1.operator*(rObj2);

54. Example (Cont ..) // the member function operator*()
// will overload the * operator
class Rational {
public:
Rational(int n = 0, int d = 1);
Rational operator*(const Rational &) const;
void Display() const;
private:
int numerator;
int denominator; };

55. Example (Cont ..) // defining the operator*() function
Rational Rational::operator*(const Rational &r) const {
int n = (*this).numerator * r.numerator;
// int n = numerator * r.numerator;
int d = (*this).denominator * r.denominator;
// int d = denominator * r.denominator;
return Rational(n,d); }

56. Using friend functions
If the first operand is not an object (or a reference to an object) of the class type (for which we want to overload), the overloaded operator must be implemented as a non-member (friend) function.
Function prototypes for binary/unary operators:
friend retType operator op(Type1 &, Type2 &);
friend retType operator op(Type &);

57. Example
We often want to overload the insertion (>>) and extraction (<<) operators so that objects can be read/written using these operators.
Suppose we want to be able to read and write rational numbers in format like 2/9.
I/O statements might look like:
cin >> rObj;
cout << rObj << endl;

58. Example will be translated by the compiler to: The statement
cin >> rObj;
will be translated by the compiler to:
operator>>(cin,rObj);
How will the compiler translate this one?
cout << rObj;

59. Example (Cont ..) class Rational {
friend ostream& operator<< (ostream&, const Rational&);
friend istream& operator>> (istream&, Rational&);
public:
Rational (int n = 0, int d = 1);
private:
int numerator;
int denominator; };

60. Example (Cont ..)
ostream& operator<< (ostream &out, const Rational &r) {
out << r.numerator << "/" << r.denominator;
return out; }
istream& operator>> (istream &in, Rational &r)
// complete the code
main()
Rational rObj;
cout << "Enter a rational number like 2/9: ";
cin >> rObj;
cout << "The rational number is: " << rObj << endl; };