AN OVERVIEW OF

C++
1
OBJECTIVES
 Introduction
 What is object-oriented programming?
 Two versions of C++
 C++ console I/O
 C++ comments
 Classes: A first look
 Some differences between C and C++
 Introducing function overloading
 C++ keywords
 Introducing Classes
2
INTRODUCTION
 C++ is the C programmer’s answer to Object-
Oriented Programming (OOP).
 C++ is an enhanced version of the C language.

 C++ adds support for OOP without sacrificing

any of C’s power, elegance, or flexibility.
 C++ was invented in 1979 by Bjarne Stroustrup
at Bell Laboratories in Murray Hill, New Jersey,
USA.

3
INTRODUCTION (CONT.)
 The elements of a computer language do not exist in a
void, separate from one another.
 The features of C++ are highly integrated.

 Both object-oriented and non-object-oriented programs

can be developed using C++.

4
WHAT IS OOP?
 OOP is a powerful way to approach the task of
programming.
 OOP encourages developers to decompose a
problem into its constituent parts.
 Each component becomes a self-contained object
that contains its own instructions and data that
relate to that object.
 So, complexity is reduced and the programmer
can manage larger programs.

5
WHAT IS OOP? (CONT.)
 All
OOP languages, including C++, share three
common defining traits:
 Encapsulation
 Binds together code and data
 Polymorphism
 Allows one interface, multiple methods
 Inheritance
 Provides hierarchical classification
 Permits reuse of common code and data

6
TWO VERSIONS OF C++
 A traditional-style C++ program -

#include <iostream.h>

int main()
{
/* program code */
return 0;
}
7
TWO VERSIONS OF C++ (CONT.)
 A modern-style C++ program that uses the new-style
headers and a namespace -

#include <iostream>
using namespace std;

int main()
{
/* program code */
return 0; 8

}
THE NEW C++ HEADERS
 The new-style headers do not specify filenames.
 They simply specify standard identifiers that might be
mapped to files by the compiler, but they need not be.
 <iostream>
 <vector>
 <string>, not related with <string.h>
 <cmath>, C++ version of <math.h>
 <cstring>, C++ version of <string.h>
 Programmer defined header files should end in “.h”.

9
SCOPE RESOLUTION OPERATOR (::)
 Unary Scope Resolution Operator
 Usedto access a hidden global variable
 Example: usro.cpp
 Binary Scope Resolution Operator
 Used to associate a member function with its class
(will be discussed shortly)
 Used to access a hidden class member variable (will
be discussed shortly)
 Example: bsro.cpp

10
NAMESPACES
 A namespace is a declarative region.
 It localizes the names of identifiers to avoid name
collisions.
 The contents of new-style headers are placed in the std
namespace.
 A newly created class, function or global variable can
put in an existing namespace, a new namespace, or it
may not be associated with any namespace
 In the last case the element will be placed in the global unnamed
namespace.
 Example: namespace.cpp

11
C++ CONSOLE I/O (OUTPUT)
 cout << “Hello World!”;
cout ???
 printf(“Hello World!”);
 cout << iCount; /* int iCount */ Shift right operator ???
 printf(“%d”, iCount);
How does a shift right
 cout << 100.99;
operator produce output
 printf(“%f”, 100.99); to the screen?
 cout << “\n”, or cout << ‘\n’, or cout << endl
 printf(“\n”)
 In general, cout << expression;

Do we smell polymorphism here??? 12

C++ CONSOLE I/O (INPUT)
 cin >> strName; /* char strName[16] */
 scanf(“%s”, strName);
 cin >> iCount; /* int iCount */
 scanf(“%d”, &iCount);
 cin >> fValue; /* float fValue */
 scanf(“%f”, &fValue);
 In general, cin >> variable;

13
Hmmm. Again polymorphism.
 C++ CONSOLE I/O (I/O CHAINING)
 cout << “Hello” << ‘ ‘ << “World” << ‘!’;
 cout << “Value of iCount is: ” << iCount;

 cout << “Enter day, month, year: ”;

 cin >> day >> month >> year;
 cin >> day;
 cin >> month;

 cin >> year

14
What’s actually happening here? Need to learn more.
C++ CONSOLE I/O (EXAMPLE)
include <iostream> include <iostream>
int main() using namespace std;
{ int main()
char str[16]; {
std::cout << “Enter a string: ”; char str[16];
std::cin >> str; cout << “Enter a string: ”;
std::cout << “You entered: ” cin >> str;
<< str; cout << “You entered: ”
} << str;
}

15
C++ COMMENTS
 Multi-line comments
 /* one or more lines of comments */
 Single line comments
 // …

16
CLASSES: A FIRST LOOK
 General syntax -

class class-name
{
// private functions and variables
public:
// public functions and variables
}object-list (optional);
17
CLASSES: A FIRST LOOK (CONT.)
 A class declaration is a logical abstraction that
defines a new type.
 It determines what an object of that type will
look like.
 An object declaration creates a physical entity of
that type.
 That is, an object occupies memory space, but a
type definition does not.
 Example: p-23.cpp, p-26.cpp, stack-test.c.

18
CLASSES: A FIRST LOOK (CONT.)
 Each object of a class has its own copy of every variable
declared within the class (except static variables which
will be introduced later), but they all share the same
copy of member functions.
 How do member functions know on which object they have
to work on?
 The answer will be clear when “this” pointer is introduced.

19
SOME DIFFERENCES BETWEEN
C AND C++
 No need to use “void” to denote empty parameter list.
 All functions must be prototyped.
 If a function is declared as returning a value, it must
return a value.
 Return type of all functions must be declared explicitly.
 Local variables can be declared anywhere.
 C++ defines the bool datatype, and keywords true (any
nonzero value) and false (zero).

20
INTRODUCING FUNCTION
OVERLOADING

 Provides the mechanism by which C++ achieves one type of

polymorphism (called compile-time polymorphism).
 Two or more functions can share the same name as long as
either
 The type of their arguments differs, or
 The number of their arguments differs, or
 Both of the above

21
INTRODUCING FUNCTION
OVERLOADING (CONT.)
 The compiler will automatically select the correct
version.
 The return type alone is not a sufficient difference to
allow function overloading.
 Example: p-34.cpp, p-36.cpp, p-37.cpp.

Q. Can we confuse the compiler with

function overloading?
A. Sure. In several ways. Keep exploring C++. 22
C++ KEYWORDS (PARTIAL LIST)
 bool  protected
 catch  public
 delete  template
 false  this
 friend  throw
 inline  true
 namespace  try
 new  using
 operator  virtual
 private  wchar_t

