 C++ BASICS

 Static function to change the type of variable

aCharVar = static_cast<char>(anIntVar)

Here an int type variable is converted to char type

 sizeof() operator is used to determine the size of various variable types available in C++.
It gives the size in terms of bytes.
For e.g., cout<<sizeof(int) will give 4 as the answer.
 Global and static variables have default value 0.
 Static variables are initialised only once.
 Keyword auto is used while declaring or initialising the data types if the if are not sure
about its data type.
For e.g., auto a=10;
Will automatically assign ‘a’ with ‘int’ data type.
 In order to get the data type of a given variable we can use the function
typeid(variable).name(). This function will give output as the type of variable passed to it.
 For using the above function we have to include pre processor directive
#include<typeinfo> into our programm.
 For e.g., cout<<typeid(a).name;
 Type conversion widening rule:
Bool ->short int -> int -> unsigned int -> long -> unsigned long -> long long -> float ->
double -> long double
 One data type can be converted to another data type by using the following ways;
int x;
double(x); will convert x to a type of double.
 Flags in C++
There are different types of flags of C++ which can be used for output manipulation.
For e.g., boolalpha flag. It is used to display the result of bool variable in true or false
form instead of conventional form of 1 or 0.

Sample program
#include<iostream>
using namespace std;
int main()
{
bool a=true;
cout<<a<<endl;
cout<<boolalpha<<a;
return 0;
}
To reset the flag use noboolalpha .
Other Flags-
1. hex- use to give output in hexadecimal form.
2. oct- use to give output in octal form.
3. dec- use to give output in decimal form.
4. showbase- it is used to display base of the output result i.e., in case of octal it
shows 0 and in case of hexadecimal numbers it shows 0x. (noshowbase)
5. showpos – it shows positive sign before the positive numbers in output.
(noshowpos)
 6. uppercase- it gives output in the form of Uppercase. (nouppercase)
7. setw(n) – it is used to limit the output in n spaces. It needs to be used every time
whenever the width needs to be set.
8. setfill(*) – this will give output of the passed character in the output.
9. left – it makes the output left aligned.
10. right – makes the output right aligned
11. showpoint – it shows the trailing zero in output even if they are not required
double x = 12;
cout<<showpoint<<x;
this will give 12.0000 as output. Only 4 zeros are shown because the default
precision of floating-point variable is 6 digits. (noshowpoint)
12. setprecision(n) – it sets the precision of output to desired value given to n.
 Floating Point (Default Printing Format)
1. No trailing zero.
double x= 1.2300;
cout<<x<<endl;
This will give output as 1.23. No trailing zeros
2. Precision means total digits (excluding the digits after e)
double x = 1567.56732;
cout<<x<<endl;
This will give 1567.57 as output. The initialised value is rounded of to 6 digits.
3. Default precision value is 6.
4. When value before decimal point does not fit in 6 digits, power format is used.
i.e., 1234568.3 is printed as 1.23457e+06. This is known as Power Format.

 Fixed and Scientific Format in C++

1. Fixed format
o Here the precision after the decimal point is set to 6.
i.e., double x=1.23;
cout <<fixed<< x <<endl;
it will show output as 1.230000, because the default precision in fixed format is 6
after the decimal point.
o Here no power format is used whatever may be the case is.
int x =1122456.453;
cout<<fixed<<x;
This will give output as 1122456.453000.

2. Scientific Format
o Here the precision after the decimal point is set to 6.
i.e., double x= 1.23;
cout<<scientific<<x;
It will show output as 1.230000e+00
o double y = 1122456.453;
cout<<scientific<<y;
It will show output as 1.122456e+06
 Printing Hello World without using semicolon

#include<iostream>
using namespace std;
int main()
{
if(cout<<"Hello World")
{
}
return 0;
}

 Printing Hello World in C++ with empty or blank main

 wchar_t

1. it is similar to char type, except that wide char take up twice the space and
can take much larger values as result
2. Type for wide char is wchar_t
3. It occupies 4 bytes of space
4. include <iostream>
5. using namespace std;
6.   
7. int main()
8. {
9.     wchar_t w  = L'A';
10.     cout << "Wide character value:: " << w <<
endl ;
11.     cout << "Size of the wide char is:: " <<
sizeof(w);
12.     return 0;
13. }

4. L is the prefix for wide character literals and wide character strings literals
which tells compiler that the char or string is of type wide-char.

5. Following are the different types of functions associated with wchar

 wcslen() – it is used to find the length of wide string.
 wcscpy() – it is used to copy one wide char string to other
 wcscat()- it is used to for concatenation of one string to other.
 wcstok()- it is used to compare one string to other. It returns either one or
zero
  Use header file #include<cwchar> for using above function
Header files available in C++ for Input/Output operations are: 
iostream: iostream stands for standard input-output stream. This header file contains definitions of
objects like cin, cout, cerr, etc.
iomanip: iomanip stands for input-output manipulators. The methods declared in these files are used
for manipulating streams. This file contains definitions of setw, setprecision, etc.
fstream: This header file mainly describes the file stream. This header file is used to handle the data
being read from a file as input or data being written into the file as output.

Operator Precedence Chart

The below table describes the precedence order and associativity of
operators in C / C++. The precedence of the operator decreases from top to
bottom. 
 

Precedence Operator Description Associativity

() Parentheses (function call) left-to-right

[] Brackets (array subscript)

. Member selection via object name

-> Member selection via a pointer

1 ++/– Postfix increment/decrement

2 ++/– Prefix increment/decrement right-to-left

+/- Unary plus/minus

!~ Logical negation/bitwise complement

Cast (convert value to temporary value of

(type) type)

* Dereference

& Address (of operand)

Precedence Operator Description Associativity

Determine size in bytes on this

sizeof implementation

3 *, / , % Multiplication/division/modulus left-to-right

4 +/- Addition/subtraction left-to-right

5 << , >> Bitwise shift left, Bitwise shift right left-to-right

< , <= Relational less than/less than or equal to left-to-right

Relational greater than/greater than or

6 > , >= equal to left-to-right

7 == , != Relational is equal to/is not equal to left-to-right

8 & Bitwise AND left-to-right

9 ^ Bitwise exclusive OR left-to-right

10 | Bitwise inclusive OR left-to-right

11 && Logical AND left-to-right

12 || Logical OR left-to-right

13 ?: Ternary conditional right-to-left

14 = Assignment right-to-left

+= , -= Addition/subtraction assignment

*= , /= Multiplication/division assignment

%= , &= Modulus/bitwise AND assignment

^= , |= Bitwise exclusive/inclusive OR assignment

Precedence Operator Description Associativity

<>= Bitwise shift left/right assignment

15 , expression separator left-to-right

 LOOPS AND DECISIONS

 Getche() is used to get a character from the user. To use the getche() function we need to
incorporate #include<conio.h> header file
 Setw() is used to fit characters or numbers within a given space. To use setw() we need to
incorporate #include<iomanip> header file
 Exit(0) is used to end the program when no further calculations are required. To use exit(0)
we need to use #include<process.h>
 Using switch in program
Switch(case)
Case:
break;
case:
break;

default:
and so on…..

 Conditional operator
Min= (alpha<beta) ? alpha : beta
This is used to assess the given condition and assign the result accordingly

 STRUCTURES

 Structure is collection of simple variables which can be integers, float and characters.
 Data items in a structure is called as members
 Defining a structure

Struct part
{
int modelnumber;
Int partnumber;
Float cost;
};
 int main()
{
part part1;
}

 The structure definition serves only as a blueprint for the creation of variables of type
