Subject Code: BCA 307

Lab: Object Oriented Programming using C++

Submitted by: ABHISHEK
University Roll Number: 8021823
Class: BCA 3rd year DDE
Reference Number: 19233015
BCA 3rd year Lab C++ Reference Number:19233015

Contents
Function Overloading......................................................................................................................3
Inline Functions...............................................................................................................................4
Friend Function................................................................................................................................7
Default Constructors........................................................................................................................9
Parameterized Constructors...........................................................................................................11
Copy Constructor...........................................................................................................................13
Static data members.......................................................................................................................15
Overloading unary operator...........................................................................................................17
Overloading Binary Operator........................................................................................................18
Single Inheritance..........................................................................................................................20
Multiple Inheritance.......................................................................................................................21
Multilevel Inheritance....................................................................................................................23
Hybrid (Virtual) Inheritance..........................................................................................................25
Hierarchical Inheritance.................................................................................................................27
Virtual Function.............................................................................................................................29
Pure Virtual Functions...................................................................................................................31
put() and gets() function................................................................................................................32
 Using the put() function to perform the file output operation.............................................32
read() and write() Functions..........................................................................................................35

2
BCA 3rd year Lab C++ Reference Number:19233015

Function Overloading

#include <iostream>
using namespace std;

void print(int i) {
cout << " Here is int " << i << endl;
}
void print(double f) {
cout << " Here is float " << f << endl;
}
void print(char const *c) {
cout << " Here is char* " << c << endl;
}

int main() {
print(10);
print(10.10);
print("ten");
return 0;
}
Output:
Here is int 10
Here is float 10.1
Here is char* ten

3
BCA 3rd year Lab C++ Reference Number:19233015

Inline Functions
#include <iostream>
using namespace std;
class operation
{
int a,b,add,sub,mul;
float div;
public:
void get();
void sum();
void difference();
void product();
void division();
};
inline void operation :: get()
{
cout << "Enter first value:";
cin >> a;
cout << "Enter second value:";
cin >> b;
}

inline void operation :: sum()

{
add = a+b;
cout << "Addition of two numbers: " << a+b << "\n";
}

4
BCA 3rd year Lab C++ Reference Number:19233015

inline void operation :: difference()

{
sub = a-b;
cout << "Difference of two numbers: " << a-b << "\n";
}

inline void operation :: product()

{
mul = a*b;
cout << "Product of two numbers: " << a*b << "\n";
}

inline void operation ::division()

{
div=a/b;
cout<<"Division of two numbers: "<<a/b<<"\n" ;
}

int main()
{
cout << "Program using inline function\n";
operation s;
s.get();
s.sum();
s.difference();
s.product();
s.division();
return 0;

5
BCA 3rd year Lab C++ Reference Number:19233015

}
Output:
Enter first value: 45
Enter second value: 15
Addition of two numbers: 60
Difference of two numbers: 30
Product of two numbers: 675
Division of two numbers: 3

6
BCA 3rd year Lab C++ Reference Number:19233015

Friend Function
#include <iostream>

class B;

class A {
public:
void showB(B&);
};

class B {
private:
int b;

public:
B() { b = 0; }
friend void A::showB(B& x); // Friend function
};

void A::showB(B& x)
{
// Since showB() is friend of B, it can
// access private members of B
std::cout << "B::b = " << x.b;
}

int main()
{

7
BCA 3rd year Lab C++ Reference Number:19233015

A a;
B x;
a.showB(x);
return 0;
}
Output:
B::b = 0

8
BCA 3rd year Lab C++ Reference Number:19233015

Default Constructors
// Cpp program to illustrate the
// concept of Constructors
#include <iostream>
using namespace std;

class construct {
public:
int a, b;

// Default Constructor
construct()
{
a = 10;
b = 20;
}
};

int main()
{
// Default constructor called automatically
// when the object is created
construct c;
cout << "a: " << c.a << endl
<< "b: " << c.b;
return 1;
}

