C by balaguruswami - e.balagurusamy

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 -
7
#include <iostream.h>
int main()
{
/* program code */
return 0;
}

TWO VERSIONS OF C++ (CONT.)
 A modern-style C++ program that uses the new-
style headers and a namespace -
8
#include <iostream>
using namespace std;
int main()
{
/* program code */
return 0;
}

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
Used to 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!”;
printf(“Hello World!”);
 cout << iCount; /* int iCount */
printf(“%d”, iCount);
 cout << 100.99;
printf(“%f”, 100.99);
 cout << “n”, or cout << ‘n’, or cout <<
endl
printf(“n”)
 In general, cout << expression;
12
Do we smell polymorphism here???
cout ???
Shift right operator ???
How does a shift right
operator produce output
to the screen?

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)
15
include <iostream>
int main()
{
char str[16];
std::cout << “Enter a
string: ”;
std::cin >> str;
std::cout << “You entered:
” << str;
}
include <iostream>
int main()
{
char str[16];
cout << “Enter a string: ”;
cin >> str;
cout << “You entered: ”
<< str;
}

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

CLASSES: A FIRST LOOK
 General syntax -
17
class class-name
{
// private functions and variables
public:
// public functions and variables
}object-list (optional);

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.
22
Q. Can we confuse the compiler with
function overloading?
A. Sure. In several ways. Keep exploring C++.

C++ KEYWORDS (PARTIAL LIST)
23
 bool
 catch
 delete
 false
 friend
 inline
 namespace
 new
 operator
 private
 protected
 public
 template
 this
 throw
 true
 try
 using
 virtual
 wchar_t

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
32
inline int even(int x)
{
return !(x%2);
}
int main()
{
if(even(10)) cout << “10 is
evenn”;
// becomes if(!(10%2))
if(even(11)) cout << “11 is
evenn”;
// becomes if(!(11%2))
return 0;
}
 The inline specifier is a
request, not a command, to
the compiler.
 Some compilers will not in-
line a function if it contains
 A static variable
 A loop, switch or goto
 A return statement
 If the function is recursive

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
34
// Automatic in-lining
class myclass
{
int a;
public:
myclass(int n) { a = n; }
void set_a(int n) { a = n; } int
get_a() { return a; }
};
// Manual in-lining
class myclass
{
int a;
public:
myclass(int n);
void set_a(int n);
int get_a();
};
inline void myclass::set_a(int n)
{
a = n;
}

LECTURE CONTENTS
 Teach Yourself C++
 Chapter 1 (Full, with exercises)
 Chapter 2.1, 2,2, 2.4, 2.6, 2.7
35

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 two or more different classes 41

FRIEND FUNCTIONS
42
class MyClass
{
int a; // private member
public:
MyClass(int a1) {
a = a1;
}
friend void ff1(MyClass obj);
};
// friend keyword not used
void ff1(MyClass obj)
{
cout << obj.a << endl;
// can access private
member ‘a’ directly
MyClass obj2(100);
cout << obj2.a << endl;
}
void main()
{
MyClass o1(10);
ff1(o1);
}

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
44
class YourClass; // a forward
declaration
class MyClass {
public:
MyClass(int a1) { a = a1; }
friend int compare
(MyClass obj1, YourClass
obj2);
};
class YourClass {
public:
YourClass(int a1) { a = a1; }
friend int compare (MyClass
obj1, YourClass obj2);
};
void main() {
MyClass o1(10); YourClass
o2(5);
int n = compare(o1, o2); // n = 5
}
int compare (MyClass obj1,
YourClass obj2) {
return (obj1.a – obj2.a);
}

FRIEND FUNCTIONS
45
class YourClass; // a forward
declaration
class MyClass {
public:
MyClass(int a1) { a = a1; }
int compare (YourClass obj) {
return (a – obj.a)
}
};
class YourClass {
public:
YourClass(int a1) { a = a1; }
friend int MyClass::compare
(YourClass obj);
};
void main() {
MyClass o1(10); Yourclass
o2(5);
int n = o1.compare(o2); // n = 5
}

CONVERSION FUNCTION
 Used to convert an object of one type into an
object of another type.
 A conversion function automatically converts an
object 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
DepartmentofCSE,BUET

