Data types

All variables use data-type during declaration to restrict the type of data to be
stored. Therefore, we can say that data types are used to tell the variables the type
of data it can store. Whenever a variable is defined in C++, the compiler allocates
some memory for that variable based on the data-type with which it is declared.
Every data type requires a different amount of memory.

Data types in C++ is mainly divided into three types:

1. Primitive Data Types: These data types are built-in or predefined data
types and can be used directly by the user to declare variables. example: int,
char , float, bool etc. Primitive data types available in C++ are:
 Integer
 Character
 Boolean
 Floating Point
 Double Floating Point
 Valueless or Void
 Wide Character
 Primitive data types are predefined types of data, which are supported by the
programming language. For example, integer, character, and string are all
primitive data types.
Non-primitive data types are not defined by the programming language, but
are instead created by the programmer.

Primitive data structure is a data structure that can hold a single value in a
specific location whereas the non-linear data structure can hold multiple
values either in a contiguous location or random locations

The examples of primitive data structure are float, character, integer and
pointer. The value to the primitive data structure is provided by the
programmer. The following are the four primitive data structures:

o Integer: The integer data type contains the numeric values. It

contains the whole numbers that can be either negative or positive.
When the range of integer data type is not large enough then in that
case, we can use long.
o Float: The float is a data type that can hold decimal values. When the
precision of decimal value increases then the Double data type is used.
o Boolean: It is a data type that can hold either a True or a False value.
It is mainly used for checking the condition.
o Character: It is a data type that can hold a single character value
both uppercase and lowercase such as 'A' or 'a'.

Non-primitive data structure

The non-primitive data structure is a kind of data structure that can hold
multiple values either in a contiguous or random location. The non-primitive
data types are defined by the programmer. The non-primitive data structure
is further classified into two categories, i.e., linear and non-linear data
structure.

In case of linear data structure, the data is stored in a sequence, i.e., one
data after another data. When we access the data from the linear data
structure, we just need to start from one place and will find other data in a
sequence.
2. Derived Data Types: The data-types that are derived from the primitive or
built-in datatypes are referred to as Derived Data Types. These can be of
four types namely:

 Function
 Array
 Pointer
 Reference
3. Abstract or User-Defined Data Types : These data types are defined by
user itself. Like, defining a class in C++ or a structure. C++ provides the
following user-defined datatypes:
 Class
 Structure
 Union
 Enumeration
 Typedef defined DataType

primitive data types available in
 Integer: Keyword used for integer data types is int. Integers typically
requires 4 bytes of memory space and ranges from -2147483648 to
2147483647.

 Character: Character data type is used for storing characters. Keyword used
for character data type is char. Characters typically requires 1 byte of
memory space and ranges from -128 to 127 or 0 to 255.

 Boolean: Boolean data type is used for storing boolean or logical values. A
boolean variable can store either true or false. Keyword used for boolean
data type is bool.

 Floating Point: Floating Point data type is used for storing single precision
floating point values or decimal values. Keyword used for floating point data
type is float. Float variables typically requires 4 byte of memory space.

 Double Floating Point: Double Floating Point data type is used for storing
double precision floating point values or decimal values. Keyword used for
double floating point data type is double. Double variables typically requires
8 byte of memory space.

 void: Void means without any value. void datatype represents a valueless
entity. Void data type is used for those function which does not returns a
value.
 Wide Character: Wide character data type is also a character data type but
this data type has size greater than the normal 8-bit data type. Represented
by wchar_t. It is generally 2 or 4 bytes long.

Datatype Modifiers
As the name implies, datatype modifiers are used with the built-in data types to
modify the length of data that a particular data type can hold.

Data type modifiers available in C++ are:

 Signed
 Unsigned
 Short
 Long
Below table summarizes the modified size and range of built-in datatypes when
combined with the type modifiers:
The term "unsigned" in computer programming indicates a variable that can hold
only positive numbers. The term "signed" in computer code indicates that a
variable can hold negative and positive values.
Data Type Size (in bytes) Range
short int 2 -32,768 to 32,767
unsigned short int 2 0 to 65,535
unsigned int 4 0 to 4,294,967,295
Int 4 -2,147,483,648 to 2,147,483,647
long int 4 -2,147,483,648 to 2,147,483,647
unsigned long int 8 0 to 4,294,967,295
signed char 1 -128 to 127
unsigned char 1 0 to 255
Float 4
Double 8
long double 12
wchar_t 2 or 4 1 wide character

// C++ program to sizes of data types