9
BCA 3rd year Lab C++ Reference Number:19233015

Output:
a: 10
b: 20

10
BCA 3rd year Lab C++ Reference Number:19233015

Parameterized Constructors
// CPP program to illustrate
// parameterized constructors
#include <iostream>
using namespace std;

class Point {
private:
int x, y;

public:
// Parameterized Constructor
Point(int x1, int y1)
{
x = x1;
y = y1;
}

int getX()
{
return x;
}
int getY()
{
return y;
}
};

11
BCA 3rd year Lab C++ Reference Number:19233015

int main()
{
// Constructor called
Point p1(10, 15);

// Access values assigned by constructor

cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();

return 0;
}
Output:
p1.x = 10, p1.y = 15

12
BCA 3rd year Lab C++ Reference Number:19233015

Copy Constructor
#include<iostream>
using namespace std;

class Point
{
private:
int x, y;
public:
Point(int x1, int y1) { x = x1; y = y1; }

// Copy constructor
Point(const Point &p2) {x = p2.x; y = p2.y; }

int getX() { return x; }

int getY() { return y; }
};

int main()
{
Point p1(10, 15); // Normal constructor is called here
Point p2 = p1; // Copy constructor is called here

// Let us access values assigned by constructors

cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
cout << "\np2.x = " << p2.getX() << ", p2.y = " << p2.getY();

return 0;

13
BCA 3rd year Lab C++ Reference Number:19233015

}
Output:
p1.x = 10, p1.y = 15
p2.x = 10, p2.y = 15

14
BCA 3rd year Lab C++ Reference Number:19233015

Static data members

#include <iostream>
using namespace std;

class A
{
int x;
public:
A() { cout << "A's constructor called " << endl; }
};

class B
{
static A a;
public:
B() { cout << "B's constructor called " << endl; }
static A getA() { return a; }
};

A B::a; // definition of a

int main()
{
B b1, b2, b3;
A a = b1.getA();

return 0;
}

15
BCA 3rd year Lab C++ Reference Number:19233015

Output:
A's constructor called
B's constructor called
B's constructor called
B's constructor called

16
BCA 3rd year Lab C++ Reference Number:19233015

Overloading unary operator

// C++ program to show unary operator overloading
#include <iostream>

using namespace std;

class Distance {
public:

// Member Object
int feet, inch;

// Constructor to initialize the object's value

Distance(int f, int i)
{
this->feet = f;
this->inch = i;
}

// Overloading(-) operator to perform decrement

// operation of Distance object
void operator-()
{
feet--;
inch--;
cout << "\nFeet & Inches(Decrement): " << feet << "'" << inch;
}
};

// Driver Code
int main()
{
// Declare and Initialize the constructor
Distance d1(8, 9);
// Use (-) unary operator by single operand
-d1;
return 0;
}

Output:
Feet & Inches(Decrement): 7'8

Overloading Binary Operator

// C++ program to show binary operator overloading
#include <iostream>

17
BCA 3rd year Lab C++ Reference Number:19233015

using namespace std;

class Distance {
public:
// Member Object
int feet, inch;
// No Parameter Constructor
Distance()
{
this->feet = 0;
this->inch = 0;
}

// Constructor to initialize the object's value

// Parametrized Constructor
Distance(int f, int i)
{
this->feet = f;
this->inch = i;
}

// Overloading (+) operator to perform addition of

// two distance object
Distance operator+(Distance& d2) // Call by reference
{
// Create an object to return
Distance d3;

// Perform addition of feet and inches

d3.feet = this->feet + d2.feet;
d3.inch = this->inch + d2.inch;

// Return the resulting object

return d3;
}
};