part. It does not itself create any structure variables; that is, it does not set aside any space in
memory or even name any variables. This is unlike the definition of a simple variable, which
does set aside memory

 The members of a structure are accessed using dot operator

E.g. part1.modelnumber;

 Structures can be initialised in this way also

part part1 = { 6244,373,217.55}

 A structure within a structure can be formed. Infinite number of structure can be incorporated
within a given structure.

Int main()
{
Struct Distance
{
int feet;
float inches;
};

Struct Room
{
Distance length;
Distance breadth;
};

Room dining = { {13, 6.5}, {10, 0.0} };

 Structure should be declared before the main program and while nesting two structures the
inner structure should be declared first.

 FUNCTIONS
1. Basic Information

void starline();
  Void indicates that the return type of function which is null. This function will not return any
value
 Empty brackets indicate that this function will have no arguments.
 The function should be declared before it is called in any part of the program.
 The declaration tells the compiler that at some point in time this function will come up.

Starline();

 While calling a function its return type is not mentioned.

 The function call must be terminated by a semicolon.

void starline()
{
for(int n=0; n<=45; n++)
cout<<”*”;
cout<<endl;
}
Above statements are called as function definition. The definition contains the actual code for the
function.
Function definition is not terminated by semicolon.
2. Passing Arguments to a Function

 void repchar(char, int)

In the above function two arguments are passed to it i.e., char and int type.
This is known as passing by value wherein actual values will be passed to function.

 void engldisp(Distance)
Here Distance which is a structure is passed as an argument

When values are passed as an argument then the function creates a copy of it.
For e.g.
Void engldisp(Distance dd)
{
cout << dd.feet << “\’-” << dd.inches << “\””;

}
When this function is called from main with an argument of structure type then that structure
Will be copied to structure dd.
 3. Returning values from a function

 The function return type is defined in the declaration itself

For e.g.

float lbstokg(float)
Here the function will return a float value.
float lbstokg(float pounds)

{
float kilograms = 0.453592 * pounds;
return kilograms;

 Returning a structure from a function

Following line denotes a function declaration which will return a structure type value
Distance addengl(Distance, Distance);

Distance addengl( Distance dd1, Distance dd2 )

{
Distance dd3;
dd3.inches = dd1.inches + dd2.inches; //add the inches
dd3.feet = 0;
if(dd3.inches >= 12.0)
dd3.inches -= 12.0; //by 12.0 and
dd3.feet++;
dd3.feet += dd1.feet + dd2.feet;
return dd3;
}

 Reference arguments
A reference provides an alias—a different name—for a variable. One of the most important
uses for references is in passing arguments to functions
Passing arguments by reference uses a different mechanism. Instead of a value being passed
to the function, a reference to the original variable, in the calling program, is passed. (It’s
actually the memory address of the variable that is passed, although you don’t need to know
this.) An important advantage of passing by reference is that the function can access the
 actual variables in the calling program. Among other benefits, this provides a mechanism for
passing more than one value from the function back to the calling program

For e.g.

void intfrac(float, float&, float&); Function declaration

intfrac(number, intpart, fracpart); Function call

void intfrac(float n, float& intp, float& fracp) Function defintion

{
long temp = static_cast<long>(n);
intp = static_cast<float>(temp);
fracp = n - intp;
}

In the above example the changes made in intp and fracp will directly reflect in intpart and
fracpart
In the declaration float& defines the type of argument and & denotes its address in the
memory
In the definition an alias name is created i.e. intp and fracp which follow the float&

 Passing reference arguments

void scale (Distance&, float); Function declaration

scale (d1, 0.5); Function call

void scale (Distance& dd, float factor)
{
float inches = (dd.feet*12 + dd.inches) * factor; Function definition
dd.feet = static_cast<int>(inches / 12);
dd.inches = inches - dd.feet * 12;
}

4. Different kinds of arguments

Functions with the same name but different number and types of arguments can be used and
the function will still work properly

void engldisp( Distance ); Declarations

void engldisp( float );

Above examples shows that how function with same name but different arguments can be
used
5. Recursion
Recursion occurs when a function calls itself
Take a look at this example of finding out factorial of a given number.

#include <iostream>
using namespace std;
unsigned long factfunc(unsigned long);
int main()
{
int n;
unsigned long fact;
cout << “Enter an integer: “;
cin >> n;
fact = factfunc(n);
cout << “Factorial of “ << n << “ is “ << fact << endl;
return 0;
}

unsigned long factfunc(unsigned long n)

{
if(n > 1)
return n * factfunc(n-1); //self call
else
return 1;
}

In the above example in function definition the function calls itself. This recursion will occurs
until the value of n becomes 1.

6. Inline function
We mentioned that functions save memory space because all the calls to the function cause
the same code to be executed; the function body need not be duplicated in memory. When
the compiler sees a function call, it normally generates a jump to the function. At the end of
the function it jumps back to the instruction following the call,

While this sequence of events may save memory space, it takes some extra time. There must
be an instruction for the jump to the function (actually the assembly-language instruction
CALL or something similar), instructions for saving registers, instructions for pushing
arguments onto the stack in the calling program and removing them from the stack in the
function (if there are arguments), instructions for restoring registers, and an instruction to
return to the calling program. The return value (if any) must also be dealt with. All these
instructions slow down the program.
To save execution time in short functions, you may elect to put the code in the function body
directly inline with the code in the calling program. That is, each time there’s a function call
in the source file, the actual code from the function is inserted, instead of a jump to the
function.

Long sections of repeated code are generally better off as normal functions: The savings in
memory space is worth the comparatively small sacrifice in execution speed. But making a
short section of code into an ordinary function may result in little savings in memory space,
while imposing just as much time penalty as a larger function. In fact, if a function is very
 short, the instructions necessary to call it may take up as much space as the instructions within
the function body, so that there is not only a time penalty but a space penalty as well.
In such cases you could simply repeat the necessary code in your program, inserting the same
group of statements wherever it was needed. The trouble with repeatedly inserting the same
code is that you lose the benefits of program organization and clarity that come with using
functions. The program may run faster and take less space, but the listing is longer and more
complex.
The solution to this quandary is the inline function. This kind of function is written like a
normal function in the source file but compiles into inline code instead of into a function. The
source file remains well organized and easy to read, since the function is shown as a separate
entity. However, when the program is compiled, the function body is actually inserted into the
program wherever a function call occurs.

inline float lbstokg(float pounds)

{
return 0.453592 * pounds;
}

Just add inline in front of the program to make it inline

7. Default arguments

While declaring, functions can be provided with default arguments so that in case if we miss
trailing argument, it will be replaced by default argument

void repchar(char=’*’, int=45);

int main()
{
repchar();
repchar(‘=’);
repchar(‘+’, 30);
return 0;
}
The function is declared with default arguments. Note that only trailing arguments will be
replaced by default argument i.e. only int values in above function

8. Scope and Storage class

Two different kinds of scope are important here: local and file. (We’ll see another one, class
scope, later.)
• Variables with local scope are visible only within a block.
• Variables with file scope are visible throughout a file.

A block is basically the code between an opening brace and a closing brace. Thus, a function
body is a block.
There are two storage classes: automatic and static.
• Variables with storage class automatic exist during the lifetime of the function in which
they’re defined.
• Variables with storage class static exist for the lifetime of the program.

 Local Variable

So far almost all the variables we’ve used in example programs have been defined inside the
 function in which they are used. That is, the definition occurs inside the braces that delimit
the function body:

void somefunc()
{
int somevar;
float othervar;
}
Here somevar and othervar are local variable. They exist within the somefunc() and cannot be
accessed by any other function. They are in existence as long as somefunc() is operating. As
soon as control is passed from somefunc() into another function the value of somevar and
othervar are destroyed. This type of variables has automatic storage class. It means the
variable are automatically created when function is called and gets destroyed when control is
passed to other function.

9. Global Variable

The next kind of variable is global. While local variables are defined within functions, global
variables are defined outside of any function. (They’re also defined outside of any class, as
we’ll see later.) A global variable is visible to all the functions in a file (and potentially in
other files). More precisely, it is visible to all those functions that follow the variable’s
definition in the listing. Usually, you want global variables to be visible to all functions, so
you put their declarations at the beginning of the listing. Global variables are also sometimes
called external variables, since they are defined external to any function.

#include <iostream>
using namespace std;
#include <conio.h>
char ch = ‘a’; Global variable declaration
void getachar();
void putachar();

Lifetime and Visibility

Global variables have storage class static, which means they exist for the life of the program.
Memory space is set aside for them when the program begins, and continues to exist until the
program ends. You don’t need to use the keyword static when declaring global variables;
they are given this storage class automatically

As we noted, global variables are visible in the file in which they are defined, starting at the
point where they are defined. If ch were defined following main () but before getachar(), it
would be visible in getachar() and putachar(), but not in main().

 Static Local Variables

Static local variables are useful only when we want to retain the value of variable defined
within a function
Static local variables are used when it’s necessary for a function to remember a value when it
is not being executed; that is, between calls to the function. In the next example, a function,
getavg(), calculates a running average. It remembers the total of the numbers it has averaged
before, and how many there were. Each time it receives a new number, sent as an argument
from the calling program, it adds this number to the total, adds 1 to a count, and returns the
new average by dividing the total by the count.
 #include <iostream>
using namespace std;
float getavg(float);
int main()
{
float data=1, avg;
while(data != 0 )
{
cout << “Enter a number: “;
cin >> data;
avg = getavg(data);
cout << “New average is “ << avg << endl;
}
return 0;
}

float getavg(float newdata)

{
static float total = 0;
static int count = 0;
count++;
total += newdata;
return total / count;
}

STATIC VARIABLES ARE INITIALISED ONLY ONCE. DOESN’T MATTER HOW

MANY TIMES THE FUNCITON IS CALLED. THE STATIC VARIABLE WITHIN A
FUNCITON IS INTIALISED ONLY ONCE

 CLASSES AND OBJECTS

1. INTRODUCTION

#include <iostream>
using namespace std;
class smallobj //define a class
{
private:
int somedata;
public:
void setdata(int d)
{ somedata = d; }
void showdata()
{ cout << “Data is “ << somedata << endl; }
};
int main()
{
smallobj s1, s2;
s1.setdata(1066);
s2.setdata(1776);
s1.showdata();
 s2.showdata();
return 0;
};

 In the above program there are one data item and two-member function. Usually, the data
items are private and can be accessed only by member function. This is done to prevent data
item to be modified by other functions.
 Body of class is delimited by braces and terminated by a semicolon
 Member function is defined like any other normal function i.e. in the beginning they mention
return type followed by function name and arguments if any.
e.g. void setdata(int d)

 Member function defined inside a class doesn’t set aside memory space as long as any object
of the class is created.
 Member function are created as inline function by default
 Objects are created by mentioning class name followed by object name
e.g., smallobj s1,s2;


2. CALLING MEMBER FUNTION

While calling member function object names must be used along with function name
E.g., s1.setdata();

Here object s1 calls the member function setdata() using dot operator. This is because the
member function always acts on a specific object

3. CONSTRUCTORS

Data items inside a class can be initialised by using a member function or by using
Constructors.
Sometimes it is very convenient if data items are initialised automatically when they are
created without requiring member function.
This is done by a special function called Constructors.

A constructor is a member function that is executed automatically whenever an object is

created.

COUNTER EXAMPLE
In this example we want the count initially be set to zero. For that we will use a constructor.

#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
class Counter
{
private:
unsigned int count;
public:
 Counter() : count(0)
{ }
void inc_count()
{ count++; }
int get_count()
{ return count; }
};
////////////////////////////////////////////////////////////////
int main()
{
Counter c1, c2;
cout << “\nc1=” << c1.get_count();
cout << “\nc2=” << c2.get_count();
c1.inc_count();
c2.inc_count();
c2.inc_count();
cout << “\nc1=” << c1.get_count();
cout << “\nc2=” << c2.get_count();
cout << endl;
return 0;
}

FOLLOWING ARE THE CHARACTERISTICS OF A CONSTUCTOR

 They have the same name as that of class

 No return type is used for constructor since they are automatically called by system
and hence doesn’t return anything
 Initialisation of data items with constructor is somewhat different
e.g., Counter (): count (0)

The initialization takes place following the member function declarator but before the
function body. It’s preceded by a colon. The value is placed in parentheses following the
member data

 If multiple members must be initialized, they’re separated by commas. The result is

the initializer list (sometimes called by other names, such as the member-
initialization list).

someClass() : m1(7), m2(33), m2(4) ← initializer list

{ }

4. OBJECTS AS FUNCTION ARGUMENTS

Objects can be directly passed to function in the form of argument

#include <iostream>
using namespace std;
class Distance //English Distance class
{
private:
int feet;
float inches;
public:
Distance() : feet(0), inches(0.0)
{ }
Distance(int ft, float in) : feet(ft), inches(in)
{ }
void getdist()
{
cout << “\nEnter feet: “; cin >> feet;
cout << “Enter inches: “; cin >> inches;
}
void showdist()
{ cout << feet << “\’-” << inches << ‘\”’; }
void add_dist(Distance, Distance );
};
//--------------------------------------------------------------
//add lengths d2 and d3
void Distance::add_dist(Distance d2, Distance d3)

{
inches = d2.inches + d3.inches;
feet = 0;
if(inches >= 12.0)
{
inches -= 12.0;
feet++;
}
feet += d2.feet + d3.feet;
}
////////////////////////////////////////////////////////////////
int main()
{
Distance dist1, dist3;
Distance dist2(11, 6.25);
dist1.getdist();
dist3.add_dist(dist1, dist2);
cout << “\ndist1 = “; dist1.showdist();
cout << “\ndist2 = “; dist2.showdist();
cout << “\ndist3 = “; dist3.showdist();
cout << endl;
return 0;
}

In the above program 2 objects has been passed directly to the member function as arguments
e.g., dist3.add_dist(dist1, dist2);
 one more thing to observe is that the member function can be defined outside the class
as shown above;
void Distance::add_dist(Distance d2, Distance d3)

above declaration of function consists of class name i.e. Distance in order to identify to which

to which class the function is associated. It is preceded by return type of the function and
followed by double colon which is know as scope resolution operator.

dist3.add_dist(dist1, dist2)
This function allows the function to access the data items of the objects provided as
arguments. Changes are directly made in the data items of the object which called the
function i.e., in this case dist3

5. STRUCTURES AND CLASSES

Private is default in classes, therefore this word is unnecessary. The classes can be defined
without using this keyword private.

struct foo
{
void func();
private:
int data1;
};
Structures can also be used like classes. The only difference is that the public is default in
structures. But it is better to use classes instead of sturctures.
6. CLASSES OBJECTS AND MEMORY

Each object has its own separate data items but all the objects in a given class uses the
same function. The member function are created and placed in the memory only once.\

7. STATIC CLASS DATA

If a data item in a class is declared as static, only one such item is created for the entire
class, no matter how many objects there are. A static data item is useful when all objects of
the same class must share a common item of information. A member variable defined as static
has characteristics similar to a normal static variable: It is visible only within the class, but its
lifetime is the entire program.

#include <iostream>
using namespace std;

class foo
 {
private:
static int count;
public:
foo()
{ count++; }
int getcount()
{ return count; }
};
int foo::count = 0;
int main()
{
foo f1, f2, f3; //create three objects
cout << “count is “ << f1.getcount() << endl;
cout << “count is “ << f2.getcount() << endl;
cout << “count is “ << f3.getcount() << endl;
return 0;

Take a look at above program in which the count is defined as a static type integer. Now this
integer is shared by all objects created in the main function because the static type of
variables is only created once.

Separate declaration and Definition

Static type variables are declared and defined differently from normal variables. Consider
above function the line static int count declares the static type variable and outside the class
the line int foo::count=0 defines the static type of variable.

Why is this two-part approach used? If static member data were defined inside the class (as it
actually, was in early versions of C++), it would violate the idea that a class definition is only
a blueprint and does not set aside any memory. Putting the definition of static member data
outside the class also serves to emphasize that the memory space for such data is allocated
only once, before the program starts to execute, and that one static member variable is
accessed by an entire class; each object does not have its own version of the variable, as it
would with ordinary member data. In this way a static member variable is more like a global
variable.

8. CONST MEMBER FUNCTION

Member function within a class can be made constant so that they should not modify any of it
class’s member data.

void conFunc() const

{alpha = 99; }
 From the above example we can see that we need to use only const abbreviation after the
function name to make it constant.

If a object is defined as constant then a constant function can only access it.

 ARRAYS AND STRINGS

1) ARRAY FUNDAMENTALS

 Arrays are used to hold items of same type.

 Items in an array are accessed by index number

#include <iostream>
using namespace std;
int main ()
{
int age [4];
for (int j=0; j<4; j++)
{
cout << “Enter an age: “;
cin >> age[j];
}
for (j=0; j<4; j++) //display 4 ages
cout << “You entered “<< age[j] << endl;
return 0;
}

Consider the above example the array is of int type. While initialising the array its size is
mentioned within the brackets. Its members are accessed by using an index in the form of
j. For e.g., first element will be age[0], second element will be age[1]…and so on.
Notice that the first array element is numbered 0

2) ARRAY INITIALISATION
Arrays can be initialised as follows:

int days_per_month[12] = { 31, 28, 31, 30, 31, 30,

 31, 31, 30, 31, 30, 31};

3) MULTIDIMENSIONAL ARRAY

