Class and objects
This presentation is the property of its rightful owner.
Sponsored Links
1 / 60

Class and Objects PowerPoint PPT Presentation


  • 77 Views
  • Uploaded on
  • Presentation posted in: General

Class and Objects. 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

Download Presentation

Class and Objects

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Class and objects

Class and Objects


Introduction

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


Introduction cont

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:


Class constructor

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

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

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

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

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.


Example1

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


Example2

Example

class Foo

{

public:

Foo();

Foo(int j=0, float x=3.14, string s="a");

...

};

...

Foo obj1; // which constructor would be called?


Example3

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


Example4

Example

class Foo

{

public:

// No constructor provided

...

private:

float m;

string city;

};

...

Foo obj1; // automatic constructor called

// no initialization


Member initialization list

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


Example5

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


Example6

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

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

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.


Example7

Example

class Foo

{

public:

...

~Foo(); // destructor prototype

private:

...

};

Foo::~Foo( ) // destructor definition

{

... // code for destructor

}


Designing a class

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

Translating a Library


Constant member functions

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.


Example8

Example

class Foo

{

public:

...

void Display() const; // prototype

...

private:

int a, b;

};

void Foo::Display() const // definition

{

a = 10; // illegal code

...

}


Constant objects

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.


Const member data

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.


Example9

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

}


Class and objects

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

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

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

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


Copy constructor1

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?


Example10

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;

};


Example11

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

}


Example12

Example

int main()

{

Test t1(10.5, 5);

Test t2 = t1; // copy constructor is called for t2

return 0;

}


Friend classes

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.


Example13

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

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.


Example14

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

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.


Example15

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

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.


Example16

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

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

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.


Example17

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

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

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

Operators that can be overloaded

+-*/%^&|

~!=<>+=-=*=

/=%=^=&=|=<<>>>>=

<<===!=<=>=&&||++

--->*‘->[ ]( )

new delete new [ ] delete [ ]


Overloading is not automatic

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

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

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

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


Example18

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

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 cont1

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

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


Example19

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;


Example20

Example

  • The statement

    cin >> rObj;

    will be translated by the compiler to:

    operator>>(cin,rObj);

  • How will the compiler translate this one?

    cout << rObj;


Example cont2

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 cont3

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;

};


  • Login