23
 INTRODUCING
CLASSES
24
CONSTRUCTORS
 Every object we create will require some sort of initialization.
 A class’s constructor is automatically called by the compiler
each time an object of that class is created.
 A constructor function has the same name as the class and has
no return type.
 There is no explicit way to call the constructor.

25
DESTRUCTORS
 The complement of a constructor is the destructor.
 This function is automatically called by the compiler when an
object is destroyed.
 The name of a destructor is the name of its class, preceded by
a ~.
 There is explicit way to call the destructor but highly
discouraged.
 Example : cons-des-0.cpp

26
CONSTRUCTORS &
DESTRUCTORS
 For global objects, an object’s constructor is called once, when
the program first begins execution.
 For local objects, the constructor is called each time the
declaration statement is executed.
 Local objects are destroyed when they go out of scope.

 Global objects are destroyed when the program ends.

 Example: cons-des-1.cpp

27
CONSTRUCTORS &
DESTRUCTORS
 Constructors and destructors are typically declared as public.
 That is why the compiler can call them when an object of a
class is declared anywhere in the program.
 If the constructor or destructor function is declared as private
then no object of that class can be created outside of that class.
What type of error ?
 Example: private-cons.cpp, private-des.cpp

28
CONSTRUCTORS THAT TAKE
PARAMETERS
 It is possible to pass arguments to a constructor function.
 Destructor functions cannot have parameters.
 A constructor function with no parameter is called the default
constructor and is supplied by the compiler automatically if no
constructor defined by the programmer.
 The compiler supplied default constructor does not initialize
the member variables to any default value; so they contain
garbage value after creation.
 Constructors can be overloaded, but destructors cannot be
overloaded.
 A class can have multiple constructors.
 Example: cons-des-3.cpp, cons-des-4.cpp, cons-des-5.cpp,
cons-des-6.cpp
29
OBJECT POINTERS
 It is possible to access a member of an object via a pointer to
that object.
 Object pointers play a massive role in run-time polymorphism
(will be introduced later).
 When a pointer is used, the arrow operator (->) rather than the
dot operator is employed.
 Just like pointers to other types, an object pointer, when
incremented, will point to the next object of its type.
 Example: obj.cpp

30
IN-LINE FUNCTIONS
 Functions that are not actually called but, rather, are expanded
in line, at the point of each call.
 Advantage
 Have no overhead associated with the function call and
return mechanism.
 Can be executed much faster than normal functions.
 Safer than parameterized macros. Why ?
 Disadvantage
 If they are too large and called too often, the program grows
larger.

31
 IN-LINE FUNCTIONS
inline int even(int x)  The inline specifier is a request,
{ not a command, to the compiler.
return !(x%2);  Some compilers will not in-line a
} function if it contains
 A static variable
int main()  A loop, switch or goto
{
 A return statement
if(even(10)) cout << “10 is even\n”;
 If the function is recursive
// becomes if(!(10%2))

if(even(11)) cout << “11 is even\n”;

// becomes if(!(11%2))

return 0;
}
32
AUTOMATIC IN-LINING
 Defining a member function inside the class declaration causes
the function to automatically become an in-line function.
 In this case, the inline keyword is no longer necessary.

 However, it is not an error to use it in this situation.

 Restrictions
 Same as normal in-line functions.

33
AUTOMATIC IN-LINING
// Automatic in-lining // Manual in-lining
class myclass class myclass
{ {
int a; int a;
public: public:
myclass(int n) { a = n; } myclass(int n);
void set_a(int n) { a = n; } int void set_a(int n);
get_a() { return a; } int get_a();
}; };
inline void myclass::set_a(int n)
{
a = n;
} 34
LECTURE CONTENTS
 Teach Yourself C++
 Chapter1 (Full, with exercises)
 Chapter 2.1, 2,2, 2.4, 2.6, 2.7

35
 A CLOSER LOOK AT
CLASSES
36
ASSIGNING OBJECTS
 One object can be assigned to another provided that both
objects are of the same type.
 It is not sufficient that the types just be physically similar
– their type names must be the same.
 By default, when one object is assigned to another, a
bitwise copy of all the data members is made. Including
compound data structures like arrays.
 Creates problem when member variables point to
dynamically allocated memory and destructors are used
to free that memory.
 Solution: Copy constructor (to be discussed later)
 Example: assign-object.cpp

37
PASSING OBJECTS TO
FUNCTIONS
 Objects can be passed to functions as arguments in just
the same way that other types of data are passed.
 By default all objects are passed by value to a function.

 Address of an object can be sent to a function to

implement call by reference.
 Examples: From book

38
PASSING OBJECTS TO
FUNCTIONS
 In call by reference, as no new objects are formed, constructors
and destructors are not called.
 But in call value, while making a copy, constructors are not called
for the copy but destructors are called.
 Can this cause any problem in any case?

 Yes. Solution: Copy constructor (discussed later)

 Example: obj-passing1.cpp, obj-passing2.cpp, obj-passing-

problem.cpp

39
RETURNING OBJECTS FROM
FUNCTIONS
 The function must be declared as returning a class type.
 When an object is returned by a function, a temporary object
(invisible to us) is automatically created which holds the
return value.
 While making a copy, constructors are not called for the copy
but destructors are called
 After the value has been returned, this object is destroyed.
 The destruction of this temporary object might cause
unexpected side effects in some situations.
 Solution: Copy constructor (to be discussed later)
 Example: ret-obj-1.cpp, ret-obj-2.cpp, ret-obj-3.cpp

40
FRIEND FUNCTIONS
 A friend function is not a member of a class but still has access to its
private elements.
 A friend function can be
 A global function not related to any particular class
 A member function of another class
 Inside the class declaration for which it will be a friend, its prototype
is included, prefaced with the keyword friend.
 Why friend functions ?
 Operator overloading
 Certain types of I/O operations
 Permitting one function to have access to the private members of
41
two or more different classes
FRIEND FUNCTIONS
class MyClass // friend keyword not used
{ void ff1(MyClass obj)
int a; // private member {
public: cout << obj.a << endl;
MyClass(int a1) { // can access private member ‘a’
a = a1; directly
} MyClass obj2(100);
friend void ff1(MyClass obj); cout << obj2.a << endl;
}; }
void main()
{
MyClass o1(10);
ff1(o1);
} 42
FRIEND FUNCTIONS
 A friend function is not a member of the class for which it is a