double sales [DISTRICTS][MONTHS];

You can think about sales as a two-dimensional array, laid out like a checkerboard. Another
way to think about it is that sales is an array of arrays. It is an array of DISTRICTS elements,
each of which is an array of MONTHS elements.

4) FORMATTING NUMBERS

cout << setiosflags(ios::fixed) //fixed (not exponential)

<< setiosflags(ios::showpoint) //always show decimal point
<<setprecision(2)

setiosflags(ios::fixed) – This code prevents the number form getting printed in exponential format.
i.e., 3.45e3
setiosflag(ios::showpoint)- This code makes sure that decimal point is always printed.
i.e., 123.00 instead of 123
setprecision(2)- This code decides the number of integer that will appear after the decimal point.

5) PASSING ARRAY TO A FUNCTION

Arrays can be used as arguments to a function.

#include <iostream>
#include <iomanip> //for setprecision, etc.
using namespace std;
const int DISTRICTS = 4; //array dimensions
const int MONTHS = 3;
void display(double[DISTRICTS][MONTHS] );

When array is passed as an argument, its type and dimensions are written. In the above
example the array is of type double and its dimensions are expressed by DISTRICTS and
MONTHS.
It is not necessary to declare array before passing it as an argument in function declaration.
Array can be later on declared and defined in main program. Unlike structures which are
needed to declare before passing it as an argument

 Function call with array argument