#include<iostream>
#include<conio.h>
void main()
{
cout << "Size of char : " << sizeof(char) << " byte" << endl;
cout << "Size of int : " << sizeof(int) << " bytes" << endl;
cout << "Size of short int : " << sizeof(short int) << " bytes" << endl;
cout << "Size of long int : " << sizeof(long int) << " bytes" << endl;
cout << "Size of signed long int : " << sizeof(signed long int) << " bytes"
<< endl;
cout << "Size of unsigned long int : " << sizeof(unsigned long int)
<< " bytes" << endl;
cout << "Size of float : " << sizeof(float) << " bytes" <<endl;
 cout << "Size of double : " << sizeof(double)<< " bytes" << endl;
cout << "Size of wchar_t : " << sizeof(wchar_t) << " bytes" <<endl;
getch();
}

Output:

Size of char : 1 byte

Size of int : 4 bytes
Size of short int : 2 bytes
Size of long int : 8 bytes
Size of signed long int : 8 bytes
Size of unsigned long int : 8 bytes
Size of float : 4 bytes
Size of double : 8 bytes
Size of wchar_t : 4 bytes

Variables

A variable is a name given to a memory location. It is the basic unit of storage in

a program.
 The value stored in a variable can be changed during program execution.
 A variable is only a name given to a memory location, all the operations done
on the variable effects that memory location.
 In C++, all the variables must be declared before use.
How to declare variables?
A typical variable declaration is of the form:

// Declaring a single variable

type variable_name;

// Declaring multiple variables:

type variable1_name, variable2_name, variable3_name;
A variable name can consist of alphabets (both upper and lower case), numbers
and the underscore ‘_’ character. However, the name must not start with a
number.

Constants

As the name suggests the name constants are given to such variables or values in
C++ programming language which cannot be modified once they are defined.
They are fixed values in a program. There can be any types of constants like
integer, float, octal, hexadecimal, character constants, etc. Every constant has
some range. The integers that are too big to fit into an int will be taken as long.
Now there are various ranges that differ from unsigned to signed bits. Under the
signed bit, the range of an int varies from -128 to +127, and under the unsigned
bit, int varies from 0 to 255.

Defining Constants:

In C++ program we can define constants in two ways as shown below:

1. Using #define preprocessor directive

2. Using a const keyword

1. Using #define preprocessor directive: This directive is used to declare an

alias name for existing variable or any value. We can use this to declare a
constant as shown below:
#define identifierName value

 identifierName: It is the name given to constant.

 value: This refers to any value assigned to identifierName.
2. using a const keyword: Using const keyword to define constants is as simple
as defining variables, the difference is you will have to precede the definition
with a const keyword.

Below program shows how to use const to declare constants of different data
types:
#include <iostream.h>
#include<conio.h>
void main() {
// int constant
const int intVal = 10;

// Real constant
const float floatVal = 4.14;
 // char constant
const char charVal = 'A';

// string constant
const string stringVal = "ABC";

cout << "Integer Constant: " << intVal << "\n";

cout << "Floating point Constant: " << floatVal << "\n";
cout << "Character Constant: "<< charVal << "\n";
cout << "String Constant: "<< stringVal << "\n";
getch( );
}

Output:
Integer constant: 10
Floating point constant: 4.14
Character constant: A
String constant: ABC
 Types of constants

 Numeric Constant
 Character Constant
 Escape Sequences

Numeric Constant

These have numeric value having combination of sequence of digits i.e. from 0-9
as alone digit or combination of 0-9 with or without decimal point (precision
value) having positive or negative sign. These are further sub-divided into two
categories as:
(i) Integer Numeric Constant
(ii) Float or Real Numeric Constant
(i) Integer Numeric Constant

An Integer Numeric Constant is a sequence of digits (combination of 0-9 digits

without any decimal point or without precision), optionally preceded by a plus or
minus sign.
There are 3 types of integer numeric constant namely decimal integer, octal
integers and hexadecimal integer.
(a) Decimal Integer Numeric Constant: These have no decimal point in it and are
either be alone or be the combination of 0-9 digits. These have either +ve or -ve
sign. For example: 1214, -1321, 10,254, -78, +99 etc.
(b) Octal Integer Numeric Constant: These consist of combination of digits from
0-7 with positive or negative sign. It has leading with 0 or 0 (upper or lower case)
means Octal or octal. For example: 0317,003, -045 etc.
(c) Hexadecimal Integer Numeric Constant: These have hexadecimal data. It has
leading ox, OX, Ox or x, X. These have combination of 0-9 and A-F (a-f) or
alone. The letters a-f or A-F represents the numbers 10-15. For example: 0x232,
0x92, 0xACD, 0xAEF etc.
(ii) Float or Real Numeric Constant

