Class and Objects

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

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:

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.

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.

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.

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");

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.

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");

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

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);

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

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

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

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

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.

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.

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

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

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

Translating a Library

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.

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

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.

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.

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 }

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.

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

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.

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

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?

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; };

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

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

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.

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

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.

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; }

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.

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

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.

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; }

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.

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.

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;

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.

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.

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

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.

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

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

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();

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);

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; };

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); }

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 &);

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;

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;

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; };

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; };