display(sales);
Here only the name of the array is passed nothing else.
  PASSING A 2D ARRAY TO A FUNCTION

1) Using Pointer to a pointer

E.g.,
void twodimension(int **arr, m, n )
{
for(int j=0;j<n;j++)
{
for(int i=0; i<m; i++)
{
cout<<arr[i][j]<<endl;
}

int main()
{

arr[ ][ n]= { (1,2,3), (4,5,6), (7,8,9)}

twodimension(arr);
}

Here the 2D array is directly passed as we are using a pointer to pointer in function.

2) Using single pointer

a) void twodimension(int *arr, m, n )
{
for(int j=0;j<n;j++)
{
for(int i=0; i<m; i++)
{
cout<<arr[i][j]<<endl;
}

int main()
{

arr[ ][ n]= { (1,2,3), (4,5,6), (7,8,9)}

twodimension( (int *) arr);

}

Here the array is type casted before passing it to the function i.e., twodimension((int *) arr)
b) void twodimension((int *)arr, m, n )
{
for(int j=0;j<n;j++)
 {
for(int i=0; i<m; i++)
{
cout<<arr[i][j]<<endl;
}

int main()
{

arr[ ][ n]= { (1,2,3), (4,5,6), (7,8,9)}

twodimension( arr);
}
Here the array is type casted after it has been passed to the function i.e., void
twodimension( (int*) arr),m , n)

6) ARRAY OF STRUCTURES

#include <iostream>
using namespace std;
const int SIZE = 4;
struct part
{
int modelnumber;
int partnumber;
float cost;
};
int main()
{
int n;
part apart[SIZE];
for(n=0; n<SIZE; n++)
{
cout << endl;
cout << “Enter model number: “;
cin >> apart[n].modelnumber;
cout << “Enter part number: “;
cin >> apart[n].partnumber;
cout << “Enter cost: “;
cin >> apart[n].cost; //get cost
}
cout << endl;
for(n=0; n<SIZE; n++)
{
cout << “Model “ << apart[n].modelnumber;
cout << “ Part “ << apart[n].partnumber;
cout << “ Cost “ << apart[n].cost << endl;
}
return 0;
}
 The array of structures is defined in the statement
part apart[SIZE];

 where part denotes a data type of structure

 apart is the name of the structure
 SIZE is the size of the array.

ACCESSING A DATA ITEM

Data item in an array of type structure can be accessed as follow:
apart[j].modelnumber;
apart[j].partnumber;
apart[j].cost;

7) ARRAY AS CLASS MEMBER DATA

#include <iostream>
using namespace std;
////////////////////////////////////////////////////////////////
class Stack
{
private:
enum {MAX = 10};
int st[MAX];
int top;
public:
Stack()
{ top = 0; }
void push(int var)
{ st[++top] = var; }
int pop()
{ return st[top--]; }
};
int main()
{
Stack s1;
s1.push(11);
s1.push(22);
cout << “1: “ << s1.pop() << endl; //22
cout << “2: “ << s1.pop() << endl; //11
s1.push(33);
s1.push(44);
s1.push(55);
s1.push(66);
cout << “3: “ << s1.pop() << endl; //66
cout << “4: “ << s1.pop() << endl; //55
cout << “5: “ << s1.pop() << endl; //44
 cout << “6: “ << s1.pop() << endl; //33
return 0;
}

Here unlike in structures the array is defined in class definition.

int st[MAX];

But the array can also be defined in the main program also.