A floating-point constant consists of a sequence of decimal digits, a decimal point,

and another sequence of decimal digits. A minus sign can precede the value to
denote a negative value. Either the sequence of digits before the decimal point or
after the decimal point can be omitted, but not both.
Character Constant

Character constants have either a single character or group of characters or a

character with backslash used for special purpose. These are further subdivided
into three types:
(i) Single Character Constant
(ii) String Character Constant
(iii) Backslash Character Constant
(i) Single Character Constant
Single Character constants are enclosed between single quotes(‘). For example,
‘a’ and ‘%’ are both character constants. So these are also called single quote
character constant.
For example: ‘a’, ‘M’, ‘5’, ‘+’, ‘1’ etc. are some valid single character constant.
(ii) String Character Constant

C++ supports another type of constant: the string. A string is a set of characters
enclosed in double quotes (“). For example: “Welcome to C++” is a string.
You must not confuse strings with characters. A single character constant is
enclosed in single quotes, as in ‘a’. However, “a” is a string containing only one
letter.
For example: “Dinesh”, “Hello”, “2013”, “2013-2020”, “5+3”, “?+!” etc. are
some valid string character constant. These are used for printing purpose or
display purpose in the C++ program’s output statements. These can also be used
for assigning the string data to the character (string) type variables.
(iii) Backslash Character Constants

Enclosing character constants in single quotes works for most printing characters.
A few, however, such as the carriage return, can’t be. For this reason, C++
includes the special backslash character constants, shown below, so that you may
easily enter these special characters as constants.
These are also referred to as escape sequences.
These are used for special purpose in the C++ language. These are used in output
statements like cout etc.
Escape Sequences

A list of backslash character constant or escape sequence is as in the below table:

Enumerations:
Enumeration is a user defined datatype in C++ language. It is used to assign names
to the integral constants which makes a program easy to read and maintain. The
keyword “enum” is used to declare an enumeration.
The following is the syntax of enums.
enum enum_name{const1, const2, ....... };
Here,
enum_name − Any name given by user.
const1, const2 − These are values of type flag.

Why Do You Use Enums?

Enums or enumerations are generally used when you expect the variable to select
one value from the possible set of values. It increases the abstraction and enables
you to focus more on values rather than worrying about how to store them. It is
also helpful for code documentation and readability purposes.

enum direction {East, West, North, South}dir;

Here Enumeration name is direction which can only take one of the four specified
values, the dir at the end of the declaration is an enum variable.

Lets take a simple example to understand this:

Here I have assigned the value West to the enum variable dir and when I displayed
the value of dir it shows 1. This is because by default the values are in increasing
order starting from 0, which means East is 0, West is 1, North is 2 and South is 3.

Simple enum Example

#include<iostream.h>
#include<conio.h>
enum direction {East, West, North, South}dir;
void main()
{
dir = West;
cout<<dir;
getch();
}
Another way to declare enum variable
As we have seen in the above example that I have declared the enum variable dir
during enum declaration, there is another way to declare an enum variable.

#include <iostream.h>
#include<conio.h>
enum direction {East, West, North, South};
void main(){
direction dir;
dir = South;
cout<<dir;
getch();
}
Output:

3
Why use enum in C++

Enums are used only when we expect the variable to have one of the possible
set of values, for example, we have a dir variable that holds the direction.
Since we have four directions, this variable can take any one of the four
values, if we try to assign a another random value to this variable, it will
throw a compilation error. This increases compile-time checking and avoid
errors that occurs by passing in invalid constants.
Another important place where they are used frequently are switch case statements
where all the values that case blocks expect can be defined in an enum. This way
we can ensure that the enum variable that we pass in switch parenthesis is not
taking any random value that it shouldn’t accept.

How to change default values of Enum

#include <iostream.h>
#include<conio.h>
enum direction {East=11, West=22, North=33,
South=44};
void main(){
direction dir;
dir = South;
cout<<dir;
getch();
}
Output:

44

The enum keyword is also used to define the variables of enum type. There are two
ways to define the variables of enum type as follows −
enum colors{red, black};
enum suit{heart, diamond=8, spade=3, club};
The following is an example of enums.

Example

#include<iostream.h>
#include<conio.h>
enum colors{red=5, black};
enum suit{heart, diamond=8, spade=3, club};
void main() {
cout <<"The value of enum color :
"<<red<<","<<black;
cout <<"\nThe default value of enum suit :
"<<heart<<","<<diamond<<","<<spade<<","<<club;
getch();
}
Output
The value of enum color : 5,6
The default value of enum suit : 0,8,3,4
In the above program, two enums are declared as color and suit outside the main()
function.
enum colors{red=5, black};
enum suit{heart, diamond=8, spade=3, club};
In the main() function, the values of enum elements are printed.
cout <<"The value of enum color : "<<red<<","<<black;
cout <<"\nThe default value of enum suit :
"<<heart<<","<<diamond<<","<<spade<<","<<club;
Compiler Tokens:

A token is the smallest element of a program that is meaningful to the compiler.

When C++ compiler analyzes a program, it breaks the program into TOKENS.A
TOKEN is a distinct unit that is recognizable by the compiler.
Tokens can be classified as follows:
1. Keywords
2. Identifiers
3. Constants
4. Strings
5. Special Symbols
6. Operators
1.Keywords: Keywords are pre-defined or reserved words in a programming
language. Each keyword is meant to perform a specific function in a program.
Since keywords are referred names for a compiler, they can’t be used as variable
names because by doing so, we are trying to assign a new meaning to the
keyword which is not allowed. You cannot redefine keywords. However, you can
specify the text to be substituted for keywords before compilation by using C/C+
+ preprocessor directives.

2.Identifiers: Identifiers are used as the general terminology for the naming of
variables, functions and arrays. These are user-defined names consisting of an
arbitrarily long sequence of letters and digits with either a letter or the
underscore(_) as a first character. Identifier names must differ in spelling and
case from any keywords. You cannot use keywords as identifiers; they are
reserved for special use. Once declared, you can use the identifier in later
program statements to refer to the associated value. A special kind of identifier,
called a statement label, can be used in goto statements.
There are certain rules that should be followed while naming c identifiers:

 They must begin with a letter or underscore(_).

 They must consist of only letters, digits, or underscore. No other special
character is allowed.
 It should not be a keyword.
 It must not contain white space.
 It should be up to 31 characters long as only the first 31 characters are
significant.
 main: method name.
 a: variable name.

3.Constants: Constants are also like normal variables. But, the only difference is,
their values cannot be modified by the program once they are defined. Constants
refer to fixed values. They are also called literals.
Constants may belong to any of the data type
Syntax:
const data_type variable_name; (or) const data_type *variable_name;

Types of Constants:

1. Integer constants – Example: 0, 1, 1218, 12482

2. Real or Floating-point constants – Example: 0.0, 1203.03, 30486.184
3. Octal & Hexadecimal constants – Example: octal: (013 ) 8 =
(11)10, Hexadecimal: (013)16 = (19)10
4. Character constants -Example: ‘a’, ‘A’, ‘z’
5. String constants -Example: “Welcome to C++”

4.Strings: Strings are nothing but an array of characters ended with a null
character (‘\0’). This null character indicates the end of the string. Strings are
always enclosed in double-quotes. Whereas, a character is enclosed in single
quotes in C and C++.Declarations for String:

 char string[20] = {‘w’, ’e’, ‘l’, ‘c’, ‘o’, ‘m’, ‘e’, ‘\0’};
 char string[20] = “welcome”;
 char string [] = “welcome”;
 when we declare char as “string[20]”, 20 bytes of memory space is allocated
for holding the string value.
 When we declare char as “string[]”, memory space will be allocated as per the
requirement during the execution of the program.

5.Special Symbols: The following special symbols are used in C having some
special meaning and thus, cannot be used for some other purpose.[] () {}, ; * = #

 Brackets[]: Opening and closing brackets are used as array element reference.
These indicate single and multidimensional subscripts.
 Parentheses(): These special symbols are used to indicate function calls and
function parameters.
 Braces{}: These opening and ending curly braces mark the start and end of a
block of code containing more than one executable statement.
 Comma (, ): It is used to separate more than one statements like for separating
parameters in function calls.
 Colon(:): It is an operator that essentially invokes something called an
initialization list.
 Semicolon(;): It is known as a statement terminator. It indicates the end of
one logical entity. That’s why each individual statement must be ended with a
semicolon.
 Asterisk (*): It is used to create a pointer variable and for the multiplication
of variables.
 Assignment operator(=): It is used to assign values and for the logical
