Unit - 4

Classes and Data Abstraction

Q1) Explain structure

A1)

In C++, classes and structs are blueprints that are used to create the instance of a class. Structs are used for lightweight objects such as Rectangle, color, Point, etc.

Unlike class, structs in C++ are value type than reference type. It is useful if you have data that is not intended to be modified after creation of struct.

C++ Structure is a collection of different data types. It is similar to the class that holds different types of data.

The Syntax Of Structure

1. Struct structure_name  
2. {  
3.     // member declarations.  
4. }   

In the above declaration, a structure is declared by preceding the struct keyword followed by the identifier(structure name). Inside the curly braces, we can declare the member variables of different types. Consider the following situation:

1. Struct Student  
2. {  
3.    Char name[20];  
4.     Int id;  
5.     Int age;  
6. }  

In the above case, Student is a structure contains three variables name, id, and age. When the structure is declared, no memory is allocated. When the variable of a structure is created, then the memory is allocated. Let's understand this scenario.

How to create the instance of Structure?

Structure variable can be defined as:

Student s;

Here, s is a structure variable of type Student. When the structure variable is created, the memory will be allocated. Student structure contains one char variable and two integer variable. Therefore, the memory for one char variable is 1 byte and two ints will be 2*4 = 8. The total memory occupied by the s variable is 9 byte.

How to access the variable of Structure:

The variable of the structure can be accessed by simply using the instance of the structure followed by the dot (.) operator and then the field of the structure.

For example:

1. s.id = 4;  

In the above statement, we are accessing the id field of the structure Student by using the dot(.) operator and assigns the value 4 to the id field.

Q2) Give some examples of structure

A2)

C++ Struct Example

Let's see a simple example of struct Rectangle which has two data members width and height.

1. #include <iostream>    
2. Using namespace std;    
3. Struct Rectangle      
4. {      
5.   Int width, height;      
6.      
7. };      
8. Int main(void) {    
9.    Struct Rectangle rec;    
10.    Rec.width=8;    
11.    Rec.height=5;    
12.   Cout<<"Area of Rectangle is: "<<(rec.width * rec.height)<<endl;    
13. Return 0;    
14. }    

Output:

Area of Rectangle is: 40

C++ Struct Example: Using Constructor and Method

Let's see another example of struct where we are using the constructor to initialize data and method to calculate the area of rectangle.

1. #include <iostream>    
2. Using namespace std;    
3. Struct Rectangle    {      
4.   Int width, height;      
5.  Rectangle(int w, int h)      
6.    {      
7.        Width = w;      
8.        Height = h;      
9.    }      
10.  Void areaOfRectangle() {       
11.    Cout<<"Area of Rectangle is: "<<(width*height); }      
12. };      
13. Int main(void) {    
14.    Struct Rectangle rec=Rectangle(4,6);    
15.    Rec.areaOfRectangle();    
16.   Return 0;    
17. }    

Output:

Area of Rectangle is: 24

Q3) Difference in structure and class

A3)

Structure v/s Class

Q4) Explain object and class

A4)

Since C++ is an object-oriented language, program is designed using objects and classes in C++.

C++ Object

In C++, Object is a real world entity, for example, chair, car, pen, mobile, laptop etc.

In other words, object is an entity that has state and behavior. Here, state means data and behavior means functionality.

Object is a runtime entity, it is created at runtime.

Object is an instance of a class. All the members of the class can be accessed through object.

Let's see an example to create object of student class using s1 as the reference variable.

1. Student s1;  //creating an object of Student      

In this example, Student is the type and s1 is the reference variable that refers to the instance of Student class.

C++ Class

In C++, object is a group of similar objects. It is a template from which objects are created. It can have fields, methods, constructors etc.

Let's see an example of C++ class that has three fields only.

1. Class Student    
2. {    
3.     Public:  
4.     Int id;  //field or data member     
5.     Float salary; //field or data member  
6.     String name;//field or data member    
7. }    

Q5) Give a Class Example: Store and Display Employee Information

A5)

Let's see another example of C++ class where we are storing and displaying employee information using method.

1. #include <iostream>  
2. Using namespace std;  
3. Class Employee {  
4.   Public:  
5.       Int id;//data member (also instance variable)      
6.       String name;//data member(also instance variable)  
7.       Float salary;  
8.       Void insert(int i, string n, float s)    
9.        {    
10.            Id = i;    
11.            Name = n;    
12.            Salary = s;  
13.        }    
14.       Void display()    
15.        {    
16.            Cout<<id<<"  "<<name<<"  "<<salary<<endl;    
17.        }    
18. };  
19. Int main(void) {  
20.    Employee e1; //creating an object of Employee   
21.    Employee e2; //creating an object of Employee  
22.    e1.insert(201, "Sonoo",990000);    
23.    e2.insert(202, "Nakul", 29000);    
24.    e1.display();    
25.    e2.display();    
26.    Return 0;  
27. }  

Output:

202 onoo  990000

202  Nakul  29000

Q6) Give a Class Example: Initialize and Display data through method

A6)

Let's see another example of C++ class where we are initializing and displaying object through method.

1. #include <iostream>  
2. Using namespace std;  
3. Class Student {  
4.   Public:  
5.       Int id;//data member (also instance variable)      
6.       String name;//data member(also instance variable)      
7.       Void insert(int i, string n)    
8.        {    
9.            Id = i;    
10.            Name = n;    
11.        }    
12.       Void display()    
13.        {    
14.            Cout<<id<<"  "<<name<<endl;    
15.        }    
16. };  
17. Int main(void) {  
18.    Student s1; //creating an object of Student   
19.    Student s2; //creating an object of Student  
20.    s1.insert(201, "Sonoo");    
21.    s2.insert(202, "Nakul");    
22.    s1.display();    
23.    s2.display();  
24.    Return 0;  
25. }  