This definition of MAX is unusual. In keeping with the philosophy of encapsulation, it’s
preferable to define constants that will be used entirely within a class, as MAX is here, within
the class. Thus the use of global const variables for this purpose is nonoptimal. Standard C++
mandates that we should be able to declare MAX within the class as
static const int MAX = 10;
This means that MAX is constant and applies to all objects in the class. Unfortunately, some
compilers, including the current version of Microsoft Visual C++, do not allow this newly
approved construction.

8) GENERATING RANDOM VARIABLES

We can generate random numbers by using #include<cstdlib> header file.

Following function are used:

srand(time(NULL));
rand()

rand ()
The rand() function is used in C/C++ to generate random numbers in the range [0,
RAND_MAX). 
Note: If random numbers are generated with rand() without first calling srand(), your
program will create the same sequence of numbers each time it runs.

srand()
The srand() function sets the starting point for producing a series of pseudo-random
integers. If srand() is not called, the rand() seed is set as if srand(1) were called at program
start. Any other value for seed sets the generator to a different starting point .

Note: The pseudo-random number generator should only be seeded once, before any calls
to rand(), and the start of the program. It should not be repeatedly seeded, or reseeded every
time you wish to generate a new batch of pseudo-random numbers. 
Standard practice is to use the result of a call to srand(timse(0)) as the seed. However,
time() returns a time_t value which vary everytime and hence the pseudo-random number
vary for every program call. 
 

9) STRINGS
There are two types:
1) C-strings – These are array of type char
 2) Strings that are object string class.

a) C- String variables

#include <iostream>
using namespace std;
int main()
{
const int MAX = 80;
char str[MAX];
cout << “Enter a string: “;
cin >> str;
cout << “You entered: “ << str << endl;
return 0;
}

Here string is defined as an array of type char. Above program is not able to read spaces and
print the character which are continuous. For e.g., if we enter my name is …..then only “my”
will be printed.

b) String Constants.

char str[] = “Farewell! Thou art too dear for my possessing.”;

Here the string constant is written as a normal English phrase, delimited by quotes.

c) Reading embedded blanks

The normal input operation i.e., cin>>str is not able to read the spaces embedded in
the strings. So in order to read the spaces between the strings we need to use the
function

cin.get(str, MAX)

wher str is array of type char and MAX is the number of elements it can hold

Now the above program will be able to read the spaces between the words but it will
not be able to read multiple lines. For that we need to modify cin.get()

cin.get(str, MAX, ‘$’)

Here the dollar sign indicates the character to be entered to end the process.
Any character can be used

10) String Header file and functions

#inlcude<cstring> - This file must be included to use the function such as strcpy() which is
used to copy strings.

strcpy(str2, str1) – This function is used to copy one string into another.
11) ARRAY OF STRINGS

Sounds weird, but array of strings exists. By the definition of strings which are defined as
array of type char. Array of strings can be defined as follows-

#include <iostream>
using namespace std;
int main()
{
const int DAYS = 7;
const int MAX = 10;
char star[DAYS][MAX] = { “Sunday”, “Monday”, “Tuesday”,
“Wednesday”, “Thursday”,
“Friday”, “Saturday”};
for(int j=0; j<DAYS; j++)
cout << star[j] << endl;
return 0;
}

In the above program star is defined as array of strings. The DAYS defines the number of
different string elements and MAX defines the number of character in each string i.e., limit of
the string.

In this case we don’t need a second index to access the elements of the array
For e.g., the elements of star can be accessed by inserting star[j]

12) STRING AS CLASS MEMBER

#include <iostream>
#include <cstring> //for strcpy()
using namespace std;
class part
{
private:
char partname[30];
int partnumber;
double cost;
public:
void setpart(char pname[], int pn, double c)
{
strcpy(partname, pname);
partnumber = pn;
cost = c;
}
void showpart()
{
cout << “\nName=” << partname;
cout << “, number=” << partnumber;
cout << “, cost=$” << cost;
}
};
int main()
{
 part part1, part2;
part1.setpart(“handle bolt”, 4473, 217.55);
part2.setpart(“start lever”, 9924, 419.25);
cout << “\nFirst part: “; part1.showpart();
cout << “\nSecond part: “; part2.showpart();
cout << endl;
return 0;
}

In the above program a string is defined in a class as char partname[30]

1) ADDING TWO DIFFERENT STRINGS TOGETHER

By using concat() function we can add two C-type strings together. The result of the this
operation is kept in the first string that is passed as an argument

strcat (s1, s2)

Here s1 will get modified after adding s2 to it.

Where s1 and s2 are C-type strings

strncat(s1, s2, int n)

This function is used to concatenate two strings but this allows the specific number of
characters of second string to be concatenated to first string.

2) FUNCTION OF C- TYPE STRING

1) strcmp(str1,str2)
This function compares two C-type strings and returns 0 if strings are same otherwise it
returns 1 or -1 depending upon the first mismatch character in str1 and str2.

If first mismatch character of str1 is having ASCII value greater than the character of str2
then value 1 is returned otherwise -1 is returned.

2) strncmp (str1, str2, int n)

This function is used to compare particular number of characters in two strings.
For e.g.,
char ch [ ] = “All is well”;

char ch1[ ]= “All is not well”;

int x= strncmp (ch, ch1, 3)

The x will be 0 if the strings are equal and 1 or -1 depending upon the ASCII value of
mismatch characters.

3) strcasecmp(str1, str2)
This function is used to compare strings regardless of the case i.e., uppercase or
lowercase
char ch[] = “HELLO”;
char ch1[] = “hello”;

int x= strcasecmp(ch, ch1)

 The x will have the value 0 because both strings are equal if we ignore the case.
4) strncasecmp(str1, str2, n)

It is similar to above function. The only difference is that it allows the user to compare a
specific number of characters regardless of the case of the letters.

5) strchr (str, char)

This function is used to search for a particular character in a C-type string.

It returns a pointer to that character if it is found.

char* s= strchr(str, ‘A’)

cout<<s-str+1
This will give the position of the character.
6) strrchr(str, char)
This will try to find the given character from the end. In short it returns the pointer to the
last occurrence of the given character to be found.

7) strstr(str1, str2)

This function is used to find a string within another string. It returns a pointer indicating
the starting position of the string to be found.

8) strrev(str)
This function reverses the string provided as an argument.

9) strlwr(str)
It convers all the characters in the string to a lower case.

10) strupr(str)
It converts all the characters in the string to uppercase.

11) strdup(str)
This is used to duplicate a string. It returns a pointer of type char.

13) STANDARD C++ STRING CLASS

3) Defining and assigning string objects

#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1(“Man”);
string s2 = “Beast”;
 string s3;
s3 = s1;
cout << “s3 = “ << s3 << endl;
s3 = “Neither “ + s1 + “ nor “;
s3 += s2;
cout << “s3 = “ << s3 << endl;
s1.swap(s2);
cout << s1 << “ nor “ << s2 << endl;
return 0;
}

4) Unlike C-type string, C++ string is improved and easy to use. We do not need to define the
limits
For e.g., we define C-type strings as char name[30]. Here we provide the limit of the string
whereas in standard C++ string we define strings as

string name;
we need not to define its limits. It is all managed by the compiler.
5) In C++ standard strings we can assign one string to another with an assignment operator
directly

string s1, s3;

s1=s3;
This assignment was not possible in C-type strings

6) Strings can be initialised as

string s1(“Man”);
string s2 = “Beast”;
getline(cin, fullname)
getline(cin, fullname, ‘$’)

getline() function allows to read multiple lines

7) Two strings can be easily added together by using

s1+=s2;

14) Finding String Objects

string s1= “ In Xanadu did Kubla Kahn a stately pleasure dome decree”;
int n;
n=s1.find(“Kubla”);
this will give the position of the required word in above string