friend.
 MyClass obj(10), obj2(20);
 obj.ff1(obj2); // wrong, compiler error
 Friend functions need to access the members (private, public or
protected) of a class through an object of that class. The object
can be declared within or passed to the friend function.
 A member function can directly access class members.
 A function can be a member of one class and a friend of
another.
 Example : friend1.cpp, friend2.cpp, friend3.cpp

43
FRIEND FUNCTIONS
class YourClass; // a forward friend int compare (MyClass obj1,
declaration YourClass obj2);
class MyClass { };
int a; // private member void main() {
public: MyClass o1(10); YourClass o2(5);
MyClass(int a1) { a = a1; } int n = compare(o1, o2); // n = 5
friend int compare (MyClass }
obj1, YourClass obj2);
}; int compare (MyClass obj1,
class YourClass { YourClass obj2) {
int a; // private member return (obj1.a – obj2.a);
public: }
YourClass(int a1) { a = a1; }
44
FRIEND FUNCTIONS
class YourClass; // a forward class YourClass {
declaration int a; // private member
class MyClass { public:
int a; // private member YourClass(int a1) { a = a1; }
public: friend int MyClass::compare
MyClass(int a1) { a = a1; } (YourClass obj);
int compare (YourClass obj) { };
return (a – obj.a) void main() {
} MyClass o1(10); Yourclass o2(5);
}; int n = o1.compare(o2); // n = 5
}
45
CONVERSION FUNCTION
 Used to convert an object of one type into an object of
another type.
 A conversion function automatically converts an object

Department of CSE, BUET

into a value that is compatible with the type of the
expression in which the object is used.
 General form: operator type() {return value;}
 type is the target type and value is the value of the object
after conversion.
 No parameter can be specified.
 Must be a member of the class for which it performs the
conversion.
 Examples: From Book.
46
CONVERSION FUNCTION
#include <iostream> int main
using namespace std; {
coord o1(2, 3), o2(4, 3);
class coord
int i;

Department of CSE, BUET

{
int x, y;
public:
i = o1;
coord(int i, int j){ x = i; y = j; } // automatically converts to integer
operator int() { return x*y; } cout << i << ‘\n’;
};
i = 100 + o2;
// automatically converts to integer
cout << i << ‘\n’;

return 0;
}

47
 Department of CSE, BUET
48
CONVERSION FUNCTION
STATIC CLASS MEMBERS
 A class member can be declared as static
 Only one copy of a static variable exists – no matter how
many objects of the class are created
 All objects share the same variable
 It can be private, protected or public
 A static member variable exists before any object of its
class is created
 In essence, a static class member is a global variable that
simply has its scope restricted to the class in which it is
declared

49
STATIC CLASS MEMBERS
 When we declare a static data member within a class, we
are not defining it
 Instead, we must provide a definition for it elsewhere,
outside the class
 To do this, we re-declare the static variable, using the
scope resolution operator to identify which class it
belongs to
 All static member variables are initialized to 0 by default

50
STATIC CLASS MEMBERS
 The principal reason static member variables are supported by
C++ is to avoid the need for global variables
 Member functions can also be static
 Can access only other static members of its class directly
 Need to access non-static members through an object of
the class
 Does not have a this pointer
 Cannot be declared as virtual, const or volatile
 static member functions can be accessed through an object of
the class or can be accessed independent of any object, via the
class name and the scope resolution operator
 Usual access rules apply for all static members
 Example: static.cpp

51
 STATIC CLASS MEMBERS
class myclass { void main ( ) {
static int x; myclass ob1, ob2;
public: cout << ob1.getX() << endl; // 1
static int y; ob2.setX(5);
int getX() { return x; } cout << ob1.getX() << endl; // 5
void setX(int x) { cout << ob1.y << endl; // 2
myclass::x = x; myclass::y = 10;
} cout << ob2.y << endl; // 10
}; // myclass::x = 100;
int myclass::x = 1; // will produce compiler error
int myclass::y = 2; }

52
CONST MEMBER FUNCTIONS AND
MUTABLE
 When a class member is declared as const it can’t
modify the object that invokes it.
 A const object can’t invoke a non-const member

Department of CSE, BUET

function.
 But a const member function can be called by either
const or non-const objects.
 If you want a const member function to modify one or
more member of a class but you don’t want the function
to be able to modify any of its other members, you can
do this using mutable.
 mutable members can modified by a const member
function.
53
 Examples: From Book.
LECTURE CONTENTS
 Teach Yourself C++
 Chapter 3 (Full, with exercises)
 Chapter 13 (13.2,13.3 and 13.4)

54
 ARRAYS,
POINTERS
AND
REFERENCES
55
ARRAYS OF OBJECTS
 Arrays of objects of class can be declared just like other
variables.
 class A{ … };
 A ob[4];
 ob[0].f1(); // let f1 is public in A
 ob[3].x = 3; // let x is public in A
 In this example, all the objects of the array are initialized
using the default constructor of A.
 If A does not have a default constructor, then the above
array declaration statement will produce compiler error.

56
ARRAYS OF OBJECTS
 If a class type includes a constructor, an array of objects
can be initialized
 Initializing array elements with the constructor taking an
integer argument
class A{ public: int a; A(int n) { a = n; } };
 A ob[2] = { A(-1), A(-2) };
 A ob2[2][2] = { A(-1), A(-2), A(-3), A(-4) };
 In this case, the following shorthand form can also be
used
 A ob[2] = { -1, -2 };

57
ARRAYS OF OBJECTS
 If a constructor takes two or more arguments, then only
the longer form can be used.
class A{ public: int a, b; A(int n, int m) { a = n; b =
m; } };
 A ob[2] = { A(1, 2), A(3, 4) };
 Aob2[2][2] = { A(1, 1), A(2, 2), A(3, 3), A(4, 4) };

58
ARRAYS OF OBJECTS
• We can also mix no argument, one argument and multi-
argument constructor calls in a single array declaration.

class A
{
public:
A() { … } // must be present for this example to be
compiled
A(int n) { … }
A(int n, int m) { … }
};
– A ob[3] = { A(), A(1),A(2, 3) };
59
USING POINTERS TO
OBJECTS
 We can take the address of objects using the address
operator (&) and store it in object pointers.
 A ob; A *p = &ob;
 We have to use the arrow (->) operator instead of the dot
(.) operator while accessing a member through an object
pointer.
 p->f1(); // let f1 is public in A
 Pointer arithmetic using an object pointer is the same as
it is for any other data type.
 When incremented, it points to the next object.
 When decremented, it points to the previous object.

60
THIS POINTER
 A special pointer in C++ that points to the object that
generates the call to the method
 Let,
 class A{ public: void f1() { … } };
 A ob; ob.f1();
 The compiler automatically adds a parameter whose type
