introduction object-oriented programming (oop) encapsulates data (attributes) and functions...
TRANSCRIPT
IntroductionObject-oriented programming (OOP)
Encapsulates data (attributes) and functions (behavior) into packages called classes
Information hiding Class objects communicate across well-defined
interfacesImplementation details hidden within classes
themselvesUser-defined (programmer-defined) types: classes
Data (data members) Functions (member functions or methods)Similar to blueprints – reusableClass instance: object
2
Introduction (Cont.)Classes
Model objects Attributes (data members) Behaviors (member functions)
Defined using keyword classMember functions
Methods Invoked in response to messages
Member access specifierspublic:
Accessible wherever object of class in scopeprivate:
Accessible only to member functions of classprotected:
3
Class constructorA 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 constructorsA 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.
Exampleclass 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 valuesDefault 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.
Exampleclass 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");
Exampleclass Foo{ public: Foo(); Foo(int j=0, float x=3.14, string s="a"); ...};
...Foo obj1; // which constructor would be called?
Exampleclass 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);
Exampleclass Foo{ public: // No constructor provided ... private: float m; string city;};
...Foo obj1; // automatic constructor called // no initialization
Member initialization listMember data can be initialized by a
constructor in two waysCode inserted in the constructorA member initialization list
Member initialization listGiven 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
Exampleclass 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
Exampleclass 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 destructorA 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.
Exampleclass Foo{ public: ... ~Foo(); // destructor prototype private: ...};
Foo::~Foo( ) // destructor definition{ ... // code for destructor}
Designing a ClassData members normally placed in private:
section of a classFunction members usually in public: sectionTypically public: section followed by private:
although not required by compiler
19
Class LibrariesClass declarations placed in header file
Given .h extensionContains data items and prototypes
Implementation fileSame prefix name as header fileGiven .cpp extension
Programs which use this class library called client programs
20
Translating a Library
21
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.
Exampleclass Foo{ public: ... void Display() const; // prototype ... private: int a, b;};void Foo::Display() const // definition{ a = 10; // illegal code ...}
Constant objectsAn 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 dataMember 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.
Exampleclass 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 CopyThe default member wise copy is called
shallow copy copies only the class data members and not
any pointed-to dataDone by default in three situations:
Assignment of one object into anotherPassing objects to functions by valueReturning an object from a function
Deep CopyA 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 ConstructorA constructor whose only argument is an
object of the same class.The copy constructor is implicitly called in 3
situations:passing object parameters by valueinitializing an object variable in its declarationreturning an object as the return value of a
function
Copy ConstructorEvery class has a default copy constructor
that uses a shallow copy.So when should you implement your own
copy constructor and how?
Exampleclass 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;};
ExampleTest::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}
Exampleint main()
{
Test t1(10.5, 5);
Test t2 = t1; // copy constructor is called for t2
return 0;
}
Friend classesOne 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.
Exampleclass Foo1
{
friend class Foo2;
public:
...
private:
...
};
// This means Foo1 is granting friendship, i.e.
// access to private member data, to Foo2.
Friend FunctionsMaking 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.
Exampleclass Foo{ friend void SetX(Foo &, int val); public: ... private: int x;};
//friend function definitionvoid SetX(Foo &f, int val){ f.x = val;}
Array of ObjectsJust 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.
Exampleclass 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 PointerEvery 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.
Exampleclass 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 OverloadingAll 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.
ExampleSuppose 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 likecompare timesif (time1 < time2)
print times to an output streamcout << "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 automaticOverloading the operator + allows statements
like: object1 + object2
The above does not allow statements like: object1 += object2
The += operator must be overloaded separately.
RestrictionsThe 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 overloadingThe functions must have access to the private
member data of the class.Two ways to write operator overloading
functions:Member functionsNon-member (friend) functions
Using member functionsIf 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();
ExampleSuppose 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);
// 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;};
// 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 functionsIf 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 &);
ExampleWe 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;
ExampleThe 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;};