n=s1.find_first_of(“spde”);
This will give the position of whichever comes first from spde.

n=s1.find_first_not_of(“aeiouAEIOU”);

15) Modifying String Objects

string s1(“Quick! Send for Count Graystone.”);

 string s2(“Lord”);
string s3(“Don’t “);
8) s1.erase(0,7)
where 0 is the start position of the letter to be removed and 7 is its length
This will erase the word Quick!

9) s1.replace(9,5,s2)
where 9 is the starting position of the letter and 5 is its length
This will replace Count with Lord

10) s1.replace(0,1, “s”)

where 0 is the position of the letter and 1 is its length
This will replace the first letter i.e., S with s

11) s1.insert(0, s3)

where 0 is the position where the new string is to be inserted
This will add Don’t at the beginning of string s1

12) s1.erase(s1.size()-1,1)
since last character in a string is automatically inserted as ‘\0’ therefore we need to subtract -1
from total size to get the last character

13) s1.append(3, ‘!’)

where 3 is the number of time the character following it should be appended
This will insert three ! at the end

14) userName.compare(0, 2, aName, 0, 2)

This will compare the first two characters of string userName with first two character of string
aName

15) aName.substr(0,2)
This will give out the first two characters of string named aName

16) word.at[j]
This will give the character present in string word at j position

17) str.copy(string, chararray, starting point)

This function can copy a string to an array of char type. The arguments to the function are
string that is needed to be copied, the array where the string will be copied, and the starting
point from where the copying will be started.

18) Str.c_str()
This function is very useful in converting a string to an array. This function returns a pointer
to the given string that is converted into array of char type. But remember it is a constant
function.

19) Str.substr(x,y)
This is use to extract substring from a string. Here x denotes the starting point and y denotes
the number of characters to be extracted.

20) Strcmp(str1,str2)
This function is used to compare two strings. It returns 0 if the strings are equal and -1 if they
are not.
 10) Operator Overloading

The rather forbidding term operator overloading refers to giving the normal C++ operators,
such as +, *, <=, and +=, additional meanings when they are applied to user-defined data
types.
Normally
a = b + c;
works only with basic types such as int and float, and attempting to apply it when a, b, and c
are objects of a user-defined class will cause complaints from the compiler. However, using
overloading, you can make this statement legal even when a, b, and c are user-defined types .

1) Overloading Unary Operator

class Counter
{
private:
unsigned int count;
public:
Counter() : count(0)
{}
unsigned int get_count()
{ return count; }
void operator ++ ()
{
++count;
}
};

int main()
{
Counter c1, c2;

cout << “\nc1=” << c1.get_count();

cout << “\nc2=” << c2.get_count();
++c1;
++c2;
++c2;
cout << “\nc1=” << c1.get_count(); //display again
cout << “\nc2=” << c2.get_count() << endl;
return 0;
}

To overload any operator we have to use following format

(Return type) operator (operator to be overloaded) (arguments if any)

e.g., void operator ++ ()

here operator is a keyword and this keyword is used to overload an operator.

2) Operator with a return value

Consider the above example

If we want to use

c1=++c2;
 Then we need to change the return type of the operator from void

Counter operator ++()

{

Counter temp;
temp.count=++count;
return temp;

Here we created an object temp of Counter class which is then returned.

Instead of creating an object of Counter class we can directly return value in this way

Counter operator ++()

{
return Counter(count++);

3) Overloading operator for postfix use

In order to use the postfix operation, we just need to make a change

Counter operator ++(int)

Here we have included int inside the bracket. It works as an argument to the operator.

4) Overloading binary operator (+, -, *, /)

#include <iostream>
using namespace std;
class Distance //English Distance class
{
private:
int feet;
float inches;
public:
Distance (): feet (0), inches (0.0)
Distance (int ft, float in): feet(ft), inches(in)
{}
void getdist()
{
cout << “\nEnter feet: “; cin >> feet;
cout << “Enter inches: “; cin >> inches;
}
void showdist() const
{ cout << feet << “\’-” << inches << ‘\”’; }
Distance operator + ( Distance ) const;
};
Distance Distance::operator + (Distance d2) const //return sum
{
int f = feet + d2.feet; //add the feet
 float i = inches + d2.inches; //add the inches
if(i >= 12.0) //if total exceeds 12.0,
{
i -= 12.0; //by 12.0 and
f++;
}
return Distance(f,i);
}

int main()
{
Distance dist1, dist3, dist4;
dist1.getdist();
Distance dist2(11, 6.25);
dist3 = dist1 + dist2;
dist4 = dist1 + dist2 + dist3;
cout << “dist1 = “; dist1.showdist(); cout << endl;
cout << “dist2 = “; dist2.showdist(); cout << endl;
cout << “dist3 = “; dist3.showdist(); cout << endl;
cout << “dist4 = “; dist4.showdist(); cout << endl;
return 0;
}

Distance operator + (Distance)

Here return type is a Distance which is a class. This operator takes another class as argument.
The object on the left side of the operator is the object of which the operator is a member. The
object on the right side of the operator is furnished as argument.

In the last statement in operator definition

return Distance(f , i)

It creates a nameless object of class Distance and two arguments are passed to it due to which
the constructor which is defined to handle two arguments is called. This nameless object is
then returned.

5) The Subscript operator []

#include <iostream>
using namespace std;
#include <process.h> //for exit ()
const int LIMIT = 100; //array size
////////////////////////////////////////////////////////////////
class safearay
{
private:
int arr[LIMIT];
public:
int& operator [](int n)
{
if( n< 0 || n>=LIMIT )
{ cout << “\nIndex out of bounds”; exit(1); }
return arr[n];
}
 };

int main()
{
safearay sa1;
for(int j=0; j<LIMIT; j++)
sa1[j] = j*10;
for(j=0; j<LIMIT; j++)
{
int temp = sa1[j];
cout << “Element “ << j << “ is “ << temp << endl;
}
return 0;
}

11) Inheritance
#include <iostream>
using namespace std;

class Counter //base class

{
protected:
unsigned int count;
public:
Counter() : count(0)
{}
Counter(int c) : count(c)
{}
unsigned int get_count() const
{ return count; }
Counter operator ++ ()
{ return Counter(++count); }
}
class CountDn : public Counter
{
public:
Counter operator -- ()
{ return Counter(--count); }
};

int main()
{
CountDn c1;
cout << “\nc1=” << c1.get_count();
++c1; ++c1; ++c1;
cout << “\nc1=” << c1.get_count();
--c1; --c1; //decrement c1, twice
cout << “\nc1=” << c1.get_count();
cout << endl;
return 0;
}

 Defining derived class

From the above program we can see that derived class is defined by firstly providing the name of
the class then colon and then name of the base class from which it is derived.
If derived class doesn’t have a constructor, then constructor from base class is used.

Objects of the derived class can use the function from the base class.

 The protected access specifier

 A member function of class can always access class members, whether they are public or private.
But an object declared externally can only invoke (using the dot operator, for example) public
members of the class. It is not allowed to use private members. So in order to allow member
function of derived class to access the members of base class, the base class members are defined
as private.

 Members of base class cannot use member function of derived class

 Overriding member function

We can use functions with same name in base as well as derived class. But the main thing to
remember is that when we will call the function the function in derived class will be executed.
This is because function in derived class overrides the function of base class.

// staken.cpp
// overloading functions in base and derived classes
#include <iostream>
using namespace std;
#include <process.h>
class Stack
{
protected:
enum { MAX = 3 };
int st[MAX];
int top;
public:
Stack()
{ top = -1; }
void push(int var)
{ st[++top] = var; }
int pop()
{ return st[top--]; }
};