operation validation.
 Pre-processor (#): The preprocessor is a macro processor that is used
automatically by the compiler to transform your program before actual
compilation.

6.Operators: Operators are symbols that trigger an action when applied to C++
variables and other objects. The data items on which operators act upon are called
operands.
Depending on the number of operands that an operator can act upon, operators
can be classified as follows:
 Unary Operators: Those operators that require only a single operand to act
upon are known as unary operators.For Example increment and decrement
operators
 Binary Operators: Those operators that require two operands to act upon are
called binary operators. Binary operators are classified into :
1. Arithmetic operators
2. Relational Operators
3. Logical Operators
4. Assignment Operators
5. Conditional Operators
6. Bitwise Operators

Operators are the foundation of any programming language. We can define

operators as symbols that help us to perform specific mathematical and logical
computations on operands. In other words, we can say that an operator operates
the operands. For example, ‘+’ is an operator used for addition, as shown below:
c = a + b;
Here, ‘+’ is the operator known as the addition operator and ‘a’ and ‘b’ are
operands. The addition operator tells the compiler to add both of the operands ‘a’
and ‘b’.
The functionality of the C++ programming language is incomplete without the
use of operators.
C++ has many built-in operators and can be classified into 6 types:
1. Arithmetic Operators
2. Relational Operators
3. Logical Operators
4. Bitwise Operators
5. Assignment Operators
6. Other Operators
The above operators have been discussed in detail:
1. Arithmetic Operators:
These operators are used to perform arithmetic/mathematical operations on
operands. Examples: (+, -, *, /, %,++,–). Arithmetic operators are of two types:
a) Unary Operators: Operators that operate or work with a single operand are
unary operators. For example: Increment(++) and Decrement(–) Operators
int val = 5;
++val; // 6
b) Binary Operators: Operators that operate or work with two operands are
binary operators. For example: Addition(+), Subtraction(-), multiplication(*),
Division(/) operators
int a = 7;
int b = 2;
cout<<a+b; // 9
2. Relational Operators:
These are used for the comparison of the values of two operands. For example,
checking if one operand is equal to the other operand or not, an operand is greater
than the other operand or not, etc. Some of the relational operators are (==, >= ,
<= )
int a = 3;
int b = 5;
a < b;
// operator to check if a is smaller than b
3. Logical Operators:
Logical Operators are used to combining two or more conditions/constraints or to
complement the evaluation of the original condition in consideration. The result
of the operation of a logical operator is a Boolean value either true or false.
For example, the logical AND represented as ‘&&’ operator in C or C+
+ returns true when both the conditions under consideration are satisfied.
Otherwise, it returns false. Therefore, a && b returns true when both a and b are
true (i.e. non-zero)
(4 != 5) && (4 < 5); // true
4. Bitwise Operators:
The Bitwise operators are used to perform bit-level operations on the operands.
The operators are first converted to bit-level and then the calculation is performed
on the operands. The mathematical operations such as addition, subtraction,
multiplication, etc. can be performed at bit-level for faster processing. For
example, the bitwise AND represented as & operator in C or C++ takes two
numbers as operands and does AND on every bit of two numbers. The result of
AND is 1 only if both bits are 1.
int a = 5, b = 9; // a = 5(00000101), b = 9(00001001)
cout << (a ^ b); // 00001100
cout <<(~a); // 11111010
5. Assignment Operators:
Assignment operators are used to assigning value to a variable. The left side
operand of the assignment operator is a variable and the right side operand of the
assignment operator is a value. The value on the right side must be of the same
data type as the variable on the left side otherwise the compiler will raise an
error.
Different types of assignment operators are shown below:
a. “=”: This is the simplest assignment operator. This operator is used to assign
the value on the right to the variable on the left.
For example:
a = 10;
b = 20;
ch = 'y';
b. “+=”: This operator is combination of ‘+’ and ‘=’ operators. This operator first
adds the current value of the variable on left to the value on the right and then
assigns the result to the variable on the left.
For example:
(a += b) can be written as (a = a + b)
If initially value stored in a is 5. Then (a += 6) = 11.
c. “-=”: This operator is a combination of ‘-‘ and ‘=’ operators. This operator first
subtracts the value on the right from the current value of the variable on left and
then assigns the result to the variable on the left.
For example:
(a -= b) can be written as (a = a - b)
If initially value stored in a is 8. Then (a -= 6) = 2.
d. “*=”: This operator is a combination of ‘*’ and ‘=’ operators. This operator
first multiplies the current value of the variable on left to the value on the right
and then assigns the result to the variable on the left.
For example:
(a *= b) can be written as (a = a * b)
If initially, the value stored in a is 5. Then (a *= 6) = 30.
e. “/=”: This operator is a combination of ‘/’ and ‘=’ operators. This operator first
divides the current value of the variable on left by the value on the right and then
assigns the result to the variable on the left.
For example:
(a /= b) can be written as (a = a / b)
If initially, the value stored in a is 6. Then (a /= 2) = 3.
6. Other Operators:
Apart from the above operators, there are some other operators available in C or
C++ used to perform some specific tasks. Some of them are discussed here:
a. sizeof operator:
 sizeof is much used in the C++ programming language.
 It is a compile-time unary operator which can be used to compute the size of
