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