is “pointer to an object of the class” in every non-static
member function of the class.
 It also automatically calls the member function with the
address of the object through which the function is
invoked.
 So the above example works as follows –
 class A{ public: void f1( A *this ) { … } };
61
 A ob; ob.f1( &ob );
THIS POINTER
 It is through this pointer that every non-static member
function knows which object’s members should be used.

class A
{
int x;
public:
void f1()
{
x = 0; // this->x = 0;
}
};
62
THIS POINTER
 this pointer is generally used to access member variables
that have been hidden by local variables having the same
name inside a member function.

class A{ void f1() {

int x; int x = 0;
public: cout << x; // prints
A(int x) { value of local ‘x’
x = x; // only copies cout << this->x; //
local ‘x’ to itself; the prints value of member
member ‘x’ remains ‘x’
uninitialized }
this->x = x; // now its };
63
ok
}
USING NEW AND DELETE
 C++ introduces two operators for dynamically allocating
and deallocating memory :
 p_var = new type
 new returns a pointer to dynamically allocated
memory that is sufficient to hold a data obect of type
type
 delete p_var
 releases the memory previously allocated by new
 Memory allocated by new must be released using delete
 The lifetime of an object is directly under our control
and is unrelated to the block structure of the program

64
USING NEW AND DELETE
 In case of insufficient memory, new can report failure in
two ways
 By returning a null pointer
 By generating an exception
 The reaction of new in this case varies from compiler to
compiler

65
USING NEW AND DELETE
 Advantages
 No need to use sizeof operator while using new.
 New automatically returns a pointer of the specified
type.
 In case of objects, new calls dynamically allocates the
object and call its constructor
 In case of objects, delete calls the destructor of the
object being released

66
USING NEW AND DELETE
 Dynamically allocated objects can be given initial
values.
 int *p = new int;
 Dynamically allocates memory to store an integer value which
contains garbage value.
 int *p = new int(10);
 Dynamically allocates memory to store an integer value and
initializes that memory to 10.
 Note the use of parenthesis ( ) while supplying initial values.

67
USING NEW AND DELETE
 class A{ int x; public: A(int n) { x = n; } };
 A *p = new A(10);
 Dynamically allocates memory to store a A object and calls the
constructor A(int n) for this object which initializes x to 10.
 A *p = new A;
 It will produce compiler error because in this example class A does
not have a default constructor.

68
USING NEW AND DELETE
 We can also create dynamically allocated arrays using
new.
 But deleting a dynamically allocated array needs a slight
change in the use of delete.
 It is not possible to initialize an array that is
dynamically allocated.
 int *a= new int[10];
 Creates an array of 10 integers
 All integers contain garbage values

 Note the use of square brackets [ ]

 delete [ ] a;
 Delete the entire array pointed by a
 Note the use of square brackets [ ]

69
USING NEW AND DELETE
 It is not possible to initialize an array that is dynamically
allocated, in order to create an array of objects of a class,
the class must have a default constructor.
class A { class A {
int x; int x;
public: public:
A(int n) { x = n; } }; A() { x = 0; }
A(int n) { x = n; } };
A *array = new A[10]; A *array = new A[10]; // no
// compiler error error
// use array
delete [ ] array; 70
USING NEW AND DELETE
 A *array = new A[10];
 The default constructor is called for all the objects.
 delete [ ] array;
 Destructor is called for all the objects present in the
array.

71
REFERENCES
 A reference is an implicit pointer
 Acts like another name for a variable
 Can be used in three ways
 A reference can be passed to a function
 A reference can be returned by a function
 An independent reference can be created
 Reference variables are declared using the & symbol
 void f(int &n);
 Unlike pointers, once a reference becomes associated
with a variable, it cannot refer to other variables
72
REFERENCES
 Using pointer -  Using reference -
void f(int *n) { void f(int &n) {
*n = 100; n = 100;
} }
void main() { void main() {
int i = 0; int i = 0;
f(&i); f(i);
cout << i; // 100 cout << i; // 100
} }

73
REFERENCES
 A reference parameter fully automates the call-by-
reference parameter passing mechanism

 No need to use the address operator (&) while calling

a function taking reference parameter

 Inside a function that takes a reference parameter, the

passed variable can be accessed without using the
indirection operator (*)

74
REFERENCES
 Advantages
 The address is automatically passed

 Reduces use of ‘&’ and ‘*’

 When objects are passed to functions using

references, no copy is made

 Hence destructors are not called when the functions

ends

 Eliminates the troubles associated with multiple

destructor calls for the same object 75
PASSING REFERENCES TO
OBJECTS
 We can pass objects to functions using references

 No copy is made, destructor is not called when the

function ends

 As reference is not a pointer, we use the dot operator (.)

to access members through an object reference

76
PASSING REFERENCES TO
OBJECTS
class myclass { void main() {
int x; myclass obj;
public: cout << obj.getx() << endl;
myclass() { f(obj);
x = 0; cout << obj.getx() << endl;
cout << “Constructing\n”; }
}
~myclass() { Output:
cout << “Destructing\n”; Constructing
} 0
void setx(int n) { x = n; } 500
int getx() { return x; } Destructing
};
void f(myclass &o) {
o.setx(500);
77
}
RETURNING REFERENCES
 A function can return a reference
 Allows a functions to be used on the left side of an
assignment statement
 But, the object or variable whose reference is returned
must not go out of scope
 So, we should not return the reference of a local variable
 For the same reason, it is not a good practice to return
the pointer (address) of a local variable from a
function

78
RETURNING REFERENCES
int x; // global variable Output:
int &f() { 1
return x; 100
} 2
void main() { So, here f() can be used to both set
x = 1; the value of x and read the value
of x
cout << x << endl;
Example: From Book(151 – 153)
f() = 100;
cout << x << endl;
x = 2;
cout << f() << endl;
}
79
INDEPENDENT REFERENCES
 Simply another name for another variable
 Must be initialized when it is declared
 int &ref; // compiler error
 int x = 5; int &ref = x; // ok
 ref = 100;
 cout << x; // prints “100”
 An independent reference can refer to a constant
 int &ref=10; // compile error
 const int &ref = 10;

80
RESTRICTIONS
 We cannot reference another reference
 Doing so just becomes a reference of the original
variable
 We cannot obtain the address of a reference
 Doing so returns the address of the original variable
 Memory allocated for references are hidden from the
programmer by the compiler
 We cannot create arrays of references
 We cannot reference a bit-field
 References must be initialized unless they are
members of a class, are return values, or are function
parameters
81
LECTURE CONTENTS
 Teach Yourself C++
 Chapter 4 (See All Exercise)

82
 Department of CSE, BUET
FUNCTION OVERLOADING
83 Chapter 5
OBJECTIVES
 Overloading Constructor Functions
 Creating and Using a Copy Constructor

Department of CSE, BUET

