Industrial Training File
Name: Nishant Panchal
Roll No: 190070800031
Branch: Computer Engg.
Done from: Excel Computer Classes
Subject: C++
Class and Objects
Class: A class in C++ is the building block that leads to Object-
Oriented programming. It is a user-defined data type, which holds its
own data members and member functions, which can be accessed and
used by creating an instance of that class. A C++ class is like a
blueprint for an object.
Syntax:
class <class_name>{
//code;
};
Object: An Object is an instance of a Class. When a class is defined,
no memory is allocated but when it is instantiated (i.e. an object is
created) memory is allocated.
Syntax:
class_name object_name;
Example:
#include<iostream>
#include<conio.h>
using namespace std;
class student{
public:
char name[20],branch[20],rollno[20];
};
int main(){
student s;// object of class student
system("cls");
cout<<"enter the name of the student : ";
cin>>s.name;
cout<<"enter the roll no of the student : ";
cin>>s.rollno;
cout<<"enter the class of the student : ";
cin>>s.branch;
cout<<"\n\n\n\nName of the student is "<<s.name<<endl;
cout<<"Class of the student is "<<s.name<<endl;
cout<<"Roll no of the student is "<<s.name<<endl;
getch();
return 0;
Encapsulation
In normal terms Encapsulation is defined as wrapping up of data and
information under a single unit. In Object Oriented Programming,
Encapsulation is defined as binding together the data and the functions
that manipulates them.
Encapsulation also lead to data abstraction or hiding. As using
encapsulation also hides the data. In the above example the data of
any of the section like sales, finance or accounts is hidden from any
other section.
In C++ encapsulation can be implemented using Class and access
modifiers
Access modifiers: Access modifiers are used to implement an
important aspect of Object-Oriented Programming known as Data
Hiding.
There are 3 types of access modifiers available in C++:
1. Public
2. Private
3. Protected
Example:
#include<iostream>
using namespace std;
class Circle {
// private data member
private:
double radius;
// public member function
public:
void compute_area(double r) {
// member function can access private
// data member radius
radius = r;
double area = 3.14*radius*radius;
cout << "Radius is: " << radius << endl;
cout << "Area is: " << area;
};
// main function
int main() {
// creating object of the class
Circle obj;
// trying to access private data member
// directly outside the class
obj.compute_area(1.5);
return 0;
Constructors
A constructor is a special type of member function of a class which
initializes objects of a class. In C++, Constructor is automatically called
when object(instance of class) create. It is special member function of
the class because it does not have any return type.
Constructor has same name as the class itself
Constructors don’t have return type
A constructor is automatically called when an object is created.
It must be placed in public section of class.
If we do not specify a constructor, C++ compiler generates a default
constructor for object (expects no parameters and has an empty
body).
Types of Constructors
1. Default Constructors: Default constructor is the constructor
which doesn’t take any argument. It has no parameters.
2. Parameterized Constructors: It is possible to pass arguments to
constructors. Typically, these arguments help initialize an object
when it is created. To create a parameterized constructor, simply
add parameters to it the way you would to any other function.
When you define the constructor’s body, use the parameters to
initialize the object.
3. Copy Constructor: A copy constructor is a member function
which initializes an object using another object of the same class
Example:
#include <iostream>
using namespace std;
class point {
private:
double x, y;
public:
// Non-default Constructor &
// default Constructor
point (double px, double py) {
x = px, y = py;
}
};
int main(void) {
// Define an array of size
// 10 & of type point
// This line will cause error
point a[10];
// Remove above line and program
// will compile without error
point b = point(5, 6);
}
Distructors
Destructor is an instance member function which is invoked
automatically whenever an object is going to be destroyed. Meaning, a
destructor is the last function that is going to be called before an object
is destroyed.
Destructor function is automatically invoked when the objects are
destroyed.
It cannot be declared static or const.
The destructor does not have arguments.
It has no return type not even void.
An object of a class with a Destructor cannot become a member of
the union.
A destructor should be declared in the public section of the class.
The programmer cannot access the address of destructor.
Example:
class String {
private:
char* s;
int size;
public:
String(char*); // constructor
~String(); // destructor
};
String::String(char* c) {
size = strlen(c);
s = new char[size + 1];
strcpy(s, c);
}
String::~String() {
delete[] s;
}
Polymorphism
The word polymorphism means having many forms. In simple words,
we can define polymorphism as the ability of a message to be
displayed in more than one form. A real-life example of polymorphism,
a person at the same time can have different characteristics. Like a
man at the same time is a father, a husband, an employee. So the
same person posses different behavior in different situations. This is
called polymorphism. Polymorphism is considered as one of the
important features of Object Oriented Programming.
In C++ polymorphism is mainly divided into two types:
Compile time Polymorphism
Runtime Polymorphism
Compile time polymorphism: This type of polymorphism is achieved
by function overloading or operator overloading.
Function Overloading: When there are multiple functions with
same name but different parameters then these functions are said
to be overloaded. Functions can be overloaded by change in
number of arguments or/and change in type of arguments.
Operator Overloading: C++ also provide option to overload
operators. For example, we can make the operator (‘+’) for string
class to concatenate two strings. We know that this is the addition
operator whose task is to add two operands. So a single operator ‘+’
when placed between integer operands , adds them and when
placed between string operands, concatenates them.
Example:
#include<iostream>
using namespace std;
class Complex {
private:
int real, imag;
public:
Complex(int r = 0, int i =0) {
real = r;
imag = i;
}
// This is automatically called when '+' is used with
// between two Complex objects
Complex operator + (Complex const &obj) {
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
void print() {
cout << real << " + i" << imag << endl;
};
int main() {
Complex c1(10, 5), c2(2, 4);
Complex c3 = c1 + c2; // An example call to "operator+"
c3.print();
Runtime polymorphism: This type of polymorphism is achieved
by Function Overriding.
Function overriding on the other hand occurs when a derived
class has a definition for one of the member functions of the base
class. That base function is said to be overridden.
Example:
#include <bits/stdc++.h>
using namespace std;
class base {
public:
virtual void print () {
cout<< "print base class" <<endl;
}
void show () {
cout<< "show base class" <<endl;
}
};
class derived:public base {
public:
void print () { //print () is already virtual function in derived class,
we could also declared as virtual void print () explicitly
cout<< "print derived class" <<endl;
}
void show () {
cout<< "show derived class" <<endl;
}
};
//main function
int main() {
base *bptr;
derived d;
bptr = &d;
//virtual function, binded at runtime (Runtime polymorphism)
bptr->print();
// Non-virtual function, binded at compile time
bptr->show();
return 0;
}
Defining functions outside the class
The member function can be declared outside the class using scope
resolution operator ( :: )
Example:
#include<iostream>
#include<conio.h>
using namespace std;
class math {
private:
int a,b,c;
public:
void sum();
};
void math::sum() {
cout<<"enter two value:"<<endl;
cin>>a>>b;
c=a+b;
cout<<"sum of two no is :"<<c;
int main() {
math s;// object of calss student
s.sum();
getch();
return 0;
Defining operator overloading outside the class.
return_type calss_name::operator (argument)
{
//code;
}
Friend function
In object-oriented programming, a friend function, that is a "friend" of
a given class, is a function that is given the same access as methods to
private and protected data. [1]
A friend function is declared by the class that is granting access, so
friend functions are part of the class interface, like methods. Friend
functions allow alternative syntax to use objects, for
instance f(x) instead of x.f() , or g(x,y) instead of x.g(y) .
Friend functions have the same implications on encapsulation as
methods.
Example:
#include <iostream>
class A {
private:
int a;
public:
A() {
a = 0;
friend class B; // Friend Class
};
class B {
private:
int b;
public:
void showA(A& x) {
// Since B is friend of A, it can access
// private members of A
std::cout << "A::a=" << x.a;
};
int main() {
A a;
B b;
b.showA(a);
return 0;
}
Inheritance
The capability of a class to derive properties and characteristics from
another class is called Inheritance. Inheritance is one of the most
important feature of Object Oriented Programming.
Sub Class: The class that inherits properties from another class is
called Sub class or Derived Class.
Super Class:The class whose properties are inherited by sub class is
called Base Class or Super class.
Types of Inheritance in C++
1. Single Inheritance: In single inheritance, a class is allowed to
inherit from only one class. i.e. one sub class is inherited by one base
class only.
Example:
#include <iostream>
using namespace std;
// base class
class Vehicle {
public:
Vehicle() {
cout << "This is a Vehicle" << endl;
};
// sub class derived from a single base classes
class Car: public Vehicle {
};
// main function
int main() {
// creating object of sub class will
// invoke the constructor of base classes
Car obj;
return 0;
2. Multiple Inheritance: Multiple Inheritance is a feature of C++ where
a class can inherit from more than one classes. i.e one sub class is
inherited from more than one base classes.
Example:
#include <iostream>
using namespace std;
// first base class
class Vehicle {
public:
Vehicle() {
cout << "This is a Vehicle" << endl;
};
// second base class
class FourWheeler {
public:
FourWheeler() {
cout << "This is a 4 wheeler Vehicle" << endl;
};
// sub class derived from two base classes
class Car: public Vehicle, public FourWheeler {
};
// main function
int main() {
// creating object of sub class will
// invoke the constructor of base classes
Car obj;
return 0;
}
3.Multilevel Inheritance: In this type of inheritance, a derived class is
created from another derived class.
Example:
#include <iostream>
using namespace std;
// base class
class Vehicle
{
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
// first sub_class derived from class vehicle
class fourWheeler: public Vehicle
{ public:
fourWheeler()
{
cout<<"Objects with 4 wheels are vehicles"<<endl;
}
};
// sub class derived from the derived base class fourWheeler
class Car: public fourWheeler{
public:
Car()
{
cout<<"Car has 4 Wheels"<<endl;
}
};
// main function
int main()
{
//creating object of sub class will
//invoke the constructor of base classes
Car obj;
return 0;}
4. Hierarchical Inheritance: In this type of inheritance, more than one
sub class is inherited from a single base class. i.e. more than one
derived class is created from a single base class.
Example:
#include <iostream>
using namespace std;
// base class
class Vehicle {
public:
Vehicle() {
cout << "This is a Vehicle" << endl;
}
};
// first sub class
class Car: public Vehicle {
};
// second sub class
class Bus: public Vehicle {
};
// main function
int main() {
// creating object of sub class will
// invoke the constructor of base class
Car obj1;
Bus obj2;
return 0;
}
5.Hybrid (Virtual) Inheritance: Hybrid Inheritance is implemented by
combining more than one type of inheritance. For example: Combining
Hierarchical inheritance and Multiple Inheritance.
Example:
#include <iostream>
using namespace std;
// base class
class Vehicle {
public:
Vehicle() {
cout << "This is a Vehicle" << endl;
};
//base class
class Fare {
public:
Fare() {
cout<<"Fare of Vehicle\n";
};
// first sub class
class Car: public Vehicle {
};
// second sub class
class Bus: public Vehicle, public Fare {
};
// main function
int main() {
// creating object of sub class will
// invoke the constructor of base class
Bus obj2;
return 0;
}
Exception Handling
One of the advantages of C++ over C is Exception Handling.
Exceptions are run-time anomalies or abnormal conditions that a
program encounters during its execution. There are two types of
exceptions: a)Synchronous, b)Asynchronous(Ex:which are beyond the
program’s control, Disc failure etc). C++ provides following specialized
keywords for this purpose.
try: represents a block of code that can throw an exception.
catch: represents a block of code that is executed when a particular
exception is thrown.
throw: Used to throw an exception. Also used to list the exceptions that
a function throws, but doesn’t handle itself.
Example:
#include <iostream>
using namespace std;
int main() {
int x = -1;
// Some code
cout << "Before try \n";
try {
cout << "Inside try \n";
if (x < 0) {
throw x;
cout << "After throw (Never executed) \n";
} catch (int x ) {
cout << "Exception Caught \n";
cout << "After catch (Will be executed) \n";
return 0;
File Handling
In C++, files are mainly dealt by using three classes fstream, ifstream, ofstream
available in fstream headerfile.
ofstream:
Stream class to write on files
ifstream: Stream class to read from files
fstream: Stream class to both read and write from/to files.
Now the first step to open the particular file for read or write
operation. We can open file by
1. passing file name in constructor at the time of object
creation
2. using the open method
Open File by using constructor
ifstream (const char* filename, ios_base::openmode mode =
ios_base::in);
ifstream fin(filename, openmode) by default openmode = ios::in
ifstream fin(“filename”);
Open File by using open method
Calling of default constructor
ifstream fin;
fin.open(filename, openmode)
fin.open(“filename”);
Modes :
Member Constant Stands For Access
in * Input File open for reading:
the internal stream buffer supports input operations.
out Output File open for writing:
the internal stream buffer supports output operations.
binary Binary Operations are performed in binary mode rather
than text.
ate at end The output position starts at the end of the file.
app Append All output operations happen at the end of the file,
appending to its existing contents.
trunc Truncate Any contents that existed in the file before it is open
are discarded.
Default Open Modes :
ifstream ios::in
ofstream ios::out
fstream ios::in | ios::out
Problem Statement :
To read and write a File in C++.
Examples:
Input :
Welcome in GeeksforGeeks. Best way to learn things.
-1
Output :
Welcome in GeeksforGeeks. Best way to learn things.
Recommended: Please try your approach on {
IDE
first, before moving on to the solution.
Below is the implementation by using ifstream & ofstream classes.
• C++
/* File Handling with C++ using ifstream & ofstream class object*/
/* To write the Content in File*/
/* Then to read the content of file*/
#include <iostream>
/* fstream header file for ifstream, ofstream,
fstream classes */
#include <fstream>
using namespace std;
// Driver Code
int main() {
// Creation of ofstream class object
ofstream fout;
string line;
// by default ios::out mode, automatically deletes
// the content of file. To append the content, open in ios:app
// fout.open("sample.txt", ios::app)
fout.open("sample.txt");
// Execute a loop If file successfully opened
while (fout) {
// Read a Line from standard input
getline(cin, line);
// Press -1 to exit
if (line == "-1")
break;
// Write line in file
fout << line << endl;
// Close the File
fout.close();
// Creation of ifstream class object to read the file
ifstream fin;
// by default open mode = ios::in mode
fin.open("sample.txt");
// Execute a loop until EOF (End of File)
while (fin) {
// Read a Line from File
getline(fin, line);
// Print line in Console
cout << line << endl;
// Close the file
fin.close();
return 0;