class Stack2 :
{
public:
void push(int var)
{
if(top >= MAX-1)
{ cout << “\nError: stack is full”; exit(1); }
Stack::push(var);
}
int pop() //take number off stack
{
if(top < 0) //error if stack empty
{ cout << “\nError: stack is empty\n”; exit(1); }
return Stack::pop();
}
}
int main()
{
Stack2 s1;
s1.push(11); //push some values onto stack
s1.push(22);
s1.push(33);
cout << endl << s1.pop();
cout << endl << s1.pop();
cout << endl << s1.pop();
cout << endl << s1.pop();
cout << endl;
return 0;
}

12) VECTORS IN C++

1) Functions

1) begin()
This function returns an iterator pointing to the first element in the vector

2) end()
This function returns an iterator pointing to the theoretical element that follows the last
element in the vector.

3) rbegin() (reverse beginning)

Returns a reverse iterator pointing to the last element in the vector. It moves from last to
first element.

4) rend()
Returns a reverse iterator pointing to theoretical element preceding the first element in the
vector.

5) crbegin()
Returns a constant reverse iterator pointing to the last element in the vector (reverse
beginning). It moves form last to first element

6) crend()
Returns a constant reverse iterator pointing to the theoretical element preceding the first
element in the vector (considered as reverse end)

7) size()
Returns the number of elements in the vector

8) capacity()
Returns the size of the storage space currently allocated to the vector expressed as number
of elements

9) resize()
Resizes the container so that it contains ‘n’ elements.
vectorname.resize(int n)

vectorname.resize(int n, int val)

n is new container size

val- if this value is specified then the new elements are initialized with this value.

10) empty()
Returns whether the container is empty. The return type is bool.

11) shrink_to_fit()
Reduces the capacity of the container to fit its size and destroys all elements beyond the
capacity.

12) reserve()
Requests that the vector capacity be at least enough to contain n elements

13) at(g)
 Returns a reference to the element at position ‘g’ in the vector
vectorname.at(position)

14) front()
Returns a reference to the first element in the vector.
vectorname.front()

15) back()
Returns a reference to the last element in the vector.
vectorname.back()

16) assign()
This function is used to assign new values to the elements in the vector replacing the old
one.
vectorname.assign(int size, int value)
size-number of values to be assigned
value- value to be assigned

vectorname.assign(array, arr+size)

arr- The array which is to be assigned to a vector

size- number of elements from the beginning which has to be assigned.

vectorname.assign(InputInterator first, InputIterator last)

first – Input iterator to the initial position range.

last- Input iterator to the final position range.
vectorname.assign(initializer list)
v.assign({1,2,3})

17) push_back()

This function is used to push elements into a vector from the back. The new value is
inserted into the vector at the end, after the current last element and the container size is
increased by 1
vectorname.push_back(value)
The value to be added in the back is passed as the parameter.
myvector = {1,2,3,4,5}

myvector.push_back(6);

Output = {1,2,3,4,5,6}

18) pop_back()
This function is used to pop or remove elements from a vector from the back

vectorname.pop_back()

19) insert()
This function is used to insert elements in the vector at a desired location.

vectorname.insert(position, val)
 position – it specifies the iterator which points to the position where the insertion is to be
done.
val- it specifies the value to be inserted.

vectorname.insert(position, size, value)

vectorname.insert(position, iterator1, iterator2)

position – it specifies the position at which insertion to be done in vector

iterator1 – it specifies the starting position from which the elements are to be inserted

20) erase()
This function is used to remove elements from a specified position or range.
vectorname.erase(position)
vectorname.erase(starting position, ending position)

21) clear()
This function is used to remove all the elements in a vector thus making it of size 0.

22) Swap()
This function is used to swap elements of one vector with another irrespective of their
sizes.
vectorname.swap(vector)

23) emplace()
This function extends the container by inserting a new element at the position.
Reallocation happens only if there is a need for more space. Here the container size
increases by one.

vectorname.emplace(const_iterator position, element)

position- it specifies the iterator pointing to the position in the container where the new
element is to be inserted.

Return value- this function returns an iterator that points to the newly inserted element.

LIBRARTY IN C++ STL

I. Non modifying sequence operation

1) all_of()
Test condition for all elements in range.
It checks for a given property on every element and returns true when each element in the
range satisfies specified property, else return false.
https://www.geeksforgeeks.org/stdall_of-in-cpp/

all_of(InputIterator first, InputIterator last, UnaryPredicate pred);

It returns a bool type value.

2) any_of()
 This function checks for a given range if there is even one element satisfying a given
property mentioned in function. Return true if at least one element satisfies the property
else returns false.
https://www.geeksforgeeks.org/useful-array-algorithms-in-c-stl/

any_of(InputIterator first, InputIterator last, UnaryPredicate pred);

Return value:
It returns a bool type value.

3) none_of()
This function returns true if none of the elements satisfies the given condition else return
false.

https://www.geeksforgeeks.org/useful-array-algorithms-in-c-stl/
Return value:
It returns a bool type value.
none_of(InputIterator first, InputIterator last, UnaryPredicate pred);

4) for_each()
This function helps in making changes in each element without using for loop or while
loop.
for_each(InputIterator first, InputIterator last, Function fnc);

first-The beginning position from where the function operations have to be executed.
last- The ending position till where function has to be executed.
fnc/obj- The third argument is a function or an object function which operation would be
applied to each element.

https://www.geeksforgeeks.org/for_each-loop-c/

5) find()
Finds the element in the given range of numbers. Returns an iterator to the first element in
the range that compares equal to val. If no such element is found, the function returns last.

Iterator it= find(InputIterator first, InputIterator last, const value)

first-starting point
last- ending point
value- value to be searched.
https://www.geeksforgeeks.org/std-find-in-cpp/

Return value:
Returns an iterator to the first element in the range that compares equal to val.
If no elements match, the function returns last.

6) find_if()
Returns an iterator to first element in the range for which pred (Unary function) returns
true. If no such element is found, the function returns last.

Iterator it = find_if( InputIterator first, InputIterator last, Unary Predicate pred);

Return value:
Returns an iterator to first element for which pred(function) returns true.

https://www.geeksforgeeks.org/stdfind_if-stdfind_if_not-in-c/
7) find_if_not()
Returns an iterator to first element in the range for which pred( Unary function) returns
false. If no such element is found, the function returns last.

Iterator it = find_if( InputIterator first, InputIterator last, Unary Predicate pred);

Return value:
Returns an iterator to first element for which pred(function) returns false.

https://www.geeksforgeeks.org/stdfind_if-stdfind_if_not-in-c/

8) find_end()
This function is used to find the last occurrence of sub-sequence inside a container. It
searches the range[first1, last1] for the last occurrence of the sequence defined by [first2,
last2], and returns an iterator to first element, or last if no occurrence are found.

find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2,

ForwardIterator2 last2);

first1- Forward iterator to the first element in the first range.

last1- forward iterator to the last element in the first range.
first2- forward iterator to the first element in the second range.
last2- forward iterator to the last element in the second range.
 Return value – it returns an iterator to the first element of the last occurrence of [first2,
last2], in [first1, last1]. If the sequence is not found the function returns last1.

9) find_first_of()
This function is used to compare elements between two containers. It compares all the
elements in a range [first1, last1] with the elements in the range [first2, last2] and if any
of the elements present in the second range is found in the first one, then it returns an
iterator to that element.
If there are more than one common element in both the ranges then an iterator to the first
common element present in the first container is returned. In case there is no match, the
iterator pointing to last1 is returned.

