class and objects
Download
Skip this Video
Download Presentation
Class and Objects

Loading in 2 Seconds...

play fullscreen
1 / 60

Class and Objects - PowerPoint PPT Presentation


  • 98 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Class and Objects' - kemp


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

}

slide27

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;

};

ad