its operand.

b. Comma Operator:
 The comma operator (represented by the token) is a binary operator that
evaluates its first operand and discards the result, it then evaluates the second
operand and returns this value (and type).
 The comma operator has the lowest precedence of any C operator.
 Comma acts as both operator and separator. (See this article for reference)
c. Conditional Operator :
 The conditional operator is of the form Expression1? Expression2:
Expression3.
 Here, Expression1 is the condition to be evaluated. If the condition(Expression1)
is True then we will execute and return the result of Expression2 otherwise if the
condition(Expression1) is false then we will execute and return the result of
Expression3.
 We may replace the use of if..else statements with conditional operators.
Increment and Decrement operator:
In C++, Increment operators are used to increase the value of a variable by 1.
This operator is represented by the ++ symbol. The increment operator can either
increase the value of the variable by 1 before assigning it to the variable or can
increase the value of the variable by 1 after assigning the variable. Thus it can be
classified into two types:
 Pre-Increment Operator
 Post-Increment Operator
1) Pre-increment operator: A pre-increment operator is used to increment the
value of a variable before using it in an expression. In the Pre-Increment, value is
first incremented and then used inside the expression.
Syntax:
a = ++x;

Here, if the value of ‘x’ is 10 then the value of ‘a’ will be 11 because the value of
‘x’ gets modified before using it in the expression.

// CPP program to demonstrate pre increment operator

#include <iostream.h>
#include <conio.h>
void main()
{
int x = 10, a;
a = ++x;
cout << "Pre Increment Operation";
// Value of a will change
cout << "\na = " << a;
 // Value of x change before execution of a=++x;
cout << "\nx = " << x;
getch( );
}

Output
Pre Increment Operation
a = 11
x = 11
2) Post-increment operator: A post-increment operator is used to increment the
value of the variable after executing the expression completely in which post-
increment is used. In the Post-Increment, value is first used in an expression and
then incremented.
Syntax:
a = x++;

Here, suppose the value of ‘x’ is 10 then the value of variable ‘a’ will be 10
because the old value of ‘x’ is used.

// CPP program to demonstrate post increment operator

#include <iostream.h>
#include<conio.h>
void main()
{
int x = 10, a;
a = x++;
cout << "Post Increment Operation";
 // Value of a will not change
cout << "\na = " << a;

// Value of x change after execution of a=x++;

cout << "\nx = " << x;
getch( );
}

Output
Post Increment Operation
a = 10
x = 11

Scope Resolution Operator

In C++, scope resolution operator is :: The :: (scope resolution) operator is used
to qualify hidden names so that you can still use them.

The scope resolution operator is used to reference the global variable or member
function that is out of scope. Therefore, we use the scope resolution operator to
access the hidden variable or function of a program. The operator is represented as
the double colon (::) symbol.

For example, when the global and local variable or function has the same name in
a program, and when we call the variable, by default it only accesses the inner or
local variable without calling the global variable. In this way, it hides the global
variable or function. To overcome this situation, we use the scope resolution
operator to fetch a program's hidden variable or function.
#include <iostream.h>
#include<conio.h>
// declare global variable
int num = 50;
void main ()
{
// declare local variable
int num = 100;

// print the value of the variables

cout << " The value of the local variable num: " << num;

// use scope resolution operator (::) to access the global variable

cout << "\n The value of the global variable num: " << ::num;
getch( );
}

Output

The value of the local variable num: 100

The value of the global variable num: 50
// C++ program to show that we can access a global variable
// using scope resolution operator :: when there is a local
// variable with same name
#include<iostream.h>
#include<conio.h>

int x; // Global x

void main()
{
int x = 10; // Local x
cout << "Value of global x is " << ::x;
cout << "\nValue of local x is " << x;
getch( );
}

Output:
Value of global x is 0
Value of local x is 10

#include<iostream.h>
#include<conio.h>
void main( )
{
int m = 20;
{
int k = m;
int m = 30;
cout<<”We are in inner block\n”;
cout<<”k=”<<k<<”\n”;
cout<<”Local m =”<<m<<”\n”;
cout<<”Global m = “<< : :m<<”\n”;
}
getch( );
}

Output:
We are in inner block
k = 20
Local m = 30
Global m = 10

Memory Management Operators( new , delete)

C++ allows us to allocate the memory of a variable or an array in run time. This is
known as dynamic memory allocation.

In C++, we need to deallocate the dynamically allocated memory manually after

we have no use for the variable.