Output:

202 onoo

202  Nakul

Q7) Explain Function Overloading

A7)

You can have multiple definitions for the same function name in the same scope. The definition of the function must differ from each other by the types and/or the number of arguments in the argument list. You cannot overload function declarations that differ only by return type.

Following is the example where same function print() is being used to print different data types –

#include <iostream>

Using namespace std;

Class printData {

   public:

      void print(int i) {

        cout << "Printing int: " << i << endl;

      }

      void print(double  f) {

        cout << "Printing float: " << f << endl;

      }

      void print(char* c) {

        cout << "Printing character: " << c << endl;

      }

};

Int main(void) {

   printData pd;

   // Call print to print integer

   pd.print(5);

   // Call print to print float

   pd.print(500.263);

   // Call print to print character

   pd.print("Hello C++");

   return 0;

}

When the above code is compiled and executed, it produces the following result −

Printing int: 5

Printing float: 500.263

Printing character: Hello C++

Q8) Explain Operators Overloading

A8)

You can redefine or overload most of the built-in operators available in C++. Thus, a programmer can use operators with user-defined types as well.

Overloaded operators are functions with special names: the keyword "operator" followed by the symbol for the operator being defined. Like any other function, an overloaded operator has a return type and a parameter list.

Box operator+(const Box&);

Declares the addition operator that can be used to add two Box objects and returns final Box object. Most overloaded operators may be defined as ordinary non-member functions or as class member functions. In case we define above function as non-member function of a class then we would have to pass two arguments for each operand as follows −

Box operator+(const Box&, const Box&);

Following is the example to show the concept of operator over loading using a member function. Here an object is passed as an argument whose properties will be accessed using this object, the object which will call this operator can be accessed using this operator as explained below –

#include <iostream>

Using namespace std;

Class Box {

   public:

      double getVolume(void) {

         return length * breadth * height;

      }

      void setLength( double len ) {

         length = len;

      }

      void setBreadth( double bre ) {

         breadth = bre;

      }

      void setHeight( double hei ) {

         height = hei;

      }

      // Overload + operator to add two Box objects.

      Box operator+(const Box& b) {

         Box box;

         box.length = this->length + b.length;

         box.breadth = this->breadth + b.breadth;

         box.height = this->height + b.height;

         return box;

      }

   private:

      double length;      // Length of a box

      double breadth;     // Breadth of a box

      double height;      // Height of a box

};

// Main function for the program

Int main() {

   Box Box1;                // Declare Box1 of type Box

   Box Box2;                // Declare Box2 of type Box

   Box Box3;                // Declare Box3 of type Box

   double volume = 0.0;     // Store the volume of a box here

   // box 1 specification

   Box1.setLength(6.0);

   Box1.setBreadth(7.0);

   Box1.setHeight(5.0);

   // box 2 specification

   Box2.setLength(12.0);

   Box2.setBreadth(13.0);

   Box2.setHeight(10.0);

   // volume of box 1

   volume = Box1.getVolume();

   cout << "Volume of Box1 : " << volume <<endl;

   // volume of box 2

   volume = Box2.getVolume();

   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:

   Box3 = Box1 + Box2;

   // volume of box 3

   volume = Box3.getVolume();

   cout << "Volume of Box3 : " << volume <<endl;

   return 0;

}

When the above code is compiled and executed, it produces the following result −

Volume of Box1 : 210

Volume of Box2 : 1560

Volume of Box3 : 5400

Q9) Explain assignment operator with example

A9)

You can overload the assignment operator (=) just as you can other operators and it can be used to create an object just like the copy constructor.

Following example explains how an assignment operator can be overloaded.

#include <iostream>

Using namespace std;

Class Distance {

   private:

      int feet;             // 0 to infinite

      int inches;           // 0 to 12

   public:

      // required constructors

      Distance() {

         feet = 0;

         inches = 0;

      }

      Distance(int f, int i) {

         feet = f;

         inches = i;

      }

      void operator = (const Distance &D ) {

         feet = D.feet;

         inches = D.inches;

      }

      // method to display distance

      void displayDistance() {

         cout << "F: " << feet <<  " I:" <<  inches << endl;

      }

};

Int main() {

   Distance D1(11, 10), D2(5, 11);

   cout << "First Distance : ";

   D1.displayDistance();

   cout << "Second Distance :";

   D2.displayDistance();

   // use assignment operator

   D1 = D2;

   cout << "First Distance :";

   D1.displayDistance();

   return 0;

}

When the above code is compiled and executed, it produces the following result −

First Distance : F: 11 I:10

Second Distance :F: 5 I:11

First Distance :F: 5 I:11

Q10) Explain Passing parameters by references

A10)

We have discussed how we implement call by reference concept using pointers. Here is another example of call by reference which makes use of C++ reference −

#include <iostream>

Using namespace std;

// function declaration

Void swap(int& x, int& y);

Int main () {

   // local variable declaration:

   int a = 100;

   int b = 200;

   cout << "Before swap, value of a :" << a << endl;

   cout << "Before swap, value of b :" << b << endl;

   /* calling a function to swap the values.*/

   swap(a, b);

   cout << "After swap, value of a :" << a << endl;

   cout << "After swap, value of b :" << b << endl;

   return 0;

}

// function definition to swap the values.

Void swap(int& x, int& y) {

   int temp;

   temp = x; /* save the value at address x */

   x = y;   /* put y into x */

   y = temp; /* put x into y */

   return;

}

When the above code is compiled and executed, it produces the following result −

Before swap, value of a :100

Before swap, value of b :200

After swap, value of a :200

After swap, value of b :100