C++ Notes
Before using this pointer to point to a set of
Major topics covered:
 Memory Allocation
 Classes and Objects
 Operation Overloading
Tips for defining and undefining
directives and use of macros
• All the preprocessor directives start with the #
sign
• A symbol cannot be redefined without
undefining it first
• The conditional compilation directives help in
debugging the program
• Do not declare variable names starting with
underscore
• Always use parenthesis while defining
macros that takes arguments
The Pointer function for dynamic
memory Allocation:
The functions used for dynamic memory
allocation, provide a chunk of memory from
heap. The function does not know for what
data type this chunk of memory will be used? It
returns a pointer of type void. A pointer ptr of
type void is declared as under.
void *ptr ;
The ‘void’ is a special type of pointers. We
have to cast it before its use. The cast means
the conversion of ‘void’ into a type of pointer
that can be used for native data type like int,
char, float etc. The operator used for casting, in
C, is standard cast operator. We write the
name of the type in parentheses. Suppose we
have a pointer ptr defined as a void pointer like
void *ptr ;
integers, we will at first cast it. It means that it
will be converted into a type of a pointer to an
integer. The syntax of doing this casting is
simple and is given below.
( int * ) ptr ;
Here both int and * are written in parentheses.
The int is the data type into which we are
converting a void pointer ptr. Now ptr is a
pointer to an integer.
calloc Function
The syntax of the calloc function is as follows.
void *calloc (size_t n, size_t el_size)
This function takes two arguments. The first
argument is the required space in terms of
numbers while the second one is the size of
the space. So we can say that we require n
elements of type int.
malloc Function
The malloc function takes one argument i.e.
the number of bytes to be allocated. The
syntax of the function is void * malloc (size_t
size) ;
It returns a void pointer to the starting of the
chunk of the memory allocated from the heap
in case of the availability of that memory. If the
memory is not available or is fragmented (not
in a sequence), malloc will return a NULL
pointer. While using malloc, we normally make
use sizeof operator and a call to malloc
function is written in the following way.
malloc (1000 * sizeof(int)) ;
Here * is multiplication operator and not a
dereference operator of a pointer.
Free( )
We use a function free. This function returns
the allocated memory, got through calloc or
malloc, back to the heap. The argument that is
passed to this function is the pointer through
which we have allocated the memory earlier. In
our program, we write
free (iptr) ;
Realloc Function
We can reallocate the same memory with a
new size according to our requirement. The
function that reallocates the memory is realloc.
The syntax of realloc is given below.
void realloc (void * ptr, size_t size ) ;
Memory Leak
This is an error while managing memory
allocation. Suppose there was a pointer
pointing to a memory chunk through heap and
under some circumstance it got deleted or
removed. Now there is no pointer for that
memory chunk and we cannot use this memory
in any of the programs. This can result is loss
of every piece of memory if it continues. This
result in system halt or system crash and
computer can be rebooted to get that memory
back after refreshing. For avoiding this
condition we should always free( ) the memory
before exiting the pointer. The second
necessary thing is that after freeing the
memory, explicitly assign NULL to the pointer.
Its benefit is that this pointer can be checked if
it is pointing to some memory.
Dangling Pointers
This is the opposite of memory leak. In this
case the pointer for memory chunk exists but
somehow that memory gets deallocated and
when we use such a pointer to write a program
in the memory, it can cause unwanted
problems.
History of C++
C language was developed by scientists of Bell
Labs in 1970s. It is very lean and mean
language, very concise but with lot of power. C
conquered the programming world and took it
by storm. Major operating systems e.g., Unix
was written in C language.
Going briefly into the history of languages, after
the Machine Language (language of 0s and
1s), the Assembly Language was developed.
Using Assembly language, programmers could
use some symbolic codes, which were easier
to understand by novice people. After that
high-level languages like COBOL, FORTRAN
were developed.
Top down Structured Programming
Basically, a problem is broken into small pieces
or modules and each small piece corresponds
to a function. Following are its basic points:
 Divide and Conquer
 Single entry Single exit
 Comment your programs