find_first_of(InputIterator first1, InputIterator last1, InputIterator first2,

InputIterator last2);

https://www.geeksforgeeks.org/stdfind_first_of-in-cpp/

first1- Forward iterator to the first element in the first range.

last1- forward iterator to the last element in the first range.
first2- forward iterator to the first element in the second range.
last2- forward iterator to the last element in the second range.

Return value- it returns an iterator to the first element in [first1, last1] that is part of
[first2, last2]. If no matches are found of [first2,last2] is empty the function returns last1.

10) adjacent_find()

 without binary predicate

This function searches the range for the first occurrence of two consecutive elements and
returns an iterator to the first of these two elements, or last if no such pair is found.

adjacent_find(ForwardIt first, ForwardIt last)

first, last- Range of elements to be examine

https://www.geeksforgeeks.org/stdadjacent_find-in-c/

 with binary predicate

adjacent_find(ForwardIt first, ForwardIt last, Binary predicate p);

first, last- Range of elements to be examine

p: binary predicate which returns true if the elements should be treated equal.

Return value:
An iterator to the first of the first pair of identical elements that is, the first iterator it such
that *it=*(it+1) for the first version or p (*it, *(it+1))! =false for the second version
If no such elements are found false is returned.
11) count()
Returns the number of occurrences of an element in a given range. Returns the number of
elements in the range [first, last] that compare equal to val.

int n= count(Iterator first, Iterator last, T&val)

first,last= input iterators to the initial and final position of the sequence of elements,
val- Value to match.

https://www.geeksforgeeks.org/std-count-cpp-stl/

12) count_if()
this function returns the numbers of elements that satisfies the given condition
int n= count_if(Itertor first, Iterator last, Unary Predicate p);
first, last- input iterator to the initial and final position of the sequence of elements
p= condition to be satisfied by the number.

https://www.geeksforgeeks.org/count_if-in-c/

13) mismatch ()
This function returns the 1st mismatch pair pointer, first element pointing to position first
mismatch element of first container, second element pointing to position of first mismatch
element of 2nd container. If no mismatch is found, 1st element points to position after last
element of 1st container and 2nd points to corresponding position of 2nd pointer.

Iterator mispair = mismatch(v.begin(), v.end(), v1.begin());

First mispair = *mispair.first;

Second mispair = *mispair.second;

https://www.geeksforgeeks.org/stdmismatch-examples-c/

14) equal()

It helps to compare the elements within the range [first1, last1] with those within range
beginning at first2.
bool equal ( InputIterator first1, InputIterator last1, InputIterator first2)

https://www.geeksforgeeks.org/stdequal-in-cpp/

first1, last1- initial and final position of the first sequence. All the elements are present
within the range [first1, last1]
first2 – Initial position of the second sequence.

Return value:
Returns true if all the elements in both range match; otherwise, false.
 bool equal ( InputIterator first1, InputIterator last1, InputIterator first2,
BinaryPredicate pred);

first1, last1- initial and final position of the first sequence. All the elements are present
within the range [first1, last1]
first2 – Initial position of the second sequence.

Pred – binary function that accepts two elements as arguments and returns a value
convertible to Boolean.

Return value:
Returns true if all the elements in both range match; otherwise, false.

15) is_permutation()

This function checks whether one sequence is permutation of other or not.

Permutation means the other sequence is similar to first sequence just the elements will
occupy different position
e.g., seq1 = { 0,1,2,3,4}
seq2 = {4,3,2,1,0}
these two sequences are permutation of one another.

https://www.geeksforgeeks.org/stdis_permutation-c-stl/

bool is_permutation(ForwardIterator first1, ForwardIterator last1,

ForwardIterator first2)

first1, last1- initial and final position of the first sequence. All the elements are present
within the range [first1, last1]

first2 – Initial position of the second sequence.

Return value:
Returns true if all the elements in both range match; otherwise, false.

16) search()
This function is used to find out the presence of a subsequence satisfying a condition with
respect to another sequence.
 It searches the secquence [first1, last1) for the first occurrence of the subsequence
defined by [first2, last2] and returns an iterator to its first element of the
occurrence, or last1 if no occurrences are found.
 It compares the elements in both the ranges sequentially using operator == or
based on any given predicate. A subsequence of [first, last1) is considered a
match only when this is true for all the elements of [first2, last2]. Finally
std::search returns the first such occurrence.

search(ForwardIterator1 first1, ForwardIterator last1, ForwardIterator

first2, ForwardIterator last2)
 https://www.geeksforgeeks.org/stdsearch-in-c/

first1- Forward iterator to the beginning of the subsequence of first container to be searched into.

last1 Forward iterator to the ending of the subsequence of first container to be searched into

first2 -Forward iterator to the beginning of the subsequence of second container to be searched for.

last2- Forward iterator to the ending of the subsequence of second container to be searched for.

Return- an iterator to the first element of the first occurrence of [first2, last2) in [first1,last1) or last1
if no occurrence are found.

search(ForwardIterator1 first1, ForwardIterator last1, ForwardIterator first2,

ForwardIterator last2, BinaryPredicate pred)

pred – binary function that accepts two elements as arguments (one from each of the two container, in
the same order) and returns a value convertible to bool. The returned value indicates whether the
elements are considered to match in the context of the function

17) search_n()

This function is used to determine whether a given element satisfies a predicate a given
no. of times consecutively within the container elements.
It searches the range [first, last) for sequence of count elements, each comparing equal to
given value (version 1) or satisfying a predicate (version 2)

The function returns an iterator to the first such element, or an iterator to the last element
of the container, if no such sequence is found.

1) For comparing elements using (= =)

Search_n()(ForwardIterator1 first1, ForwardIterator last1, Size count, const
T&val);

First- Forward Iterator to beginning of the container to be searched for.

Last- forward Iterator to the end of the container to be searched for.
Count- minimum number of successive elements to match.
Size shall be convertible to an integral value.
Val- Individual value to be compared.

Return- It returns an iterator to the first element of the sequence.

If no such sequence is found, the function returns last.

https://www.geeksforgeeks.org/stdsearch_n-with-example-in-cpp/
2) For comparing elements using a predicate.

Search_n()(ForwardIterator1 first1, ForwardIterator last1, Size count, const T&val,

BinaryPredicate pred);

Pred- Binary function accepts two arguments (one element from the sequence as first,
and val as second), and returns a value convertible to bool. The value returned indicates
whether the element is considered a match in the context of this function.

Return- It returns an iterator to the first element of the sequence.

If no such sequence is found, the function returns last.

https://www.geeksforgeeks.org/stdsearch_n-with-example-in-cpp/

II. Modifying sequence operations

1) copy()

a) copy(strt_iter1, end_iter1, strt_iter2)

strt_iter1 – The pointer to the beginning of the source container, from where elements have
to be started copying

end_iter1, - The pointer to the end of the source container, from where elements have to be
copied.

strt_iter2- The pointer to the beginning of the destination container, to where elements have
to be started copying.

https://www.geeksforgeeks.org/different-methods-copy-c-stl-stdcopy-copy_n-copy_if-
copy_backward/

b) copy(strt_iter1, num, strt_iter2)

num- Integer specifying how many numbers would be copied to destination container
starting from strt_iter1. If a negative number is entered, no operation is performed

c) copy_if(v1.begin(), v1.end(), v2.begin(), []( int i))

13) STANDARD TEMPLATE LIBRARY