CONVERSION FUNCTION
47
#include <iostream>
class coord
{
int x, y;
public:
coord(int i, int j){ x = i; y = j; }
operator int() { return x*y; }
};
int main
{
coord o1(2, 3), o2(4, 3);
int i;
i = o1;
// automatically converts to integer
cout << i << ‘n’;
i = 100 + o2;
// automatically converts to integer
cout << i << ‘n’;
return 0;
}

CONVERSION FUNCTION
48

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

 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

 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

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

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
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.
 Examples: From Book.
53

LECTURE CONTENTS
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 ) { … } };
A ob; ob.f1( &ob );
61

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.
63
class A{
int x;
public:
A(int x) {
x = x; // only copies
local ‘x’ to itself; the
member ‘x’ remains
uninitialized
this->x = x; // now
its ok
}
void f1() {
int x = 0;
cout << x; // prints
value of local ‘x’
cout << this->x; //
prints value of
member ‘x’
}
};

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

 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

 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

 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

 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

 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

 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.
70
class A {
int x;
public:
A(int n) { x = n; } };
A *array = new A[10];
// compiler error
class A {
int x;
public:
A() { x = 0; }
A(int n) { x = n; } };
A *array = new A[10]; //
no error
// use array
delete [ ] array;

 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
73
 Using pointer -
void f(int *n) {
*n = 100;
}
void main() {
int i = 0;
f(&i);
cout << i; // 100
}
 Using reference -
void f(int &n) {
n = 100;
}
void main() {
int i = 0;
f(i);
cout << i; // 100
}

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
77
class myclass {
int x;
public:
myclass() {
x = 0;
cout << “Constructingn”;
}
~myclass() {
cout << “Destructingn”;
}
void setx(int n) { x = n; }
int getx() { return x; }
};
void f(myclass &o) {
o.setx(500);
}
void main() {
myclass obj;
cout << obj.getx() << endl;
f(obj);
cout << obj.getx() << endl;
}
Output:
Constructing
0
500
Destructing

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
79
int x; // global variable
int &f() {
return x;
}
void main() {
x = 1;
cout << x << endl;
f() = 100;
cout << x << endl;
x = 2;
cout << f() << endl;
}
Output:
1
100
2
So, here f() can be used to both
set the value of x and read the
value of x
Example: From Book(151 –
153)

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
Chapter 4 (See All Exercise)
82

FUNCTION OVERLOADING
Chapter 5
83

OBJECTIVES
 Overloading Constructor Functions
 Creating and Using a Copy Constructor
 The overload Anachronism (not in
syllabus)
 Using Default Arguments
 Overloading and Ambiguity
 Finding the address of an overloaded
function
84

OVERLOADING
CONSTRUCTOR FUNCTIONS
 It is possible to overload constructors, but
destructors cannot be overloaded.
 Three main reasons to overload a
constructor 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
(CONTD.)
 Let, we want to write
 MyClass ob1, ob2(10);
 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
(CONTD.)
 Overloading constructor functions also allows the
programmer to select the most convenient method to
create objects.
 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
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

COPY CONSTRUCTOR
(CONTD.)
 If we do not write our own copy
constructor, then the compiler supplies a
copy constructor that simply performs
bitwise copy.
 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

COPY CONSTRUCTOR
(CONTD.)
 Object initialization can occur in three ways
 When an object is used to initialize another in a declaration
statement
 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
 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

(CONTD.)
 Default arguments must be specified only once: either
in the function’s prototype or in its definition.
 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

(CONTD.)
 Relation between default arguments and
function 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

(CONTD.)
 It is possible to create copy constructors that take
additional arguments, as long as the additional
arguments have default 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:
 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:

void f2( int a, int b) { … }

void f2(int a, int &b) { … }
 int x = 1, y = 2;
 f2(x, y); // ambiguous, compiler error
96

OVERLOADING AND
AMBIGUITY (CONTD.)
 Due to the use of default arguments.
 Example 3:
 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 ) { … }
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
 Chapter 5 (Full, with exercises)
 Except “The overload Anachronism”
99

INHERITANCE
Chapter 7
100

C by balaguruswami - e.balagurusamy

C by balaguruswami - e.balagurusamy

More Related Content

What's hot

Similar to C by balaguruswami - e.balagurusamy

Recently uploaded

C by balaguruswami - e.balagurusamy