 The overload Anachronism (not in syllabus)

 Using Default Arguments

 Overloading and Ambiguity

 Finding the address of an overloaded function

84
OVERLOADING CONSTRUCTOR
FUNCTIONS
 Itis possible to overload constructors, but
destructors cannot be overloaded.
 Three main reasons to overload a constructor

Department of CSE, BUET

function
 To gain flexibility
 To support arrays
 To create copy constructors
 There must be a constructor function for each
way that an object of a class will be created,
otherwise compile-time error occurs.

85
OVERLOADING CONSTRUCTOR
FUNCTIONS (CONTD.)
 Let, we want to write
 MyClass ob1, ob2(10);

Department of CSE, BUET

 Then MyClass should have the following two constructors (it may have
more)
 MyClass ( ) { … }
 MyClass ( int n ) { … }
 Whenever we write a constructor in a class, the compiler does not supply
the default no argument constructor automatically.
 No argument constructor is also necessary for declaring arrays of objects
without any initialization.
 MyClass array1[5]; // uses MyClass () { … } for each element
 But with the help of an overloaded constructor, we can also initialize the
elements of an array while declaring it.
 MyClass array2[3] = {1, 2, 3} // uses MyClass ( int n ) { … } for each element
86
OVERLOADING CONSTRUCTOR
FUNCTIONS (CONTD.)

 Overloading constructor functions also allows the programmer

to select the most convenient method to create objects.

Department of CSE, BUET

 Date d1(22, 9, 2007); // uses Date( int d, int m, int y )
 Date d2(“22-Sep-2007”); // uses Date( char* str )
 Another reason to overload a constructor function is to support
dynamic arrays of objects created using “new”.
 As dynamic arrays of objects cannot be initialized, the class
must have a no argument constructor to avoid compiler error
while creating dynamic arrays using “new”.

87
CREATING AND USING A COPY
CONSTRUCTOR
 By default when a assign an object to another object or initialize a
new object by an existing object, a bitwise copy is performed.
 This cause problems when the objects contain pointer to

Department of CSE, BUET

dynamically allocated memory and destructors are used to free that
memory.
 It causes the same memory to be released multiple times that causes
the program to crash.
 Copy constructors are used to solve this problem while we perform
object initialization with another object of the same class.
 MyClass ob1;
 MyClass ob2 = ob1; // uses copy constructor
 Copy constructors do not affect assignment operations.
 MyClass ob1, ob2;
 ob2 = ob1; // does not use copy constructor

88
CREATING AND USING A COPY
CONSTRUCTOR (CONTD.)
 Ifwe do not write our own copy constructor,
then the compiler supplies a copy constructor
that simply performs bitwise copy.

Department of CSE, BUET

 We can write our own copy constructor to dictate
precisely how members of two objects should be
copied.
 The most common form of copy constructor is
 classname (const classname &obj) {
 // body of constructor
}

89
CREATING AND USING A COPY
CONSTRUCTOR (CONTD.)

 Object initialization can occur in three ways

 When an object is used to initialize another in a declaration statement

Department of CSE, BUET

 MyClass y;
 MyClass x = y;

 When an object is passed as a parameter to a function

 func1(y); // calls “void func1( MyClass obj )”
 When a temporary object is created for use as a return value by a
function
 y = func2(); // gets the object returned from “MyClass func2()”
 See the examples from the book and the supplied codes to have
a better understanding of the activities and usefulness of copy
constructors.
 Example: copy-cons.cpp
90
USING DEFAULT ARGUMENTS

 It is related to function overloading.

 Essentially a shorthand form of function overloading

Department of CSE, BUET

 It allows to give a parameter a default value when no
corresponding argument is specified when the function is
called.
 void f1(int a = 0, int b = 0) { … }
 It can now be called in three different ways.
 f1(); // inside f1() ‘a’ is ‘0’ and b is ‘0’
 f1(10); // inside f1() ‘a’ is ‘10’ and b is ‘0’

 f1(10, 99); // inside f1() ‘a’ is ‘10’ and b is ‘99’

 We can see that we cannot give ‘b’ a new (non-default) value without
specifying a new value for ‘a’.
 So while specifying non-default values, we have to start from the
leftmost parameter and move to the right one by one. 91
USING DEFAULT ARGUMENTS
(CONTD.)

 Default arguments must be specified only once: either in the

function’s prototype or in its definition.

Department of CSE, BUET

 All default parameters must be to the right of any parameters
that don’t have defaults.
 void f2(int a, int b = 0); // no problem
 void f3(int a, int b = 0, int c = 5); // no problem
 void f4(int a = 1, int b); // compiler error
 So, once you begin to define default parameters, you cannot
specify any parameters that have no defaults.
 Default arguments must be constants or global variables. They
cannot be local variables or other parameters.
92
USING DEFAULT ARGUMENTS
(CONTD.)

 Relation
between default arguments and function

Department of CSE, BUET

overloading.
 void f1( int a = 0, int b = 0 ) { … }
 It acts as the same way as the following overloaded
functions –
 void f2( ) { int a = 0, b = 0; … }
 void f2( int a ) { int b = 0; … }

 void f2( int a, int b ) { … }

 Constructor functions can also have default

arguments. 93
USING DEFAULT ARGUMENTS
(CONTD.)

 It is possible to create copy constructors that take additional

arguments, as long as the additional arguments have default

Department of CSE, BUET

values.
 MyClass( const MyClass &obj, int x = 0 ) { … }
 This flexibility allows us to create copy constructors that have
other uses.
 See the examples from the book to learn more about the uses of
default arguments.

94
OVERLOADING AND AMBIGUITY
 Due to automatic type conversion rules.
 Example 1:

Department of CSE, BUET