// Driver Code
int main()
{
// Declaring and Initializing first object
Distance d1(8, 9);

// Declaring and Initializing second object

Distance d2(10, 2);

18
BCA 3rd year Lab C++ Reference Number:19233015

// Declaring third object

Distance d3;

// Use overloaded operator

d3 = d1 + d2;

// Display the result

cout << "\nTotal Feet & Inches: " << d3.feet << "'" << d3.inch;
return 0;
}
Output:
Total Feet & Inches: 18'11

19
BCA 3rd year Lab C++ Reference Number:19233015

Single Inheritance
// C++ program to explain
// Single inheritance
#include <iostream>
using namespace std;
// base class
class Vehicle {
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
// sub class derived from two 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;
}
Output:
This is a vehicle

Multiple Inheritance
// C++ program to explain

20
BCA 3rd year Lab C++ Reference Number:19233015

// multiple inheritance
#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

21
BCA 3rd year Lab C++ Reference Number:19233015

int main()
{
// creating object of sub class will
// invoke the constructor of base classes
Car obj;
return 0;
}
Output:
This is a Vehicle
This is a 4 wheeler Vehicle

22
BCA 3rd year Lab C++ Reference Number:19233015

Multilevel Inheritance
// C++ program to implement
// Multilevel Inheritance
#include <iostream>
using namespace std;

// base class
class Vehicle
{
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
class fourWheeler: public Vehicle
{ public:
fourWheeler()
{
cout<<"Objects with 4 wheels are vehicles"<<endl;
}
};
// sub class derived from two base classes
class Car: public fourWheeler{
public:
car()
{
cout<<"Car has 4 Wheels"<<endl;

23
BCA 3rd year Lab C++ Reference Number:19233015

}
};

// main function
int main()
{
//creating object of sub class will
//invoke the constructor of base classes
Car obj;
return 0;
}
output:
This is a Vehicle
Objects with 4 wheels are vehicles
Car has 4 Wheels

24
BCA 3rd year Lab C++ Reference Number:19233015

Hybrid (Virtual) Inheritance

// C++ program for Hybrid Inheritance

#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

25
BCA 3rd year Lab C++ Reference Number:19233015

};

// 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;
}
Output:
This is a Vehicle
Fare of Vehicle

26
BCA 3rd year Lab C++ Reference Number:19233015

Hierarchical Inheritance
// C++ program to implement
// Hierarchical Inheritance
#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
{

};

27
BCA 3rd year Lab C++ Reference Number:19233015

// main function
int main()
{
// creating object of sub class will
// invoke the constructor of base class
Car obj1;
Bus obj2;
return 0;
}
Output:
This is a Vehicle
This is a Vehicle

28
BCA 3rd year Lab C++ Reference Number:19233015

Virtual Function
// CPP program to illustrate
// working of Virtual Functions
#include <iostream>
using namespace std;

class base {
public:
void fun_1() { cout << "base-1\n"; }
virtual void fun_2() { cout << "base-2\n"; }
virtual void fun_3() { cout << "base-3\n"; }
virtual void fun_4() { cout << "base-4\n"; }
};

class derived : public base {

public:
void fun_1() { cout << "derived-1\n"; }
void fun_2() { cout << "derived-2\n"; }
void fun_4(int x) { cout << "derived-4\n"; }
};

int main()
{
base* p;
derived obj1;
p = &obj1;

// Early binding because fun1() is non-virtual

29
BCA 3rd year Lab C++ Reference Number:19233015

// in base
p->fun_1();

// Late binding (RTP)

p->fun_2();

// Late binding (RTP)

p->fun_3();

// Late binding (RTP)

p->fun_4();

// Early binding but this function call is

// illegal(produces error) becasue pointer
// is of base type and function is of
// derived class
// p->fun_4(5);
}
Output:
base-1
derived-2
base-3
base-4

30
BCA 3rd year Lab C++ Reference Number:19233015

Pure Virtual Functions

#include<iostream>
using namespace std;