Placement of Variable declarations
This has to do with the declaration of the
variables inside the code. In C language, all
the variables are declared at the top of the
function or code block and then we can use
them later on in the code.
Inline Functions
While using macros, we use the name of the
macro in our program. Before the compilation
process starts the macro names are replaced
by the preprocessor with their definitions
(defined with #define).
Inline functions also work more or less in the
same manner as macros. The functions are
declared inline by writing inline keyword before
the name of the function. This is a directive to
the compiler and it causes the full definition of
the function to be inserted in each place the
function is called. Inserting individual copies of
functions eliminates the overhead of calling a
function (such as loading parameters onto the we create variables of a class, a special name
stack). is used for them i.e. Objects.

Overloaded Functions “Instances of a class are called objects”.

Function overloading has the same concept With the definition of class, we have a new
that the name of the function will remain same data type like int, char etc. Here int i; means ‘i’
but its behavior may change. For example, if is an instance of data type int. When we take a
we want to take square root of a number. That variable of a class, it becomes the instance of
number can be an integer, float or a double that class, called object.
and depending on the type of the argument, we
may need to do different calculation.
While overloading functions, we will write
separate functions for separate data types but PRIVATE
the function name will remain same. Return
It is the keyword of hiding data from outside but
type can be different if we want to change, for
the data under private is accessible by its own
example in the above case we might want to
data members of class which are public.
return an int for square root function for int and
double for a square root of a double typed PUBLIC
variable. Now, we will declare them as under:
This keyword simply allows data members of
int sqrt (int i); class to be accessible or readable from outside
the class.
double sqrt (double d);
UTILITY FUNCTIONS
Now, we have two functions with the same
name. How will they be differentiated inside the These are a utility used by other methods of
program? The differentiation comes from the the class. However, they are not functions,
parameters, which are passed to these supposed to be accessed from outside the
functions. So the overloaded functions are class. So they are kept private.
differentiated using type and number of
arguments passed to the function and not by
the return type. CONSTRUCTORS: Generally, a constructor
initializes the object into a state that is
What is the advantage of this function
recognizable and acceptable. The default
overloading? Our program is more readable
constructor does not take any parameter. We
after using function overloading. Instead of
can have many constructors of a class by
having lot of functions doing the same kind of
overloading them.
work but with different names.
Types of Constructors
Classes and Objects
1. Compiler Generated Constructor
“A class includes both data members as well 2. Simple Constructor
as functions to manipulate that data”. 3. Parameterized Constructor
These functions are called ‘member
functions’. We also call them methods. So a DESTRUCTORS: The name of the
class has data (the variables) and functions to destructor is the same as that of a class with a
manipulate that data. A class is a ‘user preceding tilde sign (~).
defined’ data type. This way, we expand the
language by creating a new data type. When
The destructor cannot be overloaded. This
means that there will be only one destructor for
a class.
The destructor is used normally for this
purpose to make sure that any allocated
memory is de-allocated and returned to free
store (heap).
The destructors take no arguments. The
destructors don’t return a value. So they don’t
have a return type and no return statement in
the body.
TIPS
• Explicitly write keyword private in the class
definition.
• Separate the interface and implementation.
• The default constructor has no arguments.
• Constructor has the same name as of class.
• The data members of the class are initialized
at runtime.
• Initializing the data members in the definition
of the class is a syntax error.
MEMORY Allocation in C++
NEW: The new operator is used in C++ for
memory allocation and its syntax is
new int;
int *iptr;
iptr = new int;
DELETE: Delete operator is used to free the
memory when the allocation is done by using
new as shown below:
int *iptr;
iptr = new int [10]; // Memory for 10 ints is
allocated dynamically.
delete iptr; // Allocated is freed and returned to
the free store.
STRUCTURES IN C++
Structures and classes in C++ are quite similar. C+
+ structure is declared with the same keyword
struct as in C. Unlike C structure, C++ structure
can have data and member functions. The
difference between class and structure is of
visibility. Every data member or function written
inside the structure is public (visible from outside)
by default unless declared otherwise. Similarly,
everything declared inside a class is private (not
visible from outside) by default unless declared as
public.
Messages and Methods
When we create an object, we ask that object
to do something by calling a function. This way
of asking objects in Windows operating system
is called Messaging or in other words function
calling is sending a message to the object.
Sending a message is a synonym of calling a
method of an object. The word ‘method’ is from
the fact that it is a way of doing something. So
the whole program is sending messages and
getting responses back. It is a different way of
looking at things.
Tips
- Classes are one way of extending the C++
language.
- Whenever new operator is used, no number of
bytes or sizeof operator is required and no cast is
applied to convert the pointer to the required type.
- Whenever new operator is called to create an
object, the constructor is also called for that object.
It is a good practice that whenever you write a
class, use a constructor function to initialize the
data members to some meaningful values.
- The usual practice is to use constructor to allocate
memory or system resources and destructors to de-
allocate or return the resources back to the system.
- In C language, the region of memory allocated at
runtime is called heap. However, in C++, the region
of available memory is called free store. There are
different functions in C and C++ to manipulate
memory at runtime. However, all C functions are
useable in C++ code.
- The memory allocated from free store or heap is
a system resource and is not returned back to the
system unless explicitly freed using delete or free
operators.
- If the memory in the free store is not sufficient
enough to fulfill the request, malloc() function
returns NULL pointer. Similarly, the new function
returns 0 in case the request could not be fulfilled.
- Whenever we use new operator, the returned
value from the new should be checked against 0
for any possible failures.
- While writing classes, good programming practice
is to write private keyword explicitly, despite the
fact that this is the default scope. Additionally, the
good practice is to write public or private
keywords only once in the class or structure
definitions, though there is no syntactical or logical
problems in writing them multiple times.
FRIEND FUNCTION
Friend functions are not member functions of
the class. The class itself declares the friend
functions. The prototype of friend functions is
written in the definition of the class with the
keyword ‘friend’. These functions have access
to the private data member of the class,
which means they have access to everything in
the class. Normally we pass an object of the
class to these functions in the argument list so
that it can manipulate the data of the object.
Question is how to declare and call it?
Answer: If we have a class, suppose ‘Date’ and
want to declare a friend function of this class.
In the definition of the class, we will write the
friend function’s prototype with the keyword
‘friend’. To access the private data, friend
function will need the object. Therefore, usually
in the parameter list of friend function, we
provide the object of that class. Normally, the
programmers work this way. As the friend
function is not affected by the private or public
keyword, so we can declare it anywhere inside
the class definition. Programmers generally
declare the friend functions at the top of the
class definition. So, the friend functions are
declared at the start of the class definition,
followed by the private data and public data.
friend return_type friend_function_name(int, char);
FRIEND CLASS
A friend class works same as a friend function.
In this programmer can create a friend class
and this class would have access to all the
data members of that class in which its
prototype is declared. Its syntax is as:
friend class class-name ;
SUMMARY
The principles of friendship of functions and
classes are that the friendship is granted, not
taken. So a class declares its friend functions
and friend classes. If a class declares another
class as a friend, it is not always reciprocal. So
declaration and granting of a right is one way.
The owner of the right grants it. So the class
itself grants the privilege of access to outsider
functions or to other classes. It is not transitive.
It does not go ‘A is a friend of B and B is a
friend of C therefore A is a friend of C’. It does
not work that way. It is restricted to a one-step
relationship. If A is a friend of B, and B is a
friend of C. If A wants C to be a friend, it
has to declare, “C is my friend”.
REFERENCE
The reference in a way keeps the address of
the data entity. But it is not really an address it
is a synonym, it is a different name for the
entity. We have to initialize the reference when
we declare it. It has to point to some existing
data type or data value. In other words, a
reference cannot be NULL. So immediately,
when we define a reference, we have to
declare it. This rule does not apply to functions.
When we are writing the argument list of a
function and say that it will get a reference
argument, here it is not needed to initialize the
reference. This reference will be passed by the
calling function. But in the main program if we
declare a reference then we have to initialize it.
When a reference is initialized, we cannot
reassign any other value to it. For example, we
have ref that is a reference to an integer. In the
program we write the line int &ref = j;
The difference between pointers and
references is that we can do arithmetic with
pointers. We can increment, decrement and
reassign a pointer. This cannot be done with
references. We cannot increment, decrement
or reassign references.
References as Return Values
A function itself can return a reference. The
syntax of declaration of such a function will be
as under.
datatype& function_name (parameter list)
Suppose we have a function myfunc that
returns the reference to an integer. The
declaration of it will be as:
int & myfunc() ;
Dangling Reference
When a reference is declared to a local
variable and somehow that variable dies; now
the reference call is to nowhere and this is
termed as dangling reference.
To avoid such situations, one can always try to
reference only variables in global scope rather
than local scope, as global variable always
exists and cannot be removed accidentally by
a function. Or you can also declare a reference
for static variables.
Tips
• The use of reference data type is the
implementation of call by reference in an
elegant way.
• We cannot do arithmetic with references like
pointers.
• Reference variables must be initialized
immediately when they are declared.
• To avoid dangling reference, don’t return the
reference of a local variable from a function.
• In functions that return reference, use global
or static variables.
• The reference data types are used as
ordinary variables without any dereference
operator.
OPERATOR OVERLOADING
Operator Overloading is quite similar to
Function Overloading. There are two types of
operators to overload: unary and binary. C++
built-in operators work for built-in (primitive)
types but for user defined data types, user has
to write his/her own operators.
There are some restriction while performing
Operator Overloading. For example, only
existing C++ operators are overloaded without
creating a new one in the language. Also, it
should not impact the type, semantics
(behavior), arity (number of operands
required), precedence and associativity of the
operator. Following operators cannot be
overloaded.
. : :: .* ? sizeof
For binary member operators, operands on the
left drives (calls) the operation.
Operator functions written as non-members but
friends of the class, get both the operands as
their arguments. Operators can be written as
non-members and even without making them
friends. But this is tedious and less efficient
way, therefore, it is not recommended.
this pointer
Whenever an object calls a member function,
the function implicitly gets a pointer from the
calling object. That pointer is known as this
pointer. ‘this’ is a key word. We cannot use it
as a variable name. ‘this’ pointer is present in
the function, referring to the calling object.
Syntax is as:
date;
this -> date;
(this*).date;