 void f1( float f ) { … }
 void f1( double d ) { … }
 float x = 10.09;
 double y = 10.09;
 f1(x); // unambiguous – use f1(float)
 f1(y); // unambiguous – use f1(double)
 f1(10); // ambiguous, compiler error
 Because integer ‘10’ can be promoted to both “float” and “double”.

95
OVERLOADING AND AMBIGUITY
(CONTD.)
 Due to the use of reference parameters.
 Example 2:

Department of CSE, BUET


b){…}
void f2( int a, int

void f2(int a, int &b ) { … }



 intx = 1, y = 2;
 f2(x, y); // ambiguous, compiler error

96
OVERLOADING AND AMBIGUITY
(CONTD.)
 Due to the use of default arguments.
 Example 3:

Department of CSE, BUET

 void f3( int a ) { … }

void f3(int a, int b = 0){…}
 f3(10, 20); // unambiguous – calls f3(int, int)
 f3(10); // ambiguous, compiler error

97
FINDING THE ADDRESS OF AN
OVERLOADED FUNCTION
 Example:
 void space( int a ) { … }
 void space( int a, char c ) { … }

Department of CSE, BUET

 void (*fp1)(int);
 void (*fp2)(int, char);
 fp1 = space; // gets address of space(int)
 fp2 = space; // gets address of space(int, char)
 So, it is the declaration of the pointer that
determines which function’s address is assigned.

98
LECTURE CONTENTS
 Teach Yourself C++
 Chapter 5 (Full, with exercises)

Department of CSE, BUET

 Except “The overload Anachronism”

99
 Department of CSE, BUET
INHERITANCE
100 Chapter 7
OBJECTIVES
 Base class access control
 Using protected members

Department of CSE, BUET

 Visibility of base class members in derived class
 Constructors, destructors, and inheritance
 Multiple inheritance
 Virtual base classes

101
BASE CLASS ACCESS CONTROL
 classderived-class-name : access base-class-
name { … };

Department of CSE, BUET

 Here access is one of three keywords
 public
 private
 protected
 Use of access is optional
 It is private by default if the derived class is a class
 It is public by default if the derived class is a struct

102
USING PROTECTED MEMBERS
 Cannot be directly accessed by non-related classes and
functions

Department of CSE, BUET

 But can be directly accessed by the derived classes

 Can also be used with structures

103
VISIBILITY OF BASE CLASS
MEMBERS IN DERIVED CLASS
When a class (derived) inherits from another (base) class, the visibility
of the members of the base class in the derived class is as follows.

Member visibility in derived class

Type of Inheritance
Member access Private Protected Public
specifier in base
class
Private Not Inherited Not Inherited Not Inherited
Protected Private Protected Protected
Public Private Protected Public
Department of CSE, BUET 104
CONSTRUCTORS, DESTRUCTORS,
AND INHERITANCE
 Both base class and derived class can have
constructors and destructors.
 Constructor functions are executed in the order

Department of CSE, BUET

of derivation.
 Destructor functions are executed in the reverse
order of derivation.
 While working with an object of a derived class,
the base class constructor and destructor are
always executed no matter how the inheritance
was done (private, protected or public).

105
 CONSTRUCTORS, DESTRUCTORS,
AND INHERITANCE (CONTD.)
 class base {  void main() {
 public:  derived obj;
 base() {  }

Department of CSE, BUET

 cout << “Constructing base class\n”;
 }  Output:
 ~base() {  Constructing base class
 Constructing derived class
 cout << “Destructing base class\n”;  Destructing derived class
 }  Destructing base class
 };
 class derived : public base {
 public:
 derived() {
 cout << “Constructing derived class\n”;
 }
 ~derived() {
 cout << “Destructing derived class\n”;
 }
106
 };
CONSTRUCTORS, DESTRUCTORS,
AND INHERITANCE (CONTD.)
 If a base class constructor takes parameters then it is the
responsibility of the derived class constructor(s) to
collect them and pass them to the base class constructor

Department of CSE, BUET

using the following syntax -
 derived-constructor(arg-list) : base(arg-list) { … }
 Here “base” is the name of the base class
 It is permissible for both the derived class and the base
class to use the same argument.
 It is also possible for the derived class to ignore all
arguments and just pass them along to the base class.

107
 CONSTRUCTORS, DESTRUCTORS,
AND INHERITANCE (CONTD.)
 class MyBase {  void main() {
 public:  MyDerived o1; // x = 0, y = 0
 int x;  MyDerived o2(5); // x = 5, y = 0

Department of CSE, BUET

 MyBase(int m) { x = m; }  MyDerived o3(6, 7); // x = 6, y = 7
 };  }
 class MyDerived : public MyBase {
 public:
 int y;
 As “MyBase” does not have a default (no
argument) constructor, every constructor
 MyDerived() : MyBase(0) { y = 0; } of “MyDerived” must pass the parameters
 MyDerived(int a) : MyBase(a) required by the “MyBase” constructor.
 {
 y = 0;
 }
 MyDerived(int a, int b) : MyBase(a)
 {
 y = b;
 }
108
 };
MULTIPLE INHERITANCE

 A derived class can inherit more than one base class in

two ways.

Department of CSE, BUET

 Option-1: By a chain of inheritance
 b1 -> d1 -> dd1 -> ddd1 -> …
 Here b1 is an indirect base class of both dd1 and ddd1

 Constructors are executed in the order of inheritance

 Destructors are executed in the reverse order

 Option-2: By directly inheriting more than one base class

 class d1 : access b1, access b2, …, access bN { … }
 Constructors are executed in the order, left to right, that the base
classes are specified
 Destructors are executed in the reverse order

109
MULTIPLE INHERITANCE (CONTD.)

b1

Department of CSE, BUET

b1 b2 b3
d1

dd1
d1

ddd1

Option - 1 Option - 2 110

VIRTUAL BASE CLASSES

 Consider the situation

Department of CSE, BUET

shown. Base Base
 Two copies of Base are
included in D3.
D1 D2
 This causes ambiguity
when a member of Base
is directly used by D3.
D3
111
VIRTUAL BASE CLASSES (CONTD.)
 class Base {  class D3 : public D1, public
 public: D2 {
 int i;  // contains two copies of ‘i’

Department of CSE, BUET

 };  };
 class D1 : public Base {  void main() {
 public:  D3 obj;
 int j;  obj.i = 10; // ambiguous,
compiler error
 };  obj.j = 20; // no problem
 class D2 : public Base {  obj.k = 30; // no problem
 public:  obj.D1::i = 100; // no
 int k; problem
 };  obj.D2::i = 200; // no
problem
 } 112
 VIRTUAL BASE CLASSES (CONTD.)

 class Base {  class D3 : public D1, public D2 {

 public:  // contains only one copy of ‘i’

Department of CSE, BUET

 int i;  }; // no change in this class definition
 };  void main() {
 class D1 : virtual public Base {  D3 obj;
 public:  obj.i = 10; // no problem
 int j;  obj.j = 20; // no problem
 }; // activity of D1 not affected  obj.k = 30; // no problem
 class D2 : virtual public Base {  obj.D1::i = 100; // no problem,
 public: overwrites ‘10’
 int k;  obj.D2::i = 200; // no problem,
overwrites ‘100’
 }; // activity of D2 not affected  }
113
LECTURE CONTENTS
 Teach Yourself C++
 Chapter 7 (Full, with exercise)

Department of CSE, BUET

 Study the examples from the book carefully

114
 Department of CSE, BUET
VIRTUAL FUNCTIONS
115 Chapter 10
OBJECTIVES
 Polymorphism in C++
 Pointers to derived classes

Department of CSE, BUET

 Important point on inheritance
 Introduction to virtual functions
 Virtual destructors
 More about virtual functions
 Final comments
 Applying polymorphism

116
POLYMORPHISM IN C++
 2 types
 Compile time polymorphism

Department of CSE, BUET

 Uses static or early binding
 Example: Function and operator overloading

 Run time polymorphism

 Uses dynamic or early binding
 Example: Virtual functions

117
POINTERS TO DERIVED CLASSES
 C++ allows base class pointers to point to
derived class objects.

Department of CSE, BUET

 Let we have –
 class base { … };
 class derived : public base { … };

 Then we can write –

 base *p1; derived d_obj; p1 = &d_obj;
 base *p2 = new derived;

118
POINTERS TO DERIVED CLASSES
(CONTD.)
 Using a base class pointer (pointing to a derived
class object) we can access only those members
of the derived object that were inherited from

Department of CSE, BUET

the base.
 It
is different from the behavior that Java shows.
 We can get Java-like behavior using virtual functions.
 This is because the base pointer has knowledge
only of the base class.
 It knows nothing about the members added by
the derived class.

119
POINTERS TO DERIVED CLASSES
(CONTD.)
 class base {  void main() {
 public:  base b1;
 void show() {  b1.show(); // base

Department of CSE, BUET

 cout << “base\n”;  derived d1;
 }  d1.show(); // derived
 };  base *pb = &b1;
 class derived : public base {  pb->show(); // base
 public:  pb = &d1;
 void show() {  pb->show(); // base
 cout << “derived\n”;  }
 }  All the function calls here are
 }; statically bound

120
POINTERS TO DERIVED CLASSES
(CONTD.)
 While it is permissible for a base class pointer to point to
a derived object, the reverse is not true.
 base b1;

Department of CSE, BUET

 derived *pd = &b1; // compiler error
 We can perform a downcast with the help of type-
casting, but should use it with caution (see next slide).

121
POINTERS TO DERIVED CLASSES
(CONTD.)

 Let we have –
 class base { … };

Department of CSE, BUET

 class derived : public base { … };
 class xyz { … }; // having no relation with “base” or “derived”
 Then if we write –
 base b_obj; base *pb; derived d_obj; pb = &d_obj; // ok
 derived *pd = pb; // compiler error
 derived *pd = (derived *)pb; // ok, valid downcasting
 xyz obj; // ok
 pd = (derived *)&obj; // invalid casting, no compiler error, but may
cause run-time error
 pd = (derived *)&b_obj; // invalid casting, no compiler error, but may
cause run-time error
122
POINTERS TO DERIVED CLASSES
(CONTD.)

 Infact using type-casting, we can use pointer of any class

Department of CSE, BUET

to point to an object of any other class.
 The compiler will not complain.
 During run-time, the address assignment will also succeed.
 But if we use the pointer to access any member, then it may cause
run-time error.
 Java
prevents such problems by throwing
“ClassCastException” in case of invalid casting.

123
POINTERS TO DERIVED CLASSES
(CONTD.)

 Pointer arithmetic is relative to the data type the

Department of CSE, BUET

pointer is declared as pointing to.
 If we point a base pointer to a derived object and then
increment the pointer, it will not be pointing to the
next derived object.
 It will be pointing to (what it thinks is) the next base
object !!!
 Be careful about this.

124
IMPORTANT POINT ON INHERITANCE

 In C++, only public inheritance supports the perfect IS-A relationship.

 In case of private and protected inheritance, we cannot treat a derived class

Department of CSE, BUET

object in the same way as a base class object
 Public members of the base class becomes private or protected in the derived
class and hence cannot be accessed directly by others using derived class objects
 If we use private or protected inheritance, we cannot assign the address of a
derived class object to a base class pointer directly.
 We can use type-casting, but it makes the program logic and structure
complicated.
 This is one of the reason for which Java only supports public inheritance.

125
INTRODUCTION TO VIRTUAL
FUNCTIONS
 A virtual function is a member function that is
declared within a base class and redefined
(called overriding) by a derived class.

Department of CSE, BUET

 It implements the “one interface, multiple
methods” philosophy that underlies
polymorphism.
 The keyword virtual is used to designate a
member function as virtual.
 Supports run-time polymorphism with the help
of base class pointers.

126
INTRODUCTION TO VIRTUAL
FUNCTIONS (CONTD.)
 While redefining a virtual function in a derived class, the
function signature must match the original function
present in the base class.

Department of CSE, BUET

 So, we call it overriding, not overloading.
 When a virtual function is redefined by a derived class,
the keyword virtual is not needed (but can be specified
if the programmer wants).
 The “virtual”-ity of the member function continues along
the inheritance chain.
 A class that contains a virtual function is referred to as a
polymorphic class.

127
INTRODUCTION TO VIRTUAL
FUNCTIONS (CONTD.)
 class base {  void main() {
 public:  base b1;

Department of CSE, BUET

 virtual void show() {  b1.show(); // base - (s.b.)
 cout << “base\n”;  derived d1;
 }  d1.show(); // derived – (s.b.)
 };
 base *pb = &b1;
 class derived : public base {
 pb->show(); // base - (d.b.)
 public:
 pb = &d1;
 void show() {
 pb->show(); // derived (d.b.)
 }
 cout << “derived\n”;
 Here,
 }  s.b. = static binding 128
 };  d.b. = dynamic binding
INTRODUCTION TO VIRTUAL
FUNCTIONS (CONTD.)
 class base {  class d2 : public base {
 public:  public:

Department of CSE, BUET

 virtual void show() {  void show() {
 cout << “base\n”;  cout << “derived-2\n”;
 }  }
 };
 };
 class d1 : public base {
 void main() {
 public:
 base *pb; d1 od1; d2 od2;
 void show() {
 int n;
 cout << “derived-1\n”;
 cin >> n;
 }
 if (n % 2) pb = &od1;
 else pb = &od2;
 };
 pb->show(); // guess what ?? 129
Run-time polymorphism
 }
VIRTUAL DESTRUCTORS
 Constructors cannot be virtual, but destructors can be
virtual.

Department of CSE, BUET

 It ensures that the derived class destructor is called when
a base class pointer is used while deleting a dynamically
created derived class object.

130
 VIRTUAL DESTRUCTORS (CONTD.)

 class base {  void main() {

 public:  base *p = new derived;

Department of CSE, BUET

 ~base() {  delete p;
 cout << “destructing base\n”;  }
 }
 };  Output:
 class derived : public base {  destructing base
 public:
 ~derived() {
 cout << “destructing derived\n”;
 }
 };

131
Using non-virtual destructor
 VIRTUAL DESTRUCTORS (CONTD.)

 class base {  void main() {

 public:  base *p = new derived;

Department of CSE, BUET

 virtual ~base() {  delete p;
 cout << “destructing base\n”;  }
 }
 };  Output:
 class derived : public base {  destructing derived
 destructing base
 public:
 ~derived() {
 cout << “destructing derived\n”;
 }
 };

132
Using virtual destructor
MORE ABOUT VIRTUAL FUNCTIONS
 If we want to omit the body of a virtual function
in a base class, we can use pure virtual functions.

Department of CSE, BUET

 virtual ret-type func-name(param-list) = 0;
 It makes a class an abstract class.
 We cannot create any objects of such classes.
 It forces derived classes to override it.
 Otherwise they become abstract too.

133
MORE ABOUT VIRTUAL
FUNCTIONS (CONTD.)
 Pure virtual function
 Helps to guarantee that a derived class will provide its

Department of CSE, BUET

own redefinition.
 We can still create a pointer to an abstract class
 Because it is at the heart of run-time polymorphism
 When a virtual function is inherited, so is its
virtual nature.
 We can continue to override virtual functions
along the inheritance hierarchy.

134
FINAL COMMENTS

 Run-time polymorphism is not automatically activated

in C++.

Department of CSE, BUET

 We have to use virtual functions and base class
pointers to enforce and activate run-time
polymorphism in C++.
 But, in Java, run-time polymorphism is automatically
present as all non-static methods of a class are by
default virtual in nature.
 We just need to use superclass references to point to
subclass objects to achieve run-time polymorphism in Java.
135
APPLYING POLYMORPHISM
 Early binding
 Normal functions, overloaded functions
 Nonvirtual member and friend functions

Department of CSE, BUET

 Resolved at compile time
 Very efficient
 But lacks flexibility
 Late binding
 Virtual functions accessed via a base class pointer
 Resolved at run-time
 Quite flexible during run-time
 But has run-time overhead; slows down program execution

136
LECTURE CONTENTS
 Teach Yourself C++
 Chapter 10 (Full, with exercises)

Department of CSE, BUET

 Study the examples from the book carefully

137
MANIPULATING
STRINGS
Resources
[1] Object Oriented Programming with C++ (3rd Edition) E
Balagurusamy
[2] Teach Yourself C++ (3rd Edition) H Schildt
INTRODUCTION
 A string is a sequence of character.

 We have used null terminated <char> arrays (C-strings

or C-style strings) to store and manipulate strings.

 ANSI C++ provides a class called string.

 We must include <string> in our program.

AVAILABLE OPERATIONS
 Creating string objects.
 Reading string objects from keyboard.

 Displaying string objects to the screen.

 Finding a substring from a string.

 Modifying string objects.

 Adding string objects.

 Accessing characters in a string.

 Obtaining the size of string.

 And many more.

COMMONLY USED STRING
CONSTRUCTORS
 String();
 // For creating an empty string.
 String(const char *str);
 // For creating a string object from a null-terminated string.
 String(const string &str);
 // For creating a string object from other string object.
CREATING STRING OBJECTS
 string s1, s3; // Using constructor with no arguments.
 string s2(“xyz”); // Using one-argument constructor.
 s1 = s2; // Assigning string objects
 s3 = “abc” + s2; // Concatenating strings

 cin >> s1; // Reading from keyboard (one word)

 cout << s2; // Display the content of s2
 getline(cin, s1) // Reading from keyboard a line of text

 s3 += s1; // s3 = s3 + s1;
 s3 += “abc”; // s3 = s3 + “abc”;
MANIPULATING STRING OBJECTS
 string s1(“12345”);
 string s2(“abcde”);

 s1.insert(4, s2); // s1 = 1234abcde5

 s1.erase(4, 5); // s1 = 12345

 s2.replace(1, 3, s1); // s2 = a12345e

MANIPULATING STRING OBJECTS
 insert()

 erase()

 replace()

 append()
RELATIONAL OPERATIONS
Operator Meaning
== Equality
!= Inequality
< Less than
<= Less than or equal
> Greater than
>= Greater than or equal

 string s1(“ABC”); string s2(“XYZ”);

 int x = s1.compare(s2);
x == 0 if s1 == s2
 x > 0 if s1 > s2
 x < 0 if s1 < s2
STRING CHARACTERISTICS
void display(string &str)
{
cout << “Size = ” << str.size() << endl;
cout << “Length = ” << str.length() << endl;
cout << “Capacity = ” << str.capacity() << endl;
cout << “Max Size = ” << str.max_size() << endl;
cout << “Empty: ” << (str.empty() ? “yes” : “no”) <<
endl;
cout << endl << endl;
}
STRING CHARACTERISTICS
Function Task
size() Number of elements currently stored

length() Number of elements currently stored

capacity() Total elements that can be stored

max_size() Maximum size of a string object that a
system can support

emply() Return true or 1 if the string is empty

otherwise returns false or 0

resize() Used to resize a string object (effects

only size and length)
ACCESSING CHARACTERS IN STRINGS
Function Task
at() For accessing individual characters
substr() For retrieving a substring
find() For finding a specific substring
find_first_of() For finding the location of first occurrence of the specific
character(s)
find_last_of() For finding the location of first occurrence of the specific
character(s)

[] operator For accessing individual character. Makes the string object to look
like an array.
COMPARING AND SWAPPING
 There is another overloaded version of compare

 int compare(int start_1, int length_1, string s_2, int

start_2, int length_2)

 string s1, s2;

 int x = s1.compare(0, 2, s2, 2, 2);

 s1.swap(s2)
 Exchanges the content of string s1 and s2
LECTURE CONTENTS
 [1] Object Oriented Programming with C++ (3rd Edition)
E Balagurusamy
 Chapter 15 (Full)
 [2] Teach Yourself C++ (3rd Edition) H Schildt
 Examples only
 Study the examples and exercise from both books
carefully