class Base
{
int x;
public:
virtual void fun() = 0;
int getX() { return x; }
};
// This class inherits from Base and implements fun()
class Derived: public Base
{
int y;
public:
void fun() { cout << "fun() called"; }
};
int main(void)
{
Derived d;
d.fun();
return 0;
}
Output:
fun() called

put() and gets() function

 Using the put() function to perform the file output operation.

31
BCA 3rd year Lab C++ Reference Number:19233015

//Writing data to a file using ofstream class and mode ios::out

#include<iostream>
#include<fstream>
#include<cstring>

using namespace std;

int main()
{

//Creating an output stream to write data to a file

ofstream ofstream_ob;

//Opening a file named File2.txt to modify the old content

ofstream_ob.open("File2.txt", ios::out);

char arr[100] = "Hello World. We wish you best in everything. Never give up!";

int length = strlen(arr);

char ch;

//Reading the char array i.e. a character at a time and writing it to the file
for(int i=0; i<length; i++)
{
ch = arr[i];
ofstream_ob.put(ch); //Writing a character to a file using put() function
}

32
BCA 3rd year Lab C++ Reference Number:19233015

//Closing the output stream

ofstream_ob.close();

return 0;
}
Output

Executing this program will create a new file named File2.txt in the current directory and we
have even written the content of this file using put function. The content of the file looks like this
:

File2.txt
Hello World. We wish you best in everything. Never give up!

33
BCA 3rd year Lab C++ Reference Number:19233015

gets()

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
char str[100];
cout << "Enter a string: ";
gets(str);
cout << "You entered: " << str;

return 0;
}
Output:

Enter a string: Have a great day!

You entered: Have a great day!

34
BCA 3rd year Lab C++ Reference Number:19233015

read() and write() Functions

//Writing a class object to a file using ofstream class and mode ios::out

#include<iostream>
#include<fstream>

using namespace std;

class A
{
private:
char name[40];
int age;
float height;
char gender;

public:
void putdata();
void getdata();
};
//Defining the function putdata() to enter the values of data members of an object.
void A :: putdata()
{
cout<<"Enter the name : ";
cin.getline(name,40);
cout<<"Enter the age : ";
cin>>age;

35
BCA 3rd year Lab C++ Reference Number:19233015

cout<<"Enter the height : ";

cin>>height;
cout<<"Enter the gender : ";
cin>>gender;
}
//Defining the function getdata() to read the values of data members of an object.
void A :: getdata()
{
cout<<"The name is : " << name << "\n";
cout<<"The age is : " << age << "\n";
cout<<"The height is : " << height << "\n";
cout<<"The gender is : " << gender << "\n";
}
int main()
{
//Creating an output stream
ofstream ofstream_ob;
//Calling the open function to write an object to a file
ofstream_ob.open("File9.txt", ios::out);

//Creating an object of A class

A ob1;
//Calling the putdata() function
ob1.putdata();
//Calling the write() function to write an object to a file.
ofstream_ob.write( (char *) & ob1, sizeof(ob1));
cout<<"Congrats! Your object is successfully written to the file \n";

36
BCA 3rd year Lab C++ Reference Number:19233015

//Closing the output stream

ofstream_ob.close();
//Creating an input stream
ifstream ifstream_ob;
//Calling the open function to read an object from a file
ifstream_ob.open("File11.txt", ios::in);
//Creating an empty object of A class
A ob2;
cout<<"\nReading the object from a file : \n";
//Calling the read() function to read an object from a file and transfer its content to an empty
object
ifstream_ob.read( (char *) & ob2, sizeof(ob2));
//Calling the getdata() function
ob2.getdata();
//Closing the input stream
ifstream_ob.close();
return 0;
}

37
BCA 3rd year Lab C++ Reference Number:19233015

Output
Enter the name : Arthur
Enter the age : 29
Enter the height : 1.78
Enter the gender : M

Congrats! Your object is successfully written to the file

Reading the object from a file :

The name is : Arthur
The age is : 29
The height is : 1.78
The gender is : M

38