We can allocate and then deallocate memory dynamically using

the new and delete operators respectively.

new operator

The new operator denotes a request for memory allocation on the Free Store. If
sufficient memory is available, new operator initializes the memory and returns
the address of the newly allocated and initialized memory to the pointer variable.

 Syntax to use new operator: To allocate memory of any data type, the syntax
is:

pointer-variable = new data-type;

 Here, pointer-variable is the pointer of type data-type. Data-type could be any

built-in data type including array or any user defined data types including
structure and class.

 Example:

// Pointer initialized with NULL

// Then request memory for the variable
int *p = NULL;
p = new int;
OR

// Combine declaration of pointer

// and their assignment
int *p = new int;

delete operator

Since it is programmer’s responsibility to deallocate dynamically allocated

memory, programmers are provided delete operator by C++ language.
Syntax:

// Release memory pointed by pointer-variable

delete pointer-variable;
Here, pointer-variable is the pointer that points to the data object created by new.
Examples:

delete p;
delete q;

#include <iostream.h>
#include<conio.h>
void main() {
// declare an int pointer
int* pointInt;

// declare a float pointer

float* pointFloat;

// dynamically allocate memory

pointInt = new int;
pointFloat = new float;

// assigning value to the memory

*pointInt = 45;
*pointFloat = 45.45f;

cout << *pointInt << endl;

cout << *pointFloat << endl;

// deallocate the memory

delete pointInt;
delete pointFloat;

getch();
}

Output

45
45.45

In this program, we dynamically allocated memory to two variables

of int and float types. After assigning values to them and printing them, we
finally deallocate the memories using the code

delete pointInt;
delete pointFloat;

Note: Dynamic memory allocation can make memory management more

efficient.
Type cast operator:

Typecasting is making a variable of one type, such as an int, act like another type,
a char, for one single operation. To typecast something, simply put the type of
variable you want the actual variable to act as inside parentheses in front of the
actual variable. (char) a will make 'a' function as a char.

#include <iostream.h>
#include<conio.h>

void main( )
{
double a = 21.09399;
float b = 10.20;
int c ;

c = (int) a;
cout << "Line 1 - Value of (int)a is :" << c << endl ;

c = (int) b;
cout << "Line 2 - Value of (int)b is :" << c << endl ;

getch( );
}
When the above code is compiled and executed, it produces the following result −
Line 1 - Value of (int)a is :21
Line 2 - Value of (int)b is :10

cout<< (char)65 <<"\n";

// The (char) is a typecast, telling the computer to interpret the 65 as a
// character, not as a number. It is going to give the character output of
// the equivalent of the number 65 (It should be the letter A for ASCII).
 (int)3.14 //Converts 3.14 to an int to give 3
(long) 3.14 //Converts 3.14 to a long to give 3L
(double) 2 // Converts 2 to a double to give 2.0
(char) 122 // Converts 122 to a char whose code is 122

ASCII ASCI ASCII

