Unit 1 and Unit 2 Notes

Dr. Saroj Kumar Nanda

When we consider a C++ program, it can be defined as a collection
of objects that communicate via invoking each other's methods. Let
us now briefly look into what a class, object, methods, and instant
variables mean.

 Object − Objects have states and behaviors. Example: A dog

has states - color, name, breed as well as behaviors -
wagging, barking, eating. An object is an instance of a class.
 Class − A class can be defined as a template/blueprint that
describes the behaviors/states that object of its type support.
 Methods − A method is basically a behavior. A class can contain
many methods. It is in methods where the logics are written,
data is manipulated and all the actions are executed.
 Instance Variables − Each object has its unique set of instance
variables. An object's state is created by the values assigned
to these instance variables.

C++ Program Structure

Let us look at a simple code that would print the words Hello World.

Live Demo
#include <iostream>
using namespace std;

// main() is where program execution begins.

int main() {
cout << "Hello World"; // prints Hello World
return 0;
}

Let us look at the various parts of the above program −

  The C++ language defines several headers, which contain
information that is either necessary or useful to your program.
For this program, the header <iostream> is needed.
 The line using namespace std; tells the compiler to use the std
namespace. Namespaces are a relatively recent addition to
C++.
 The next line '// main() is where program execution begins.' is a
single-line comment available in C++. Single-line comments
begin with // and stop at the end of the line.
 The line int main() is the main function where program
execution begins.
 The next line cout << "Hello World"; causes the message "Hello
World" to be displayed on the screen.
 The next line return 0; terminates main( )function and causes it
to return the value 0 to the calling process.

Semicolons and Blocks in C++

In C++, the semicolon is a statement terminator. That is, each
individual statement must be ended with a semicolon. It indicates
the end of one logical entity.

For example, following are three different statements −

x = y;
y = y + 1;
add(x, y);

A block is a set of logically connected statements that are

surrounded by opening and closing braces. For example −

{
cout << "Hello World"; // prints Hello World
return 0;
}

C++ does not recognize the end of the line as a terminator. For this
reason, it does not matter where you put a statement in a line. For
example −
x = y;
y = y + 1;
add(x, y);

is the same as

x = y; y = y + 1; add(x, y);

C++ Identifiers
A C++ identifier is a name used to identify a variable, function,
class, module, or any other user-defined item. An identifier starts
with a letter A to Z or a to z or an underscore (_) followed by zero
or more letters, underscores, and digits (0 to 9).

C++ does not allow punctuation characters such as @, $, and %

within identifiers. C++ is a case-sensitive programming language.
Thus, Manpower and manpower are two different identifiers in C++.

Here are some examples of acceptable identifiers −

mohd zara abc move_name a_123

myname50 _temp j a23b9 retVal

C++ Keywords
The following list shows the reserved words in C++. These reserved
words may not be used as constant or variable or any other
identifier names.

asm else new this

auto enum operator throw

bool explicit private true

break export protected try

case extern public typedef

catch false register typeid

char float reinterpret_cast typename

class for return union

const friend short unsigned

const_cast goto signed using

continue if sizeof virtual

default inline static void

delete int static_cast volatile

do long struct wchar_t

double mutable switch while

dynamic_cast namespace template

All the compilers do not support trigraphs and they are not advised
to be used because of their confusing nature.

Whitespace in C++
A line containing only whitespace, possibly with a comment, is
known as a blank line, and C++ compiler totally ignores it.

Whitespace is the term used in C++ to describe blanks, tabs,

newline characters and comments. Whitespace separates one part
of a statement from another and enables the compiler to identify
where one element in a statement, such as int, ends and the next
element begins.

Statement 1

int age;

In the above statement there must be at least one whitespace

character (usually a space) between int and age for the compiler to
be able to distinguish them.

Statement 2
fruit = apples + oranges; // Get the total fruit

In the above statement 2, no whitespace characters are necessary

between fruit and =, or between = and apples, although you are
free to include some if you wish for readability purpose.

Program comments are explanatory statements that you can include

in the C++ code. These comments help anyone reading the source
code. All programming languages allow for some form of comments.

C++ supports single-line and multi-line comments. All characters

available inside any comment are ignored by C++ compiler.

C++ comments start with /* and end with */. For example −

/* This is a comment */

/* C++ comments can also

* span multiple lines
*/

A comment can also start with //, extending to the end of the line.
For example −

Live Demo
#include <iostream>
using namespace std;

main() {
cout << "Hello World"; // prints Hello World

return 0;
}

When the above code is compiled, it will ignore // prints Hello

World and final executable will produce the following result −

Hello World
Within a /* and */ comment, // characters have no special
meaning. Within a // comment, /* and */ have no special meaning.
Thus, you can "nest" one kind of comment within the other kind. For
example −

/* Comment out printing of Hello World:

cout << "Hello World"; // prints Hello World

*/

While writing program in any language, you need to use various

variables to store various information. Variables are nothing but
reserved memory locations to store values. This means that
when you create a variable you reserve some space in
memory.

You may like to store information of various data types like

character, wide character, integer, floating point, double floating
point, boolean etc. Based on the data type of a variable, the
operating system allocates memory and decides what can be stored
in the reserved memory.

Primitive Built-in Types

C++ offers the programmer a rich assortment of built-in as well as
user defined data types. Following table lists down seven basic C++
data types −

Type Keyword

Boolean bool

Character char

Integer int

Floating point float

Double floating point double

Valueless void

Wide character wchar_t

Several of the basic types can be modified using one or more of

these type modifiers −

 signed
 unsigned
 short
 long

The following table shows the variable type, how much memory it
takes to store the value in memory, and what is maximum and
minimum value which can be stored in such type of variables.

Typical Bit
Type Typical Range
Width

char 1byte -127 to 127 or 0 to 255

unsigned char 1byte 0 to 255

signed char 1byte -127 to 127

int 4bytes -2147483648 to 2147483647

unsigned int 4bytes 0 to 4294967295

signed int 4bytes -2147483648 to 2147483647

short int 2bytes -32768 to 32767

unsigned short int 2bytes 0 to 65,535

signed short int 2bytes -32768 to 32767

-9223372036854775808 to
long int 8bytes
9223372036854775807

signed long int 8bytes same as long int

unsigned long int 8bytes 0 to 18446744073709551615

long long int 8bytes -(2^63) to (2^63)-1

unsigned long long
8bytes 0 to 18,446,744,073,709,551,615
int

float 4bytes

double 8bytes

long double 12bytes

wchar_t 2 or 4 bytes 1 wide character

The size of variables might be different from those shown in the

above table, depending on the compiler and the computer you are
using.

Following is the example, which will produce correct size of various

data types on your computer.

Live Demo
#include <iostream>
using namespace std;

int main() {
cout << "Size of char : " << sizeof(char) << endl;
cout << "Size of int : " << sizeof(int) << endl;
cout << "Size of short int : " << sizeof(short int) <<
endl;
cout << "Size of long int : " << sizeof(long int) <<
endl;
cout << "Size of float : " << sizeof(float) << endl;
cout << "Size of double : " << sizeof(double) << endl;
cout << "Size of wchar_t : " << sizeof(wchar_t) <<
endl;

return 0;
}

This example uses endl, which inserts a new-line character after

every line and << operator is being used to pass multiple values out
to the screen. We are also using sizeof() operator to get size of
various data types.
When the above code is compiled and executed, it produces the
following result which can vary from machine to machine −

Size of char : 1
Size of int : 4
Size of short int : 2
Size of long int : 4
Size of float : 4
Size of double : 8
Size of wchar_t : 4

Following is another example:

#include <iostream>
#include <limits>
using namespace std;