Charact Character
code Character I code
er
code
! exclamat " double
33 34 35 # number sign
ion point quotation
$ dollar % percent
36 37 38 & ampersand
sign sign
( left
' apostrop
39 40 parenthe 41 ) right parenthesis
he
sis
+ plus
42 * asterisk 43 44 , comma
sign
45 - hyphen 46 . period 47 / slash
48 0 49 1 50 2
51 3 52 4 53 5
54 6 55 7 56 8
57 9 58 : colon 59 ; semicolon
< less-than = equals
60 61 62 > greater-than sign
sign sign
? question
63 64 @ at sign 65 A uppercase a
mark
B uppercas C upperc
66 67 68 D uppercase d
eb ase c
E uppercas F upperc
69 70 71 G uppercase g
ee ase f
H uppercas I upperc
72 73 74 J uppercase j
eh ase i
K uppercas L upperc
75 76 77 M uppercase m
ek ase l
N uppercas O upperc
78 79 80 P uppercase p
en ase o
Q uppercas R upperc
81 82 83 S uppercase s
eq ase r
84 T uppercas 85 U upperc 86 V uppercase v
ASCII ASCI ASCII
Charact Character
code Character I code
er
code
et ase u
W uppercas X upperc
87 88 89 Y uppercase y
ew ase x
[ left
Z uppercas
90 91 square 92 \ backslash
ez
bracket
] right
93 square 94 ^ caret 95 _ underscore
bracket
` grave a lowerca
96 97 98 b lowercase b
accent se a
c lowercas d lowerca
99 100 101 e lowercase e
ec se d
f lowercas g lowerca
102 103 104 h lowercase h
ef se g
i lowercas j lowerca
105 106 107 k lowercase k
ei se j
l lowercas m lowerca
108 109 110 n lowercase n
el se m
o lowercas p lowerca
111 112 113 q lowercase q
eo se p
r lowercas s lowerca
114 115 116 t lowercase t
er se s
u lowercas v lowerca
117 118 119 w lowercase w
eu se v
x lowercas y lowerca
120 121 122 z lowercase z
ex se y
{ left curly | vertical
123 124 125 } right curly brace
brace bar
126 ~ tilde
Table 1. ASCII characters from 33 to 126
 Type Conversion in C++

Type conversion is the process that converts the predefined data type of one
variable into an appropriate data type. The main idea behind type conversion is to
convert two different data type variables into a single data type to solve
mathematical and logical expressions easily without any data loss.

For example, we are adding two numbers, where one variable is of int type and
another of float type; we need to convert or typecast the int variable into a float to
make them both float data types to add them.

Type conversion can be done in two ways in C++, one is implicit type
conversion, and the second is explicit type conversion. Those conversions are
done by the compiler itself, called the implicit type or automatic type conversion.
The conversion, which is done by the user or requires user interferences called the
explicit or user define type conversion. Let's discuss the implicit and explicit type
conversion in C++.

Implicit Type Conversion

The implicit type conversion is the type of conversion done automatically by the
compiler without any human effort. It means an implicit conversion automatically
converts one data type into another type based on some predefined rules of the C+
+ compiler. Hence, it is also known as the automatic type conversion.

For example:

1. int x = 20;
2. short int y = 5;
3. int z = x + y;

In the above example, there are two different data type variables, x, and y, where x
is an int type, and the y is of short int data type. And the resultant variable z is also
an integer type that stores x and y variables. But the C++ compiler automatically
converts the lower rank data type (short int) value into higher type (int) before
resulting the sum of two numbers. Thus, it avoids the data loss, overflow, or sign
loss in implicit type conversion of C++.
 Order of the typecast in implicit conversion
The following is the correct order of data types from lower rank to higher
rank:

1. bool -> char -> short int -> int -> unsigned int -> long int -> unsigned lo
ng int -> long long int -> float -> double -> long double

#include <iostream.h>
#include<conio.h>
void main()
{
int num; // declare int type variable
double num2 = 15.25; // declare and assign the double variable

// use implicit type conversion to assign a double value to int variable

num = num2;
cout << " The value of the int variable is: " << num << endl;
cout << " The value of the double variable is: " << num2 << endl;
getch( );
}

Output

The value of the int variable is: 15

The value of the double variable is: 15.25

In the above program, we have declared num as an integer type and num2 as the
double data type variable and then assigned num2 as 15.25. After this, we assign
num2 value to num variable using the assignment operator. So, a C++ compiler
automatically converts the double data value to the integer type before assigning it
to the num variable and print the truncate value as 15.
Explicit type conversion
Conversions that require user intervention to change the data type of one variable
to another, is called the explicit type conversion. In other words, an explicit
conversion allows the programmer to manually changes or typecasts the data type
from one variable to another type. Hence, it is also known as typecasting.
Generally, we force the explicit type conversion to convert data from one type to
another because it does not follow the implicit conversion rule.

The explicit type conversion is divided into two ways:

1. Explicit conversion using the cast operator

2. Explicit conversion using the assignment operator

Program to convert one data type into another using the assignment
operator
Let's consider an example to convert the data type of one variable into another
using the assignment operator in the C++ program.

#include <iostream.h>
#include<conio.h>
void main ()
{
// declare a float variable
float num2;
// initialize an int variable
int num1 = 25;

// convert data type from int to float

num2 = (float) num1;
cout << " The value of int num1 is: " << num1 << endl;
cout << " The value of float num2 is: " << num2 << endl;
getch ( );
}

Output

The value of int num1 is: 25

The value of float num2 is: 25.0

Comments in C++

In C/C++ there are two types of comments :

1. Single line comment

2. Multi-line comment
Single line Comment
Represented as // double forward slash
It is used to denote a single line comment. It applies comment to a single line
only. It is referred to as C++-style comments as it is originally part of C++
programming.
for example:

// single line comment

Example: This example goes same for C and C++ as the style of commenting
remains same for both the language.

Multi-line comment
Represented as /* any_text */ start with forward slash and asterisk (/*)
and end with asterisk and forward slash (*/).
It is used to denote multi-line comment. It can apply comment to more
than a single line.

/*Comment starts
continues
continues
.
.
.
Comment ends*/
Example: This example goes same for C and C++ as the style of
commenting remains same for both the language.