int main() {

std::cout << "Int Min " << std::numeric_limits<int>::min() << endl;

std::cout << "Int Max " << std::numeric_limits<int>::max() << endl;
std::cout << "Unsigned Int Min " << std::numeric_limits<unsigned int>::min() <<
endl;
std::cout << "Unsigned Int Max " << std::numeric_limits<unsigned int>::max() <<
endl;
std::cout << "Long Int Min " << std::numeric_limits<long int>::min() << endl;
std::cout << "Long Int Max " << std::numeric_limits<long int>::max() << endl;

std::cout << "Unsigned Long Int Min " << std::numeric_limits<unsigned long
int>::min() <<endl;
std::cout << "Unsigned Long Int Max " << std::numeric_limits<unsigned long
int>::max() << endl;

typedef Declarations
You can create a new name for an existing type using typedef.
Following is the simple syntax to define a new type using typedef −

typedef type newname;

For example, the following tells the compiler that feet is another
name for int −

typedef int feet;

Now, the following declaration is perfectly legal and creates an

integer variable called distance −

feet distance;

Enumerated Types
An enumerated type declares an optional type name and a set of
zero or more identifiers that can be used as values of the type. Each
enumerator is a constant whose type is the enumeration.

Creating an enumeration requires the use of the keyword enum. The

general form of an enumeration type is −

enum enum-name { list of names } var-list;

Here, the enum-name is the enumeration's type name. The list of

names is comma separated.

For example, the following code defines an enumeration of colors

called colors and the variable c of type color. Finally, c is assigned
the value "blue".

enum color { red, green, blue } c;

c = blue;

By default, the value of the first name is 0, the second name has
the value 1, and the third has the value 2, and so on. But you can
give a name, a specific value by adding an initializer. For example,
in the following enumeration, green will have the value 5.
enum color { red, green = 5, blue };

Here, blue will have a value of 6 because each name will be one
greater than the one that precedes it.

A variable provides us with named storage that our programs can

manipulate. Each variable in C++ has a specific type, which
determines the size and layout of the variable's memory; the range
of values that can be stored within that memory; and the set of
operations that can be applied to the variable.

The name of a variable can be composed of letters, digits, and the

underscore character. It must begin with either a letter or an
underscore. Upper and lowercase letters are distinct because C++ is
case-sensitive −

There are following basic types of variable in C++ as explained in

last chapter −

Sr.No Type & Description

bool
1
Stores either value true or false.

char
2
Typically a single octet (one byte). This is an integer type.

int
3
The most natural size of integer for the machine.

float
4
A single-precision floating point value.

double
5
A double-precision floating point value.

void
6
Represents the absence of type.

wchar_t
7
A wide character type.

Variable Definition in C++

A variable definition tells the compiler where and how much storage
to create for the variable. A variable definition specifies a data type,
and contains a list of one or more variables of that type as follows −

type variable_list;

Here, type must be a valid C++ data type including char, w_char,
int, float, double, bool or any user-defined object, etc.,
and variable_list may consist of one or more identifier names
separated by commas. Some valid declarations are shown here −

int i, j, k;
char c, ch;
float f, salary;
double d;

The line int i, j, k; both declares and defines the variables i, j and k;
which instructs the compiler to create variables named i, j and k of
type int.

Variables can be initialized (assigned an initial value) in their

declaration. The initializer consists of an equal sign followed by a
constant expression as follows −

type variable_name = value;

Some examples are −

extern int d = 3, f = 5; // declaration of d and f.

int d = 3, f = 5; // definition and initializing d and f.
byte z = 22; // definition and initializes z.
char x = 'x'; // the variable x has the value 'x'.

For definition without an initializer: variables with static storage

duration are implicitly initialized with NULL (all bytes have the value
0); the initial value of all other variables is undefined.

Variable Declaration in C++

A variable declaration provides assurance to the compiler that there
is one variable existing with the given type and name so that
compiler proceed for further compilation without needing complete
detail about the variable. A variable declaration has its meaning at
the time of compilation only, compiler needs actual variable
definition at the time of linking of the program.

A variable declaration is useful when you are using multiple files and
you define your variable in one of the files which will be available at
the time of linking of the program. You will use extern keyword to
declare a variable at any place. Though you can declare a
variable multiple times in your C++ program, but it can be defined
only once in a file, a function or a block of code.

Example

Try the following example where a variable has been declared at the
top, but it has been defined inside the main function −

Live Demo
#include <iostream>
using namespace std;

// Variable declaration:
extern int a, b;
extern int c;
extern float f;

int main () {
// Variable definition:
int a, b;
int c;
float f;

// actual initialization
a = 10;
b = 20;
c = a + b;

cout << c << endl ;

 f = 70.0/3.0;
cout << f << endl ;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

30
23.3333

Same concept applies on function declaration where you provide a

function name at the time of its declaration and its actual definition
can be given anywhere else. For example −

// function declaration
int func();
int main() {
// function call
int i = func();
}

// function definition
int func() {
return 0;
}

Lvalues and Rvalues

There are two kinds of expressions in C++ −

 lvalue − Expressions that refer to a memory location is called

"lvalue" expression. An lvalue may appear as either the left-
hand or right-hand side of an assignment.
 rvalue − The term rvalue refers to a data value that is stored at
some address in memory. An rvalue is an expression that
 cannot have a value assigned to it which means an rvalue may
appear on the right- but not left-hand side of an assignment.

Variables are lvalues and so may appear on the left-hand side of an

assignment. Numeric literals are rvalues and so may not be
assigned and can not appear on the left-hand side. Following is a
valid statement −

int g = 20;

But the following is not a valid statement and would generate

compile-time error −

10 = 20;

A scope is a region of the program and broadly speaking there are

three places, where variables can be declared −

 Inside a function or a block which is called local variables,

 In the definition of function parameters which is called formal
parameters.
 Outside of all functions which is called global variables.

We will learn what is a function and it's parameter in subsequent

chapters. Here let us explain what are local and global variables.

Local Variables
Variables that are declared inside a function or block are local
variables. They can be used only by statements that are inside that
function or block of code. Local variables are not known to functions
outside their own. Following is the example using local variables −

Live Demo
#include <iostream>
using namespace std;

int main () {
// Local variable declaration:
int a, b;
 int c;

// actual initialization
a = 10;
b = 20;
c = a + b;

cout << c;

return 0;
}

Global Variables
Global variables are defined outside of all the functions, usually on
top of the program. The global variables will hold their value
throughout the life-time of your program.

A global variable can be accessed by any function. That is, a global

variable is available for use throughout your entire program after its
declaration. Following is the example using global and local
variables −

Live Demo
#include <iostream>
using namespace std;

// Global variable declaration:

int g;

int main () {
// Local variable declaration:
int a, b;

// actual initialization
a = 10;
b = 20;
g = a + b;

cout << g;
 return 0;
}

A program can have same name for local and global variables but
value of local variable inside a function will take preference. For
example −

Live Demo
#include <iostream>
using namespace std;

// Global variable declaration:

int g = 20;

int main () {
// Local variable declaration:
int g = 10;

cout << g;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

10

Initializing Local and Global Variables

When a local variable is defined, it is not initialized by the
system, you must initialize it yourself. Global variables are
initialized automatically by the system when you define them
as follows −

Data Type Initializer

int 0

char '\0'
float 0

double 0

pointer NULL

It is a good programming practice to initialize variables properly,

otherwise sometimes program would produce unexpected result.

Constants refer to fixed values that the program may not

alter and they are called literals.

Constants can be of any of the basic data types and can be divided
into Integer Numerals, Floating-Point Numerals, Characters, Strings
and Boolean Values.

Again, constants are treated just like regular variables except that
their values cannot be modified after their definition.

Integer Literals
An integer literal can be a decimal, octal, or hexadecimal constant.
A prefix specifies the base or radix: 0x or 0X for hexadecimal, 0 for
octal, and nothing for decimal.

An integer literal can also have a suffix that is a combination of U

and L, for unsigned and long, respectively. The suffix can be
uppercase or lowercase and can be in any order.

Here are some examples of integer literals −

212 // Legal
215u // Legal
0xFeeL // Legal
078 // Illegal: 8 is not an octal digit
032UU // Illegal: cannot repeat a suffix

Following are other examples of various types of Integer literals −

85 // decimal
0213 // octal
0x4b // hexadecimal
30 // int
30u // unsigned int
30l // long
30ul // unsigned long

Floating-point Literals
A floating-point literal has an integer part, a decimal point, a
fractional part, and an exponent part. You can represent floating
point literals either in decimal form or exponential form.

While representing using decimal form, you must include the

decimal point, the exponent, or both and while representing using
exponential form, you must include the integer part, the fractional
part, or both. The signed exponent is introduced by e or E.

Here are some examples of floating-point literals −

3.14159 // Legal
314159E-5L // Legal
510E // Illegal: incomplete exponent
210f // Illegal: no decimal or exponent
.e55 // Illegal: missing integer or fraction

Boolean Literals
There are two Boolean literals and they are part of standard C++
keywords −

 A value of true representing true.

 A value of false representing false.

You should not consider the value of true equal to 1 and value of
false equal to 0.

Character Literals
Character literals are enclosed in single quotes. If the literal begins
with L (uppercase only), it is a wide character literal (e.g., L'x') and
should be stored in wchar_t type of variable . Otherwise, it is a
narrow character literal (e.g., 'x') and can be stored in a simple
variable of char type.

A character literal can be a plain character (e.g., 'x'), an escape

sequence (e.g., '\t'), or a universal character (e.g., '\u02C0').

There are certain characters in C++ when they are preceded by a

backslash they will have special meaning and they are used to
represent like newline (\n) or tab (\t). Here, you have a list of some
of such escape sequence codes −

Escape sequence Meaning

\\ \ character

\' ' character

\" " character

\? ? character

\a Alert or bell

\b Backspace

\f Form feed

\n Newline

\r Carriage return

\t Horizontal tab

\v Vertical tab

\ooo Octal number of one to three digits

\xhh . . . Hexadecimal number of one or more digits

Following is the example to show a few escape sequence characters

−
Live Demo
#include <iostream>
using namespace std;

int main() {
cout << "Hello\tWorld\n\n";
return 0;
}

When the above code is compiled and executed, it produces the

following result −

Hello World

String Literals
String literals are enclosed in double quotes. A string contains
characters that are similar to character literals: plain characters,
escape sequences, and universal characters.

You can break a long line into multiple lines using string literals and
separate them using whitespaces.

Here are some examples of string literals. All the three forms are
identical strings.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

Defining Constants
There are two simple ways in C++ to define constants −

 Using #define preprocessor.

  Using const keyword.

The #define Preprocessor

Following is the form to use #define preprocessor to define a
constant −

#define identifier value

Following example explains it in detail −

Live Demo
#include <iostream>
using namespace std;

#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'

int main() {
int area;

area = LENGTH * WIDTH;

cout << area;
cout << NEWLINE;
return 0;
}

When the above code is compiled and executed, it produces the

following result −

50

The const Keyword

You can use const prefix to declare constants with a specific type as
follows −

const type variable = value;

Following example explains it in detail −

Live Demo
#include <iostream>
using namespace std;

int main() {
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;

area = LENGTH * WIDTH;

cout << area;
cout << NEWLINE;
return 0;
}

When the above code is compiled and executed, it produces the

following result −

50

Note that it is a good programming practice to define constants in

CAPITALS.

C++ allows the char, int, and double data types to have modifiers
preceding them. A modifier is used to alter the meaning of the base
type so that it more precisely fits the needs of various situations.

The data type modifiers are listed here −

 signed
 unsigned
 long
 short

The modifiers signed, unsigned, long, and short can be applied to integer
base types. In addition, signed and unsigned can be applied to char,
and long can be applied to double.

The modifiers signed and unsigned can also be used as prefix

to long or short modifiers. For example, unsigned long int.
C++ allows a shorthand notation for declaring unsigned,
short, or long integers. You can simply use the word unsigned,
short, or long, without int. It automatically implies int. For example,
the following two statements both declare unsigned integer
variables.

unsigned x;
unsigned int y;

To understand the difference between the way signed and unsigned

integer modifiers are interpreted by C++, you should run the
following short program −

Live Demo
#include <iostream>
using namespace std;

/* This program shows the difference between

* signed and unsigned integers.
*/
int main() {
short int i; // a signed short integer
short unsigned int j; // an unsigned short integer

j = 50000;

i = j;
cout << i << " " << j;

return 0;
}

When this program is run, following is the output −

-15536 50000

The above result is because the bit pattern that represents 50,000
as a short unsigned integer is interpreted as -15,536 by a short.

A storage class defines the scope (visibility) and life-time of

variables and/or functions within a C++ Program. These specifiers
precede the type that they modify. There are following storage
classes, which can be used in a C++ Program

 auto
 register
 static
 extern
 mutable

The auto Storage Class

The auto storage class is the default storage class for all local
variables.

{
int mount;
auto int month;
}

The example above defines two variables with the same storage
class, auto can only be used within functions, i.e., local variables.

The register Storage Class

The register storage class is used to define local variables that
should be stored in a register instead of RAM. This means that
the variable has a maximum size equal to the register size (usually
one word) and can't have the unary '&' operator applied to it (as it
does not have a memory location).

{
register int miles;
}

The register should only be used for variables that require

quick access such as counters. It should also be noted that
defining 'register' does not mean that the variable will be stored in a
register. It means that it MIGHT be stored in a register depending
on hardware and implementation restrictions.
The static Storage Class
The static storage class instructs the compiler to keep a local
variable in existence during the life-time of the program
instead of creating and destroying it each time it comes into
and goes out of scope. Therefore, making local variables static
allows them to maintain their values between function calls.

The static modifier may also be applied to global variables. When

this is done, it causes that variable's scope to be restricted to the
file in which it is declared.

In C++, when static is used on a class data member, it causes only

one copy of that member to be shared by all objects of its class.

Live Demo
#include <iostream>

// Function declaration
void func(void);

static int count = 10; /* Global variable */

main() {
while(count--) {
func();
}

return 0;
}

// Function definition
void func( void ) {
static int i = 5; // local static variable
i++;
std::cout << "i is " << i ;
std::cout << " and count is " << count << std::endl;
}

When the above code is compiled and executed, it produces the

following result −
i is 6 and count is 9
i is 7 and count is 8
i is 8 and count is 7
i is 9 and count is 6
i is 10 and count is 5
i is 11 and count is 4
i is 12 and count is 3
i is 13 and count is 2
i is 14 and count is 1
i is 15 and count is 0

The extern Storage Class

The extern storage class is used to give a reference of a global
variable that is visible to ALL the program files. When you use
'extern' the variable cannot be initialized as all it does is point the
variable name at a storage location that has been previously
defined.

When you have multiple files and you define a global variable or
function, which will be used in other files also, then extern will be
used in another file to give reference of defined variable or function.
Just for understanding extern is used to declare a global variable or
function in another file.

The extern modifier is most commonly used when there are two or
more files sharing the same global variables or functions as
explained below.

First File: main.cpp

#include <iostream>
int count ;
extern void write_extern();

main() {
count = 5;
write_extern();
}
Second File: support.cpp

#include <iostream>
extern int count;
void write_extern(void) {
std::cout << "Count is " << count << std::endl;
}

The mutable Storage Class

The mutable specifier applies only to class objects. It allows a
member of an object to override const member function. That is, a
mutable member can be modified by a const member function.

An operator is a symbol that tells the compiler to perform specific

mathematical or logical manipulations. C++ is rich in built-in
operators and provide the following types of operators −

 Arithmetic Operators
 Relational Operators
 Logical Operators
 Bitwise Operators
 Assignment Operators
 Misc Operators

This chapter will examine the arithmetic, relational, logical, bitwise,

assignment and other operators one by one.

Arithmetic Operators
There are following arithmetic operators supported by C++
language −

Assume variable A holds 10 and variable B holds 20, then −

Show Examples

Operator Description Example

 + Adds two operands A + B will give 30

Subtracts second operand from the

- A - B will give -10
first

* Multiplies both operands A * B will give 200

/ Divides numerator by de-numerator B / A will give 2

Modulus Operator and remainder of

% B % A will give 0
after an integer division

Increment operator, increases

++ A++ will give 11
integer value by one

Decrement operator, decreases

-- A-- will give 9
integer value by one

Relational Operators
There are following relational operators supported by C++ language

Assume variable A holds 10 and variable B holds 20, then −

Show Examples

Operator Description Example

Checks if the values of two

== operands are equal or not, if yes (A == B) is not true.
then condition becomes true.

Checks if the values of two

operands are equal or not, if values
!= (A != B) is true.
are not equal then condition
becomes true.

Checks if the value of left operand

is greater than the value of right
> (A > B) is not true.
operand, if yes then condition
becomes true.

Checks if the value of left operand

< is less than the value of right (A < B) is true.
operand, if yes then condition
 becomes true.

Checks if the value of left operand

is greater than or equal to the value
>= (A >= B) is not true.
of right operand, if yes then
condition becomes true.

Checks if the value of left operand

is less than or equal to the value of
<= (A <= B) is true.
right operand, if yes then condition
becomes true.

Logical Operators
There are following logical operators supported by C++ language.

Assume variable A holds 1 and variable B holds 0, then −

Show Examples

Operator Description Example

Called Logical AND operator. If

&& both the operands are non-zero, then (A && B) is false.
condition becomes true.

Called Logical OR Operator. If any

|| of the two operands is non-zero, (A || B) is true.
then condition becomes true.

Called Logical NOT Operator. Use

to reverses the logical state of its
! operand. If a condition is true, then !(A && B) is true.
Logical NOT operator will make
false.

Bitwise Operators
Bitwise operator works on bits and perform bit-by-bit operation. The
truth tables for &, |, and ^ are as follows −

p q p&q p|q p^q

0 0 0 0 0

0 1 0 1 1

1 1 1 1 0

1 0 0 1 1

Assume if A = 60; and B = 13; now in binary format they will be as

follows −

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

The Bitwise operators supported by C++ language are listed in the

following table. Assume variable A holds 60 and variable B holds 13,
then −

Show Examples

Operator Description Example

Binary AND Operator copies a bit

(A & B) will give 12 which is 0000
& to the result if it exists in both
1100
operands.

Binary OR Operator copies a bit if it (A | B) will give 61 which is 0011

|
exists in either operand. 1101

Binary XOR Operator copies the bit

(A ^ B) will give 49 which is 0011
^ if it is set in one operand but not
0001
both.
 Binary Ones Complement Operator (~A ) will give -61 which is 1100
~ is unary and has the effect of 0011 in 2's complement form due to
'flipping' bits. a signed binary number.

Binary Left Shift Operator. The left

operands value is moved left by the A << 2 will give 240 which is 1111
<<
number of bits specified by the right 0000
operand.

Binary Right Shift Operator. The

left operands value is moved right A >> 2 will give 15 which is 0000
>>
by the number of bits specified by 1111
the right operand.

Assignment Operators
There are following assignment operators supported by C++
language −

Show Examples

Operator Description Example

Simple assignment operator, Assigns

C = A + B will assign value of A
= values from right side operands to left
+ B into C
side operand.

Add AND assignment operator, It adds

C += A is equivalent to C = C +
+= right operand to the left operand and
A
assign the result to left operand.

Subtract AND assignment operator, It

subtracts right operand from the left
-= C -= A is equivalent to C = C - A
operand and assign the result to left
operand.

Multiply AND assignment operator, It

multiplies right operand with the left C *= A is equivalent to C = C *
*=
operand and assign the result to left A
operand.

Divide AND assignment operator, It

divides left operand with the right
/= C /= A is equivalent to C = C / A
operand and assign the result to left
operand.
 Modulus AND assignment operator, It
C %= A is equivalent to C = C %
%= takes modulus using two operands and
A
assign the result to left operand.

<<= Left shift AND assignment operator. C <<= 2 is same as C = C << 2

>>= Right shift AND assignment operator. C >>= 2 is same as C = C >> 2

&= Bitwise AND assignment operator. C &= 2 is same as C = C & 2

Bitwise exclusive OR and assignment

^= C ^= 2 is same as C = C ^ 2
operator.

Bitwise inclusive OR and assignment

|= C |= 2 is same as C = C | 2
operator.

Misc Operators
The following table lists some other operators that C++ supports.

Sr.No Operator & Description

sizeof
1 sizeof operator returns the size of a variable. For example, sizeof(a), where ‘a’
is integer, and will return 4.

Condition ? X : Y
2 Conditional operator (?). If Condition is true then it returns value of X
otherwise returns value of Y.

,
Comma operator causes a sequence of operations to be performed. The value
3
of the entire comma expression is the value of the last expression of the
comma-separated list.

. (dot) and -> (arrow)

4 Member operators are used to reference individual members of classes,
structures, and unions.

Cast
5 Casting operators convert one data type to another. For example, int(2.2000)
would return 2.

&
6
Pointer operator & returns the address of a variable. For example &a; will
 give actual address of the variable.

*
7 Pointer operator * is pointer to a variable. For example *var; will pointer to a
variable var.

Operators Precedence in C++

Operator precedence determines the grouping of terms in an
expression. This affects how an expression is evaluated. Certain
operators have higher precedence than others; for example, the
multiplication operator has higher precedence than the addition
operator −

For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because

operator * has higher precedence than +, so it first gets multiplied
with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of

the table, those with the lowest appear at the bottom. Within an
expression, higher precedence operators will be evaluated first.

Show Examples

Category Operator Associativity

Postfix () [] -> . ++ - - Left to right

Unary + - ! ~ ++ - - (type)* & sizeof Right to left

Multiplicative */% Left to right

Additive +- Left to right

Shift << >> Left to right

Relational < <= > >= Left to right

Equality == != Left to right

Bitwise AND & Left to right

Bitwise XOR ^ Left to right

Bitwise OR | Left to right

Logical AND && Left to right

Logical OR || Left to right

Conditional ?: Right to left

Assignment = += -= *= /= %=>>= <<= &= ^= |= Right to left

Comma , Left to right

There may be a situation, when you need to execute a block of code

several number of times. In general, statements are executed
sequentially: The first statement in a function is executed first,
followed by the second, and so on.

Programming languages provide various control structures that

allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of

statements multiple times and following is the general from of a
loop statement in most of the programming languages −
C++ programming language provides the following type of loops to
handle looping requirements.

Sr.No Loop Type & Description

while loop
1 Repeats a statement or group of statements while a given condition is true. It
tests the condition before executing the loop body.

for loop
2 Execute a sequence of statements multiple times and abbreviates the code that
manages the loop variable.

do...while loop
3 Like a ‘while’ statement, except that it tests the condition at the end of the loop
body.

nested loops
4 You can use one or more loop inside any another ‘while’, ‘for’ or ‘do..while’
loop.

Loop Control Statements

Loop control statements change execution from its normal
sequence. When execution leaves a scope, all automatic objects
that were created in that scope are destroyed.

C++ supports the following control statements.

Sr.No Control Statement & Description

break statement
1 Terminates the loop or switch statement and transfers execution to the
statement immediately following the loop or switch.

continue statement
2 Causes the loop to skip the remainder of its body and immediately retest its
condition prior to reiterating.

goto statement
3 Transfers control to the labeled statement. Though it is not advised to use goto
statement in your program.
The Infinite Loop
A loop becomes infinite loop if a condition never becomes false.
The for loop is traditionally used for this purpose. Since none of the
three expressions that form the „for‟ loop are required, you can
make an endless loop by leaving the conditional expression empty.

#include <iostream>
using namespace std;

int main () {
for( ; ; ) {
printf("This loop will run forever.\n");
}

return 0;
}

When the conditional expression is absent, it is assumed to be true.

You may have an initialization and increment expression, but C++
programmers more commonly use the „for (;;)‟ construct to signify
an infinite loop.

NOTE − You can terminate an infinite loop by pressing Ctrl + C

keys.

Decision making structures require that the programmer specify one

or more conditions to be evaluated or tested by the program, along
with a statement or statements to be executed if the condition is
determined to be true, and optionally, other statements to be
executed if the condition is determined to be false.

Following is the general form of a typical decision making structure

found in most of the programming languages −
C++ programming language provides following types of decision
making statements.

Sr.No Statement & Description

if statement
1 An ‘if’ statement consists of a boolean expression followed by one or more
statements.

if...else statement
2 An ‘if’ statement can be followed by an optional ‘else’ statement, which
executes when the boolean expression is false.

switch statement
3 A ‘switch’ statement allows a variable to be tested for equality against a list of
values.

nested if statements
4 You can use one ‘if’ or ‘else if’ statement inside another ‘if’ or ‘else if’
statement(s).

nested switch statements

5
You can use one ‘switch’ statement inside another ‘switch’ statement(s).

The ? : Operator
We have covered conditional operator “? :” in previous chapter
which can be used to replace if...else statements. It has the following
general form −

Exp1 ? Exp2 : Exp3;

Exp1, Exp2, and Exp3 are expressions. Notice the use and
placement of the colon.

The value of a „?‟ expression is determined like this: Exp1 is

evaluated. If it is true, then Exp2 is evaluated and becomes the
value of the entire „?‟ expression. If Exp1 is false, then Exp3 is
evaluated and its value becomes the value of the expression.

A function is a group of statements that together perform a task.

Every C++ program has at least one function, which is main(), and
all the most trivial programs can define additional functions.

You can divide up your code into separate functions. How you divide
up your code among different functions is up to you, but logically
the division usually is such that each function performs a specific
task.

A function declaration tells the compiler about a function's name,

return type, and parameters. A function definition provides the actual
body of the function.

The C++ standard library provides numerous built-in functions that

your program can call. For example, function strcat() to concatenate
two strings, function memcpy() to copy one memory location to
another location and many more functions.

A function is known with various names like a method or a sub-

routine or a procedure etc.

Defining a Function
The general form of a C++ function definition is as follows −

return_type function_name( parameter list ) {

 body of the function
}

A C++ function definition consists of a function header and a

function body. Here are all the parts of a function −

 Return Type − A function may return a value. The return_type is

the data type of the value the function returns. Some functions
perform the desired operations without returning a value. In
this case, the return_type is the keyword void.
 Function Name − This is the actual name of the function. The
function name and the parameter list together constitute the
function signature.
 Parameters − A parameter is like a placeholder. When a function
is invoked, you pass a value to the parameter. This value is
referred to as actual parameter or argument. The parameter
list refers to the type, order, and number of the parameters of
a function. Parameters are optional; that is, a function may
contain no parameters.
 Function Body − The function body contains a collection of
statements that define what the function does.

Example
Following is the source code for a function called max(). This function
takes two parameters num1 and num2 and return the biggest of
both −

// function returning the max between two numbers

int max(int num1, int num2) {
// local variable declaration
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
Function Declarations
A function declaration tells the compiler about a function name and
how to call the function. The actual body of the function can be
defined separately.

A function declaration has the following parts −

return_type function_name( parameter list );

For the above defined function max(), following is the function

declaration −

int max(int num1, int num2);

Parameter names are not important in function declaration only

their type is required, so following is also valid declaration −

int max(int, int);

Function declaration is required when you define a function in one

source file and you call that function in another file. In such case,
you should declare the function at the top of the file calling the
function.

Calling a Function
While creating a C++ function, you give a definition of what the
function has to do. To use a function, you will have to call or invoke
that function.

When a program calls a function, program control is transferred to

the called function. A called function performs defined task and
when it‟s return statement is executed or when its function-ending
closing brace is reached, it returns program control back to the
main program.

To call a function, you simply need to pass the required parameters

along with function name, and if function returns a value, then you
can store returned value. For example −
Live Demo
#include <iostream>
using namespace std;

// function declaration
int max(int num1, int num2);

int main () {
// local variable declaration:
int a = 100;
int b = 200;
int ret;

// calling a function to get max value.

ret = max(a, b);
cout << "Max value is : " << ret << endl;

return 0;
}

// function returning the max between two numbers

int max(int num1, int num2) {
// local variable declaration
int result;

if (num1 > num2)

result = num1;
else
result = num2;

return result;
}

I kept max() function along with main() function and compiled the
source code. While running final executable, it would produce the
following result −

Max value is : 200

Function Arguments
If a function is to use arguments, it must declare variables that
accept the values of the arguments. These variables are called
the formal parameters of the function.

The formal parameters behave like other local variables inside the
function and are created upon entry into the function and destroyed
upon exit.

While calling a function, there are two ways that arguments can be
passed to a function −

Sr.No Call Type & Description

Call by Value
This method copies the actual value of an argument into the formal parameter
1
of the function. In this case, changes made to the parameter inside the function
have no effect on the argument.

Call by Pointer
This method copies the address of an argument into the formal parameter.
2
Inside the function, the address is used to access the actual argument used in
the call. This means that changes made to the parameter affect the argument.

Call by Reference
This method copies the reference of an argument into the formal parameter.
3
Inside the function, the reference is used to access the actual argument used in
the call. This means that changes made to the parameter affect the argument.

By default, C++ uses call by value to pass arguments. In general, this

means that code within a function cannot alter the arguments used
to call the function and above mentioned example while calling
max() function used the same method.

Default Values for Parameters

When you define a function, you can specify a default value for each
of the last parameters. This value will be used if the corresponding
argument is left blank when calling to the function.

This is done by using the assignment operator and assigning values

for the arguments in the function definition. If a value for that
parameter is not passed when the function is called, the default
given value is used, but if a value is specified, this default value is
ignored and the passed value is used instead. Consider the following
example −

Live Demo
#include <iostream>
using namespace std;

int sum(int a, int b = 20) {

int result;
result = a + b;

return (result);
}
int main () {
// local variable declaration:
int a = 100;
int b = 200;
int result;

// calling a function to add the values.

result = sum(a, b);
cout << "Total value is :" << result << endl;

// calling a function again as follows.

result = sum(a);
cout << "Total value is :" << result << endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Total value is :300

Total value is :120

Normally, when we work with Numbers, we use primitive data types

such as int, short, long, float and double, etc. The number data
types, their possible values and number ranges have been explained
while discussing C++ Data Types.
Defining Numbers in C++
You have already defined numbers in various examples given in
previous chapters. Here is another consolidated example to define
various types of numbers in C++ −

Live Demo
#include <iostream>
using namespace std;

int main () {
// number definition:
short s;
int i;
long l;
float f;
double d;

// number assignments;
s = 10;
i = 1000;
l = 1000000;
f = 230.47;
d = 30949.374;

// number printing;
cout << "short s :" << s << endl;
cout << "int i :" << i << endl;
cout << "long l :" << l << endl;
cout << "float f :" << f << endl;
cout << "double d :" << d << endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

short s :10
int i :1000
long l :1000000
float f :230.47
double d :30949.4

Random Numbers in C++

There are many cases where you will wish to generate a random
number. There are actually two functions you will need to know
about random number generation. The first is rand(), this function
will only return a pseudo random number. The way to fix this is to
first call the srand() function.

Following is a simple example to generate few random numbers.

This example makes use of time() function to get the number of
seconds on your system time, to randomly seed the rand() function
−

Live Demo
#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;

int main () {
int i,j;

// set the seed

srand( (unsigned)time( NULL ) );

/* generate 10 random numbers. */

for( i = 0; i < 10; i++ ) {
// generate actual random number
j = rand();
cout <<" Random Number : " << j << endl;
}

return 0;
}
When the above code is compiled and executed, it produces the
following result −

Random Number : 1748144778

Random Number : 630873888
Random Number : 2134540646
Random Number : 219404170
Random Number : 902129458
Random Number : 920445370
Random Number : 1319072661
Random Number : 257938873
Random Number : 1256201101
Random Number : 580322989

C++ provides a data structure, the array, which stores a fixed-size

sequential collection of elements of the same type. An array is used
to store a collection of data, but it is often more useful to think of
an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0,

number1, ..., and number99, you declare one array variable such as
numbers and use numbers[0], numbers[1], and ..., numbers[99] to
represent individual variables. A specific element in an array is
accessed by an index.

All arrays consist of contiguous memory locations. The lowest

address corresponds to the first element and the highest address to
the last element.

Declaring Arrays
To declare an array in C++, the programmer specifies the type of
the elements and the number of elements required by an array as
follows −

type arrayName [ arraySize ];

This is called a single-dimension array. The arraySize must be an

integer constant greater than zero and type can be any valid C++
data type. For example, to declare a 10-element array called
balance of type double, use this statement −

double balance[10];

Initializing Arrays
You can initialize C++ array elements either one by one or using a
single statement as follows −

double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};

The number of values between braces { } can not be larger than

the number of elements that we declare for the array between
square brackets [ ]. Following is an example to assign a single
element of the array −

If you omit the size of the array, an array just big enough to hold
the initialization is created. Therefore, if you write −

double balance[] = {1000.0, 2.0, 3.4, 17.0, 50.0};

You will create exactly the same array as you did in the previous
example.

balance[4] = 50.0;

The above statement assigns element number 5th in the array a

value of 50.0. Array with 4th index will be 5th, i.e., last element
because all arrays have 0 as the index of their first element which is
also called base index. Following is the pictorial representaion of the
same array we discussed above −

Accessing Array Elements

An element is accessed by indexing the array name. This is done by
placing the index of the element within square brackets after the
name of the array. For example −

double salary = balance[9];

The above statement will take 10th element from the array and
assign the value to salary variable. Following is an example, which
will use all the above-mentioned three concepts viz. declaration,
assignment and accessing arrays −

Live Demo
#include <iostream>
using namespace std;

#include <iomanip>
using std::setw;

int main () {

int n[ 10 ]; // n is an array of 10 integers

// initialize elements of array n to 0

for ( int i = 0; i < 10; i++ ) {
n[ i ] = i + 100; // set element at location i to i
+ 100
}
cout << "Element" << setw( 13 ) << "Value" << endl;

// output each array element's value

for ( int j = 0; j < 10; j++ ) {
cout << setw( 7 )<< j << setw( 13 ) << n[ j ] <<
endl;
}

return 0;
}

This program makes use of setw() function to format the output.

When the above code is compiled and executed, it produces the
following result −
Element Value
0 100
1 101
2 102
3 103
4 104
5 105
6 106
7 107
8 108
9 109

Arrays in C++
Arrays are important to C++ and should need lots of more detail.
There are following few important concepts, which should be clear
to a C++ programmer −

Sr.No Concept & Description

Multi-dimensional arrays
1 C++ supports multidimensional arrays. The simplest form of the
multidimensional array is the two-dimensional array.

Pointer to an array
2 You can generate a pointer to the first element of an array by simply specifying
the array name, without any index.

Passing arrays to functions

3 You can pass to the function a pointer to an array by specifying the array's
name without an index.

Return array from functions

4
C++ allows a function to return an array.

C++ provides following two types of string representations −

 The C-style character string.

 The string class type introduced with Standard C++.

The C-Style Character String

The C-style character string originated within the C language and
continues to be supported within C++. This string is actually a one-
dimensional array of characters which is terminated by
a null character '\0'. Thus a null-terminated string contains the
characters that comprise the string followed by a null.

The following declaration and initialization create a string consisting

of the word "Hello". To hold the null character at the end of the
array, the size of the character array containing the string is one
more than the number of characters in the word "Hello."

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

If you follow the rule of array initialization, then you can write the
above statement as follows −

char greeting[] = "Hello";

Following is the memory presentation of above defined string in

C/C++ −

Actually, you do not place the null character at the end of a string
constant. The C++ compiler automatically places the '\0' at the end
of the string when it initializes the array. Let us try to print above-
mentioned string −

Live Demo
#include <iostream>

using namespace std;

int main () {

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

cout << "Greeting message: ";

cout << greeting << endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Greeting message: Hello

C++ supports a wide range of functions that manipulate null-

terminated strings −

Sr.No Function & Purpose

strcpy(s1, s2);
1
Copies string s2 into string s1.

strcat(s1, s2);
2
Concatenates string s2 onto the end of string s1.

strlen(s1);
3
Returns the length of string s1.

strcmp(s1, s2);
4
Returns 0 if s1 and s2 are the same; less than 0 if s1<s2; greater than 0 if s1>s2.

strchr(s1, ch);
5
Returns a pointer to the first occurrence of character ch in string s1.

strstr(s1, s2);
6
Returns a pointer to the first occurrence of string s2 in string s1.

Following example makes use of few of the above-mentioned

functions −

Live Demo
#include <iostream>
#include <cstring>

using namespace std;

int main () {

char str1[10] = "Hello";

char str2[10] = "World";
char str3[10];
int len ;

// copy str1 into str3

strcpy( str3, str1);
cout << "strcpy( str3, str1) : " << str3 << endl;

// concatenates str1 and str2

strcat( str1, str2);
cout << "strcat( str1, str2): " << str1 << endl;

// total lenghth of str1 after concatenation

len = strlen(str1);
cout << "strlen(str1) : " << len << endl;

return 0;
}

When the above code is compiled and executed, it produces result

something as follows −

strcpy( str3, str1) : Hello

strcat( str1, str2): HelloWorld
strlen(str1) : 10

The String Class in C++

The standard C++ library provides a string class type that supports
all the operations mentioned above, additionally much more
functionality. Let us check the following example −

Live Demo
#include <iostream>
#include <string>
using namespace std;
int main () {

string str1 = "Hello";

string str2 = "World";
string str3;
int len ;

// copy str1 into str3

str3 = str1;
cout << "str3 : " << str3 << endl;

// concatenates str1 and str2

str3 = str1 + str2;
cout << "str1 + str2 : " << str3 << endl;

// total length of str3 after concatenation

len = str3.size();
cout << "str3.size() : " << len << endl;

return 0;
}

When the above code is compiled and executed, it produces result

something as follows −

str3 : Hello
str1 + str2 : HelloWorld
str3.size() : 10

C++ pointers are easy and fun to learn. Some C++ tasks are
performed more easily with pointers, and other C++ tasks, such as
dynamic memory allocation, cannot be performed without them.

As you know every variable is a memory location and every memory

location has its address defined which can be accessed using
ampersand (&) operator which denotes an address in memory.
Consider the following which will print the address of the variables
defined −
Live Demo
#include <iostream>

using namespace std;

int main () {
int var1;
char var2[10];

cout << "Address of var1 variable: ";

cout << &var1 << endl;

cout << "Address of var2 variable: ";

cout << &var2 << endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Address of var1 variable: 0xbfebd5c0

Address of var2 variable: 0xbfebd5b6

What are Pointers?

A pointer is a variable whose value is the address of another
variable. Like any variable or constant, you must declare a pointer
before you can work with it. The general form of a pointer variable
declaration is −

type *var-name;

Here, type is the pointer's base type; it must be a valid C++ type
and var-name is the name of the pointer variable. The asterisk you
used to declare a pointer is the same asterisk that you use for
multiplication. However, in this statement the asterisk is being used
to designate a variable as a pointer. Following are the valid pointer
declaration −

int *ip; // pointer to an integer

double *dp; // pointer to a double
float *fp; // pointer to a float
char *ch // pointer to character

The actual data type of the value of all pointers, whether integer,
float, character, or otherwise, is the same, a long hexadecimal
number that represents a memory address. The only difference
between pointers of different data types is the data type of the
variable or constant that the pointer points to.

Using Pointers in C++

There are few important operations, which we will do with the
pointers very frequently. (a) We define a pointer variable. (b) Assign
the address of a variable to a pointer. (c) Finally access the value at
the address available in the pointer variable. This is done by using
unary operator * that returns the value of the variable located at
the address specified by its operand. Following example makes use
of these operations −

Live Demo
#include <iostream>

using namespace std;

int main () {
int var = 20; // actual variable declaration.
int *ip; // pointer variable

ip = &var; // store address of var in pointer

variable

cout << "Value of var variable: ";

cout << var << endl;

// print the address stored in ip pointer variable

cout << "Address stored in ip variable: ";
cout << ip << endl;
 // access the value at the address available in
pointer
cout << "Value of *ip variable: ";
cout << *ip << endl;

return 0;
}

When the above code is compiled and executed, it produces result

something as follows −

Value of var variable: 20

Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20

Pointers in C++
Pointers have many but easy concepts and they are very important
to C++ programming. There are following few important pointer
concepts which should be clear to a C++ programmer −

Sr.No Concept & Description

Null Pointers
1 C++ supports null pointer, which is a constant with a value of zero defined in
several standard libraries.

Pointer Arithmetic
2
There are four arithmetic operators that can be used on pointers: ++, --, +, -

Pointers vs Arrays
3
There is a close relationship between pointers and arrays.

Array of Pointers
4
You can define arrays to hold a number of pointers.

Pointer to Pointer
5
C++ allows you to have pointer on a pointer and so on.

Passing Pointers to Functions

6 Passing an argument by reference or by address both enable the passed
argument to be changed in the calling function by the called function.
 Return Pointer from Functions
7 C++ allows a function to return a pointer to local variable, static variable and
dynamically allocated memory as well

A reference variable is an alias, that is, another name for an already

existing variable. Once a reference is initialized with a variable,
either the variable name or the reference name may be used to
refer to the variable.

References vs Pointers
References are often confused with pointers but three major
differences between references and pointers are −

 You cannot have NULL references. You must always be able to

assume that a reference is connected to a legitimate piece of
storage.
 Once a reference is initialized to an object, it cannot be
changed to refer to another object. Pointers can be pointed to
another object at any time.
 A reference must be initialized when it is created. Pointers can
be initialized at any time.

Creating References in C++

Think of a variable name as a label attached to the variable's
location in memory. You can then think of a reference as a second
label attached to that memory location. Therefore, you can access
the contents of the variable through either the original variable
name or the reference. For example, suppose we have the following
example −

int i = 17;

We can declare reference variables for i as follows.

int& r = i;
Read the & in these declarations as reference. Thus, read the first
declaration as "r is an integer reference initialized to i" and read the
second declaration as "s is a double reference initialized to d.".
Following example makes use of references on int and double −

Live Demo
#include <iostream>

using namespace std;

int main () {
// declare simple variables
int i;
double d;

// declare reference variables

int& r = i;
double& s = d;

i = 5;
cout << "Value of i : " << i << endl;
cout << "Value of i reference : " << r << endl;

d = 11.7;
cout << "Value of d : " << d << endl;
cout << "Value of d reference : " << s << endl;

return 0;
}

When the above code is compiled together and executed, it

produces the following result −

Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7
References are usually used for function argument lists and function
return values. So following are two important subjects related to
C++ references which should be clear to a C++ programmer −

Sr.No Concept & Description

References as Parameters
1 C++ supports passing references as function parameter more safely than
parameters.

Reference as Return Value

2
You can return reference from a C++ function like any other data type.

The C++ standard library does not provide a proper date type. C++
inherits the structs and functions for date and time manipulation
from C. To access date and time related functions and structures,
you would need to include <ctime> header file in your C++
program.

There are four time-related types: clock_t, time_t, size_t, and tm. The
types - clock_t, size_t and time_t are capable of representing the
system time and date as some sort of integer.

The structure type tm holds the date and time in the form of a C
structure having the following elements −

struct tm {
int tm_sec; // seconds of minutes from 0 to 61
int tm_min; // minutes of hour from 0 to 59
int tm_hour; // hours of day from 0 to 24
int tm_mday; // day of month from 1 to 31
int tm_mon; // month of year from 0 to 11
int tm_year; // year since 1900
int tm_wday; // days since sunday
int tm_yday; // days since January 1st
int tm_isdst; // hours of daylight savings time
}

Following are the important functions, which we use while working

with date and time in C or C++. All these functions are part of
standard C and C++ library and you can check their detail using
reference to C++ standard library given below.

Sr.No Function & Purpose

time_t time(time_t *time);

1 This returns the current calendar time of the system in number of seconds
elapsed since January 1, 1970. If the system has no time, .1 is returned.

char *ctime(const time_t *time);

2 This returns a pointer to a string of the form day month year
hours:minutes:seconds year\n\0.

struct tm *localtime(const time_t *time);

3
This returns a pointer to the tm structure representing local time.

clock_t clock(void);
4 This returns a value that approximates the amount of time the calling program
has been running. A value of .1 is returned if the time is not available.

char * asctime ( const struct tm * time );

This returns a pointer to a string that contains the information stored in the
5
structure pointed to by time converted into the form: day month date
hours:minutes:seconds year\n\0

struct tm *gmtime(const time_t *time);

This returns a pointer to the time in the form of a tm structure. The time is
6
represented in Coordinated Universal Time (UTC), which is essentially
Greenwich Mean Time (GMT).

time_t mktime(struct tm *time);

7 This returns the calendar-time equivalent of the time found in the structure
pointed to by time.

double difftime ( time_t time2, time_t time1 );

8
This function calculates the difference in seconds between time1 and time2.

size_t strftime();
9
This function can be used to format date and time in a specific format.

Current Date and Time

Suppose you want to retrieve the current system date and time,
either as a local time or as a Coordinated Universal Time (UTC).
Following is the example to achieve the same −
Live Demo
#include <iostream>
#include <ctime>

using namespace std;

int main() {
// current date/time based on current system
time_t now = time(0);

// convert now to string form

char* dt = ctime(&now);

cout << "The local date and time is: " << dt << endl;

// convert now to tm struct for UTC

tm *gmtm = gmtime(&now);
dt = asctime(gmtm);
cout << "The UTC date and time is:"<< dt << endl;
}

When the above code is compiled and executed, it produces the

following result −

The local date and time is: Sat Jan 8 20:07:41 2011

The UTC date and time is:Sun Jan 9 03:07:41 2011

Format Time using struct tm

The tm structure is very important while working with date and time
in either C or C++. This structure holds the date and time in the
form of a C structure as mentioned above. Most of the time related
functions makes use of tm structure. Following is an example which
makes use of various date and time related functions and tm
structure −

While using structure in this chapter, I'm making an assumption

that you have basic understanding on C structure and how to access
structure members using arrow -> operator.
Live Demo
#include <iostream>
#include <ctime>

using namespace std;

int main() {
// current date/time based on current system
time_t now = time(0);

cout << "Number of sec since January 1,1970 is:: " <<
now << endl;

tm *ltm = localtime(&now);

// print various components of tm structure.

cout << "Year:" << 1900 + ltm->tm_year<<endl;
cout << "Month: "<< 1 + ltm->tm_mon<< endl;
cout << "Day: "<< ltm->tm_mday << endl;
cout << "Time: "<< 5+ltm->tm_hour << ":";
cout << 30+ltm->tm_min << ":";
cout << ltm->tm_sec << endl;
}

When the above code is compiled and executed, it produces the

following result −

Number of sec since January 1,1970 is:: 1588485717

Year:2020
Month: 5
Day: 3
Time: 11:31:57

The C++ standard libraries provide an extensive set of input/output

capabilities which we will see in subsequent chapters. This chapter
will discuss very basic and most common I/O operations required
for C++ programming.

C++ I/O occurs in streams, which are sequences of bytes. If bytes

flow from a device like a keyboard, a disk drive, or a network
connection etc. to main memory, this is called input operation and if
bytes flow from main memory to a device like a display screen, a
printer, a disk drive, or a network connection, etc., this is
called output operation.

I/O Library Header Files

There are following header files important to C++ programs −

Sr.No Header File & Function and Description

<iostream>
This file defines the cin, cout, cerr and clog objects, which correspond to the
1
standard input stream, the standard output stream, the un-buffered standard
error stream and the buffered standard error stream, respectively.

<iomanip>
2 This file declares services useful for performing formatted I/O with so-called
parameterized stream manipulators, such as setw and setprecision.

<fstream>
3 This file declares services for user-controlled file processing. We will discuss
about it in detail in File and Stream related chapter.

The Standard Output Stream (cout)

The predefined object cout is an instance of ostream class. The cout
object is said to be "connected to" the standard output device,
which usually is the display screen. The cout is used in conjunction
with the stream insertion operator, which is written as << which are
two less than signs as shown in the following example.

Live Demo
#include <iostream>

using namespace std;

int main() {
char str[] = "Hello C++";

cout << "Value of str is : " << str << endl;

}

When the above code is compiled and executed, it produces the

following result −

Value of str is : Hello C++

The C++ compiler also determines the data type of variable to be

output and selects the appropriate stream insertion operator to
display the value. The << operator is overloaded to output data
items of built-in types integer, float, double, strings and pointer
values.

The insertion operator << may be used more than once in a single
statement as shown above and endl is used to add a new-line at the
end of the line.

The Standard Input Stream (cin)

The predefined object cin is an instance of istream class. The cin
object is said to be attached to the standard input device, which
usually is the keyboard. The cin is used in conjunction with the
stream extraction operator, which is written as >> which are two
greater than signs as shown in the following example.

Live Demo
#include <iostream>

using namespace std;

int main() {
char name[50];

cout << "Please enter your name: ";

cin >> name;
cout << "Your name is: " << name << endl;

}
When the above code is compiled and executed, it will prompt you
to enter a name. You enter a value and then hit enter to see the
following result −

Please enter your name: cplusplus

Your name is: cplusplus

The C++ compiler also determines the data type of the entered
value and selects the appropriate stream extraction operator to
extract the value and store it in the given variables.

The stream extraction operator >> may be used more than once in
a single statement. To request more than one datum you can use
the following −

cin >> name >> age;

This will be equivalent to the following two statements −

cin >> name;

cin >> age;

The Standard Error Stream (cerr)

The predefined object cerr is an instance of ostream class. The cerr
object is said to be attached to the standard error device, which is
also a display screen but the object cerr is un-buffered and each
stream insertion to cerr causes its output to appear immediately.

The cerr is also used in conjunction with the stream insertion

operator as shown in the following example.

Live Demo
#include <iostream>

using namespace std;

int main() {
char str[] = "Unable to read....";
 cerr << "Error message : " << str << endl;
}

When the above code is compiled and executed, it produces the

following result −

Error message : Unable to read....

The Standard Log Stream (clog)

The predefined object clog is an instance of ostream class. The clog
object is said to be attached to the standard error device, which is
also a display screen but the object clog is buffered. This means that
each insertion to clog could cause its output to be held in a buffer
until the buffer is filled or until the buffer is flushed.

The clog is also used in conjunction with the stream insertion

operator as shown in the following example.

Live Demo
#include <iostream>

using namespace std;

int main() {
char str[] = "Unable to read....";

clog << "Error message : " << str << endl;

}

When the above code is compiled and executed, it produces the

following result −

Error message : Unable to read....

You would not be able to see any difference in cout, cerr and clog
with these small examples, but while writing and executing big
programs the difference becomes obvious. So it is good practice to
display error messages using cerr stream and while displaying other
log messages then clog should be used.
C/C++ arrays allow you to define variables that combine several
data items of the same kind, but structure is another user defined
data type which allows you to combine data items of different kinds.

Structures are used to represent a record, suppose you want to

keep track of your books in a library. You might want to track the
following attributes about each book −

 Title
 Author
 Subject
 Book ID

Defining a Structure
To define a structure, you must use the struct statement. The struct
statement defines a new data type, with more than one member,
for your program. The format of the struct statement is this −

struct [structure tag] {

member definition;
member definition;
...
member definition;
} [one or more structure variables];

The structure tag is optional and each member definition is a normal

variable definition, such as int i; or float f; or any other valid
variable definition. At the end of the structure's definition, before
the final semicolon, you can specify one or more structure variables
but it is optional. Here is the way you would declare the Book
structure −

struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
Accessing Structure Members
To access any member of a structure, we use the member access
operator (.). The member access operator is coded as a period
between the structure variable name and the structure member that
we wish to access. You would use struct keyword to define variables
of structure type. Following is the example to explain usage of
structure −

Live Demo
#include <iostream>
#include <cstring>

using namespace std;

struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
};

int main() {
struct Books Book1; // Declare Book1 of type
Book
struct Books Book2; // Declare Book2 of type
Book

// book 1 specification
strcpy( Book1.title, "Learn C++ Programming");
strcpy( Book1.author, "Chand Miyan");
strcpy( Book1.subject, "C++ Programming");
Book1.book_id = 6495407;

// book 2 specification
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Yakit Singha");
strcpy( Book2.subject, "Telecom");
Book2.book_id = 6495700;

// Print Book1 info

 cout << "Book 1 title : " << Book1.title <<endl;
cout << "Book 1 author : " << Book1.author <<endl;
cout << "Book 1 subject : " << Book1.subject <<endl;
cout << "Book 1 id : " << Book1.book_id <<endl;

// Print Book2 info

cout << "Book 2 title : " << Book2.title <<endl;
cout << "Book 2 author : " << Book2.author <<endl;
cout << "Book 2 subject : " << Book2.subject <<endl;
cout << "Book 2 id : " << Book2.book_id <<endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Book 1 title : Learn C++ Programming

Book 1 author : Chand Miyan
Book 1 subject : C++ Programming
Book 1 id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Yakit Singha
Book 2 subject : Telecom
Book 2 id : 6495700

Structures as Function Arguments

You can pass a structure as a function argument in very similar way
as you pass any other variable or pointer. You would access
structure variables in the similar way as you have accessed in the
above example −

Live Demo
#include <iostream>
#include <cstring>

using namespace std;

void printBook( struct Books book );
struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
};

int main() {
struct Books Book1; // Declare Book1 of type
Book
struct Books Book2; // Declare Book2 of type
Book

// book 1 specification
strcpy( Book1.title, "Learn C++ Programming");
strcpy( Book1.author, "Chand Miyan");
strcpy( Book1.subject, "C++ Programming");
Book1.book_id = 6495407;

// book 2 specification
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Yakit Singha");
strcpy( Book2.subject, "Telecom");
Book2.book_id = 6495700;

// Print Book1 info

printBook( Book1 );

// Print Book2 info

printBook( Book2 );

return 0;
}
void printBook( struct Books book ) {
cout << "Book title : " << book.title <<endl;
cout << "Book author : " << book.author <<endl;
cout << "Book subject : " << book.subject <<endl;
cout << "Book id : " << book.book_id <<endl;
}
When the above code is compiled and executed, it produces the
following result −

Book title : Learn C++ Programming

Book author : Chand Miyan
Book subject : C++ Programming
Book id : 6495407
Book title : Telecom Billing
Book author : Yakit Singha
Book subject : Telecom
Book id : 6495700

Pointers to Structures
You can define pointers to structures in very similar way as you
define pointer to any other variable as follows −

struct Books *struct_pointer;

Now, you can store the address of a structure variable in the above
defined pointer variable. To find the address of a structure variable,
place the & operator before the structure's name as follows −

struct_pointer = &Book1;

To access the members of a structure using a pointer to that

structure, you must use the -> operator as follows −

struct_pointer->title;

Let us re-write above example using structure pointer, hope this will
be easy for you to understand the concept −

Live Demo
#include <iostream>
#include <cstring>

using namespace std;

void printBook( struct Books *book );
struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main() {
struct Books Book1; // Declare Book1 of type
Book
struct Books Book2; // Declare Book2 of type
Book

// Book 1 specification
strcpy( Book1.title, "Learn C++ Programming");
strcpy( Book1.author, "Chand Miyan");
strcpy( Book1.subject, "C++ Programming");
Book1.book_id = 6495407;

// Book 2 specification
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Yakit Singha");
strcpy( Book2.subject, "Telecom");
Book2.book_id = 6495700;

// Print Book1 info, passing address of structure

printBook( &Book1 );

// Print Book1 info, passing address of structure

printBook( &Book2 );

return 0;
}

// This function accept pointer to structure as

parameter.
void printBook( struct Books *book ) {
cout << "Book title : " << book->title <<endl;
cout << "Book author : " << book->author <<endl;
cout << "Book subject : " << book->subject <<endl;
cout << "Book id : " << book->book_id <<endl;
}
When the above code is compiled and executed, it produces the
following result −

Book title : Learn C++ Programming

Book author : Chand Miyan
Book subject : C++ Programming
Book id : 6495407
Book title : Telecom Billing
Book author : Yakit Singha
Book subject : Telecom
Book id : 6495700

The typedef Keyword

There is an easier way to define structs or you could "alias" types
you create. For example −

typedef struct {
char title[50];
char author[50];
char subject[100];
int book_id;
} Books;

Now, you can use Books directly to define variables of Books type
without using struct keyword. Following is the example −

Books Book1, Book2;

You can use typedef keyword for non-structs as well as follows −

typedef long int *pint32;

pint32 x, y, z;

x, y and z are all pointers to long ints.

The main purpose of C++ programming is to add object orientation
to the C programming language and classes are the central feature
of C++ that supports object-oriented programming and are often
called user-defined types.

A class is used to specify the form of an object and it combines data

representation and methods for manipulating that data into one
neat package. The data and functions within a class are called
members of the class.

C++ Class Definitions

When you define a class, you define a blueprint for a data type. This
doesn't actually define any data, but it does define what the class
name means, that is, what an object of the class will consist of and
what operations can be performed on such an object.

A class definition starts with the keyword class followed by the class
name; and the class body, enclosed by a pair of curly braces. A
class definition must be followed either by a semicolon or a list of
declarations. For example, we defined the Box data type using the
keyword class as follows −

class Box {
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};

The keyword public determines the access attributes of the members

of the class that follows it. A public member can be accessed from
outside the class anywhere within the scope of the class object. You
can also specify the members of a class as private or protected which
we will discuss in a sub-section.

Define C++ Objects

A class provides the blueprints for objects, so basically an object is
created from a class. We declare objects of a class with exactly the
same sort of declaration that we declare variables of basic types.
Following statements declare two objects of class Box −

Box Box1; // Declare Box1 of type Box

Box Box2; // Declare Box2 of type Box

Both of the objects Box1 and Box2 will have their own copy of data
members.

Accessing the Data Members

The public data members of objects of a class can be accessed using
the direct member access operator (.). Let us try the following
example to make the things clear −

Live Demo
#include <iostream>

using namespace std;

class Box {
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};

int main() {
Box Box1; // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box
here

// box 1 specification
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;

// box 2 specification
 Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;

// volume of box 1
volume = Box1.height * Box1.length * Box1.breadth;
cout << "Volume of Box1 : " << volume <<endl;

// volume of box 2
volume = Box2.height * Box2.length * Box2.breadth;
cout << "Volume of Box2 : " << volume <<endl;
return 0;
}

When the above code is compiled and executed, it produces the

following result −

Volume of Box1 : 210

Volume of Box2 : 1560

It is important to note that private and protected members can not

be accessed directly using direct member access operator (.). We
will learn how private and protected members can be accessed.

Classes and Objects in Detail

So far, you have got very basic idea about C++ Classes and
Objects. There are further interesting concepts related to C++
Classes and Objects which we will discuss in various sub-sections
listed below −

Sr.No Concept & Description

Class Member Functions

1 A member function of a class is a function that has its definition or its
prototype within the class definition like any other variable.

Class Access Modifiers

2 A class member can be defined as public, private or protected. By default
members would be assumed as private.
 Constructor & Destructor
A class constructor is a special function in a class that is called when a new
3
object of the class is created. A destructor is also a special function which is
called when created object is deleted.

Copy Constructor
4 The copy constructor is a constructor which creates an object by initializing it
with an object of the same class, which has been created previously.

Friend Functions
5 A friend function is permitted full access to private and protected members of
a class.

Inline Functions
6 With an inline function, the compiler tries to expand the code in the body of
the function in place of a call to the function.

this Pointer
7
Every object has a special pointer this which points to the object itself.

Pointer to C++ Classes

8 A pointer to a class is done exactly the same way a pointer to a structure is. In
fact a class is really just a structure with functions in it.

Static Members of a Class

9
Both data members and function members of a class can be declared as static.

One of the most important concepts in object-oriented programming

is that of inheritance. Inheritance allows us to define a class in
terms of another class, which makes it easier to create and maintain
an application. This also provides an opportunity to reuse the code
functionality and fast implementation time.

When creating a class, instead of writing completely new data

members and member functions, the programmer can designate
that the new class should inherit the members of an existing class.
This existing class is called the base class, and the new class is
referred to as the derived class.

The idea of inheritance implements the is a relationship. For

example, mammal IS-A animal, dog IS-A mammal hence dog IS-A
animal as well and so on.
Base and Derived Classes
A class can be derived from more than one classes, which means it
can inherit data and functions from multiple base classes. To define
a derived class, we use a class derivation list to specify the base
class(es). A class derivation list names one or more base classes
and has the form −

class derived-class: access-specifier base-class

Where access-specifier is one of public, protected, or private, and base-

class is the name of a previously defined class. If the access-
specifier is not used, then it is private by default.

Consider a base class Shape and its derived class Rectangle as follows
−

Live Demo
#include <iostream>

using namespace std;

// Base class
class Shape {
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}

protected:
int width;
int height;
};

// Derived class
class Rectangle: public Shape {
public:
int getArea() {
 return (width * height);
}
};

int main(void) {
Rectangle Rect;

Rect.setWidth(5);
Rect.setHeight(7);

// Print the area of the object.

cout << "Total area: " << Rect.getArea() << endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Total area: 35

Access Control and Inheritance

A derived class can access all the non-private members of its base
class. Thus base-class members that should not be accessible to the
member functions of derived classes should be declared private in
the base class.

We can summarize the different access types according to - who

can access them in the following way −

Access public protected private

Same class yes yes yes

Derived classes yes yes no

Outside classes yes no no

A derived class inherits all base class methods with the following
exceptions −
  Constructors, destructors and copy constructors of the base
class.
 Overloaded operators of the base class.
 The friend functions of the base class.

Type of Inheritance
When deriving a class from a base class, the base class may be
inherited through public, protected or private inheritance. The type of
inheritance is specified by the access-specifier as explained above.

We hardly use protected or private inheritance, but public inheritance

is commonly used. While using different type of inheritance,
following rules are applied −

 Public Inheritance − When deriving a class from a public base

class, public members of the base class become public members
of the derived class and protected members of the base class
become protected members of the derived class. A base
class's private members are never accessible directly from a
derived class, but can be accessed through calls to
the public and protected members of the base class.
 Protected Inheritance − When deriving from a protected base
class, public and protected members of the base class
become protected members of the derived class.
 Private Inheritance − When deriving from a private base
class, public and protected members of the base class
become private members of the derived class.

Multiple Inheritance
A C++ class can inherit members from more than one class and
here is the extended syntax −

class derived-class: access baseA, access baseB....

Where access is one of public, protected, or private and would be given

for every base class and they will be separated by comma as shown
above. Let us try the following example −
Live Demo
#include <iostream>

using namespace std;

// Base class Shape

class Shape {
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}

protected:
int width;
int height;
};

// Base class PaintCost

class PaintCost {
public:
int getCost(int area) {
return area * 70;
}
};

// Derived class
class Rectangle: public Shape, public PaintCost {
public:
int getArea() {
return (width * height);
}
};

int main(void) {
Rectangle Rect;
int area;

Rect.setWidth(5);
Rect.setHeight(7);
 area = Rect.getArea();

// Print the area of the object.

cout << "Total area: " << Rect.getArea() << endl;

// Print the total cost of painting

cout << "Total paint cost: $" << Rect.getCost(area) <<
endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Total area: 35
Total paint cost: $2450

One of the most important concepts in object-oriented programming

is that of inheritance. Inheritance allows us to define a class in
terms of another class, which makes it easier to create and maintain
an application. This also provides an opportunity to reuse the code
functionality and fast implementation time.

When creating a class, instead of writing completely new data

members and member functions, the programmer can designate
that the new class should inherit the members of an existing class.
This existing class is called the base class, and the new class is
referred to as the derived class.

The idea of inheritance implements the is a relationship. For

example, mammal IS-A animal, dog IS-A mammal hence dog IS-A
animal as well and so on.

Base and Derived Classes

A class can be derived from more than one classes, which means it
can inherit data and functions from multiple base classes. To define
a derived class, we use a class derivation list to specify the base
class(es). A class derivation list names one or more base classes
and has the form −

class derived-class: access-specifier base-class

Where access-specifier is one of public, protected, or private, and base-

class is the name of a previously defined class. If the access-
specifier is not used, then it is private by default.

Consider a base class Shape and its derived class Rectangle as follows
−

Live Demo
#include <iostream>

using namespace std;

// Base class
class Shape {
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}

protected:
int width;
int height;
};

// Derived class
class Rectangle: public Shape {
public:
int getArea() {
return (width * height);
}
};

int main(void) {
 Rectangle Rect;

Rect.setWidth(5);
Rect.setHeight(7);

// Print the area of the object.

cout << "Total area: " << Rect.getArea() << endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Total area: 35

Access Control and Inheritance

A derived class can access all the non-private members of its base
class. Thus base-class members that should not be accessible to the
member functions of derived classes should be declared private in
the base class.

We can summarize the different access types according to - who

can access them in the following way −

Access public protected private

Same class yes yes yes

Derived classes yes yes no

Outside classes yes no no

A derived class inherits all base class methods with the following
exceptions −

 Constructors, destructors and copy constructors of the base

class.
 Overloaded operators of the base class.
 The friend functions of the base class.
Type of Inheritance
When deriving a class from a base class, the base class may be
inherited through public, protected or private inheritance. The type of
inheritance is specified by the access-specifier as explained above.

We hardly use protected or private inheritance, but public inheritance

is commonly used. While using different type of inheritance,
following rules are applied −

 Public Inheritance − When deriving a class from a public base

class, public members of the base class become public members
of the derived class and protected members of the base class
become protected members of the derived class. A base
class's private members are never accessible directly from a
derived class, but can be accessed through calls to
the public and protected members of the base class.
 Protected Inheritance − When deriving from a protected base
class, public and protected members of the base class
become protected members of the derived class.
 Private Inheritance − When deriving from a private base
class, public and protected members of the base class
become private members of the derived class.

Multiple Inheritance
A C++ class can inherit members from more than one class and
here is the extended syntax −

class derived-class: access baseA, access baseB....

Where access is one of public, protected, or private and would be given

for every base class and they will be separated by comma as shown
above. Let us try the following example −

Live Demo
#include <iostream>

using namespace std;

// Base class Shape
class Shape {
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}

protected:
int width;
int height;
};

// Base class PaintCost

class PaintCost {
public:
int getCost(int area) {
return area * 70;
}
};

// Derived class
class Rectangle: public Shape, public PaintCost {
public:
int getArea() {
return (width * height);
}
};

int main(void) {
Rectangle Rect;
int area;

Rect.setWidth(5);
Rect.setHeight(7);

area = Rect.getArea();

// Print the area of the object.

cout << "Total area: " << Rect.getArea() << endl;
 // Print the total cost of painting
cout << "Total paint cost: $" << Rect.getCost(area) <<
endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Total area: 35
Total paint cost: $2450

C++ allows you to specify more than one definition for

a function name or an operator in the same scope, which is
called function overloading and operator overloading respectively.

An overloaded declaration is a declaration that is declared with the

same name as a previously declared declaration in the same scope,
except that both declarations have different arguments and
obviously different definition (implementation).

When you call an overloaded function or operator, the compiler

determines the most appropriate definition to use, by comparing the
argument types you have used to call the function or operator with
the parameter types specified in the definitions. The process of
selecting the most appropriate overloaded function or operator is
called overload resolution.

Function Overloading in C++

You can have multiple definitions for the same function name in the
same scope. The definition of the function must differ from each
other by the types and/or the number of arguments in the
argument list. You cannot overload function declarations that differ
only by return type.

Following is the example where same function print() is being used

to print different data types −
Live Demo
#include <iostream>
using namespace std;

class printData {
public:
void print(int i) {
cout << "Printing int: " << i << endl;
}
void print(double f) {
cout << "Printing float: " << f << endl;
}
void print(char* c) {
cout << "Printing character: " << c << endl;
}
};

int main(void) {
printData pd;

// Call print to print integer

pd.print(5);

// Call print to print float

pd.print(500.263);

// Call print to print character

pd.print("Hello C++");

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Operators Overloading in C++

You can redefine or overload most of the built-in operators available
in C++. Thus, a programmer can use operators with user-defined
types as well.

Overloaded operators are functions with special names: the

keyword "operator" followed by the symbol for the operator being
defined. Like any other function, an overloaded operator has a
return type and a parameter list.

Box operator+(const Box&);

declares the addition operator that can be used to add two Box
objects and returns final Box object. Most overloaded operators may
be defined as ordinary non-member functions or as class member
functions. In case we define above function as non-member function
of a class then we would have to pass two arguments for each
operand as follows −

Box operator+(const Box&, const Box&);

Following is the example to show the concept of operator over

loading using a member function. Here an object is passed as an
argument whose properties will be accessed using this object, the
object which will call this operator can be accessed
using this operator as explained below −

Live Demo
#include <iostream>
using namespace std;

class Box {
public:
double getVolume(void) {
return length * breadth * height;
}
void setLength( double len ) {
length = len;
}
void setBreadth( double bre ) {
breadth = bre;
}
 void setHeight( double hei ) {
height = hei;
}

// Overload + operator to add two Box objects.

Box operator+(const Box& b) {
Box box;
box.length = this->length + b.length;
box.breadth = this->breadth + b.breadth;
box.height = this->height + b.height;
return box;
}

private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};

// Main function for the program

int main() {
Box Box1; // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
Box Box3; // Declare Box3 of type Box
double volume = 0.0; // Store the volume of a box
here

// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);

// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);

// volume of box 1
volume = Box1.getVolume();
cout << "Volume of Box1 : " << volume <<endl;

// volume of box 2
 volume = Box2.getVolume();
cout << "Volume of Box2 : " << volume <<endl;

// Add two object as follows:

Box3 = Box1 + Box2;

// volume of box 3
volume = Box3.getVolume();
cout << "Volume of Box3 : " << volume <<endl;

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Volume of Box1 : 210

Volume of Box2 : 1560
Volume of Box3 : 5400

Overloadable/Non-overloadableOperators
Following is the list of operators which can be overloaded −

+ - * / % ^

& | ~ ! , =

< > <= >= ++ --

<< >> == != && ||

+= -= /= %= ^= &=

|= *= <<= >>= [] ()

-> ->* new new [] delete delete []

Following is the list of operators, which can not be overloaded −

:: .* . ?:
Operator Overloading Examples
Here are various operator overloading examples to help you in
understanding the concept.

Sr.No Operators & Example

1 Unary Operators Overloading

2 Binary Operators Overloading

3 Relational Operators Overloading

4 Input/Output Operators Overloading

5 ++ and -- Operators Overloading

6 Assignment Operators Overloading

7 Function call () Operator Overloading

8 Subscripting [] Operator Overloading

9 Class Member Access Operator -> Overloading

The word polymorphism means having many forms. Typically,

polymorphism occurs when there is a hierarchy of classes and they
are related by inheritance.

C++ polymorphism means that a call to a member function will

cause a different function to be executed depending on the type of
object that invokes the function.

Consider the following example where a base class has been derived
by other two classes −

#include <iostream>
using namespace std;

class Shape {
protected:
int width, height;
 public:
Shape( int a = 0, int b = 0){
width = a;
height = b;
}
int area() {
cout << "Parent class area :" << width * height << endl;
return width * height;
}
};
class Rectangle: public Shape {
public:
Rectangle( int a = 0, int b = 0):Shape(a, b) { }

int area () {
cout << "Rectangle class area :" << width * height << endl;
return (width * height);
}
};

class Triangle: public Shape {

public:
Triangle( int a = 0, int b = 0):Shape(a, b) { }

int area () {
cout << "Triangle class area :" << (width * height)/2 << endl;
return (width * height / 2);
}
};

// Main function for the program

int main() {
Shape *shape;
Rectangle rec(10,7);
Triangle tri(10,5);
 // store the address of Rectangle
shape = &rec;

// call rectangle area.

shape->area();

// store the address of Triangle

shape = &tri;

// call triangle area.

shape->area();

return 0;
}

When the above code is compiled and executed, it produces the

following result −

Parent class area :70

Parent class area :50

The reason for the incorrect output is that the call of the function
area() is being set once by the compiler as the version defined in
the base class. This is called static resolution of the function call,
or static linkage - the function call is fixed before the program is
executed. This is also sometimes called early binding because the
area() function is set during the compilation of the program.

But now, let's make a slight modification in our program and

precede the declaration of area() in the Shape class with the
keyword virtual so that it looks like this −

#include <iostream>
using namespace std;

class Shape {
protected:
 int width, height;

public:
Shape( int a = 0, int b = 0){
width = a;
height = b;
}
virtual int area() {
cout << "Parent class area :" << width * height << endl;
return width * height;
}
};
class Rectangle: public Shape {
public:
Rectangle( int a = 0, int b = 0):Shape(a, b) { }

int area () {
cout << "Rectangle class area :" << width * height << endl;
return (width * height);
}
};

class Triangle: public Shape {

public:
Triangle( int a = 0, int b = 0):Shape(a, b) { }

int area () {
cout << "Triangle class area :" << (width * height)/2 << endl;
return (width * height / 2);
}
};

// Main function for the program

int main() {
Shape *shape;
Rectangle rec(10,7);
 Triangle tri(10,5);

// store the address of Rectangle

shape = &rec;

// call rectangle area.

shape->area();

// store the address of Triangle

shape = &tri;

// call triangle area.

shape->area();

return 0;
}

After this slight modification, when the previous example code is

compiled and executed, it produces the following result −

Rectangle class area :70

Triangle class area :25

This time, the compiler looks at the contents of the pointer instead
of it's type. Hence, since addresses of objects of tri and rec classes
are stored in *shape the respective area() function is called.

As you can see, each of the child classes has a separate

implementation for the function area(). This is how polymorphism is
generally used. You have different classes with a function of the
same name, and even the same parameters, but with different
implementations.

Virtual Function
A virtual function is a function in a base class that is declared using
the keyword virtual. Defining in a base class a virtual function, with
another version in a derived class, signals to the compiler that we
don't want static linkage for this function.

What we do want is the selection of the function to be called at any

given point in the program to be based on the kind of object for
which it is called. This sort of operation is referred to as dynamic
linkage, or late binding.

Pure Virtual Functions

It is possible that you want to include a virtual function in a base
class so that it may be redefined in a derived class to suit the
objects of that class, but that there is no meaningful definition you
could give for the function in the base class.

We can change the virtual function area() in the base class to the
following −

class Shape {
protected:
int width, height;

public:
Shape(int a = 0, int b = 0) {
width = a;
height = b;
}

// pure virtual function

virtual int area() = 0;
};

The = 0 tells the compiler that the function has no body and above
virtual function will be called pure virtual function.

Data abstraction refers to providing only essential information to the

outside world and hiding their background details, i.e., to represent
the needed information in program without presenting the details.
Data abstraction is a programming (and design) technique that
relies on the separation of interface and implementation.

Let's take one real life example of a TV, which you can turn on and
off, change the channel, adjust the volume, and add external
components such as speakers, VCRs, and DVD players, BUT you do
not know its internal details, that is, you do not know how it
receives signals over the air or through a cable, how it translates
them, and finally displays them on the screen.

Thus, we can say a television clearly separates its internal

implementation from its external interface and you can play with its
interfaces like the power button, channel changer, and volume
control without having any knowledge of its internals.

In C++, classes provides great level of data abstraction. They provide

sufficient public methods to the outside world to play with the
functionality of the object and to manipulate object data, i.e., state
without actually knowing how class has been implemented
internally.

For example, your program can make a call to the sort() function
without knowing what algorithm the function actually uses to sort
the given values. In fact, the underlying implementation of the
sorting functionality could change between releases of the library,
and as long as the interface stays the same, your function call will
still work.

In C++, we use classes to define our own abstract data types (ADT).
You can use the cout object of class ostream to stream data to
standard output like this −

Live Demo
#include <iostream>
using namespace std;

int main() {
cout << "Hello C++" <<endl;
return 0;
}
Here, you don't need to understand how cout displays the text on
the user's screen. You need to only know the public interface and
the underlying implementation of „cout‟ is free to change.

Access Labels Enforce Abstraction

In C++, we use access labels to define the abstract interface to the
class. A class may contain zero or more access labels −

 Members defined with a public label are accessible to all parts

of the program. The data-abstraction view of a type is defined
by its public members.
 Members defined with a private label are not accessible to
code that uses the class. The private sections hide the
implementation from code that uses the type.

There are no restrictions on how often an access label may appear.

Each access label specifies the access level of the succeeding
member definitions. The specified access level remains in effect
until the next access label is encountered or the closing right brace
of the class body is seen.

Benefits of Data Abstraction

Data abstraction provides two important advantages −

 Class internals are protected from inadvertent user-level

errors, which might corrupt the state of the object.
 The class implementation may evolve over time in response to
changing requirements or bug reports without requiring
change in user-level code.

By defining data members only in the private section of the class,

the class author is free to make changes in the data. If the
implementation changes, only the class code needs to be examined
to see what affect the change may have. If data is public, then any
function that directly access the data members of the old
representation might be broken.

Data Abstraction Example

Any C++ program where you implement a class with public and
private members is an example of data abstraction. Consider the
following example −

Live Demo
#include <iostream>
using namespace std;

class Adder {
public:
// constructor
Adder(int i = 0) {
total = i;
}

// interface to outside world

void addNum(int number) {
total += number;
}

// interface to outside world

int getTotal() {
return total;
};

private:
// hidden data from outside world
int total;
};

int main() {
Adder a;

a.addNum(10);
a.addNum(20);
a.addNum(30);

cout << "Total " << a.getTotal() <<endl;

return 0;
}
When the above code is compiled and executed, it produces the
following result −

Total 60

Above class adds numbers together, and returns the sum. The
public members - addNum and getTotal are the interfaces to the
outside world and a user needs to know them to use the class. The
private member total is something that the user doesn't need to
know about, but is needed for the class to operate properly.