UNIT-2

Pointers, Arrays, Dynamic allocation Operator

Q1) Create an object and a class

A1)

Create a Class

To create a class, use the class keyword:

Example

Create a class called "MyClass":

class MyClass {       // The class
  public:             // Access specifier
    int myNum;        // Attribute (int variable)
    string myString;  // Attribute (string variable)
};

Example explained

Create an Object

In C++, an object is created from a class. We have already created the class named MyClass, so now we can use this to create objects.

To create an object of MyClass, specify the class name, followed by the object name.

To access the class attributes (myNum and myString), use the dot syntax (.) on the object:

Example

Create an object called "myObj" and access the attributes:

class MyClass {       // The class
  public:             // Access specifier
    int myNum;        // Attribute (int variable)
    string myString;  // Attribute (string variable)
};

int main() {
  MyClass myObj;  // Create an object of MyClass

  // Access attributes and set values
  myObj.myNum = 15; 
  myObj.myString = "Some text";

  // Print attribute values
  cout << myObj.myNum << "\n";
  cout << myObj.myString;
  return 0;
}

Q2) Explain in detail Visibility/Access Modifiers with examples?

A2)

Data hiding is one of the important features of Object Oriented Programming which allows preventing the functions of a program to access directly the internal representation of a class type. The access restriction to the class members is specified by the labeled public, private, and protected sections within the class body. The keywords public, private, and protected are called access specifiers.

A class can have multiple public, protected, or private labeled sections. Each section remains in effect until either another section label or the closing right brace of the class body is seen. The default access for members and classes is private.

class Base {

   public:

      // public members go here

      protected:

   // protected members go here

   private:

   // private members go here

};

The public Members

A public member is accessible from anywhere outside the class but within a program. You can set and get the value of public variables without any member function as shown in the following example −

#include <iostream>

using namespace std;

class Line {

   public:

      double length;

      void setLength( double len );

      double getLength( void );

};

// Member functions definitions

double Line::getLength(void) {

   return length ;

}

void Line::setLength( double len) {

   length = len;

}

// Main function for the program

int main() {

   Line line;

   // set line length

   line.setLength(6.0);

   cout << "Length of line : " << line.getLength() <<endl;

   // set line length without member function

   line.length = 10.0; // OK: because length is public

   cout << "Length of line : " << line.length <<endl;

   return 0;

}

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

Length of line : 6

Length of line : 10

The private Members

A private member variable or function cannot be accessed, or even viewed from outside the class. Only the class and friend functions can access private members.

By default all the members of a class would be private, for example in the following class width is a private member, which means until you label a member, it will be assumed a private member −

class Box {

   double width;

   public:

      double length;

      void setWidth( double wid );

      double getWidth( void );

};

Practically, we define data in private section and related functions in public section so that they can be called from outside of the class as shown in the following program.

#include <iostream>

using namespace std;

class Box {

   public:

      double length;

      void setWidth( double wid );

      double getWidth( void );

   private:

      double width;

};

// Member functions definitions

double Box::getWidth(void) {

   return width ;

}

void Box::setWidth( double wid ) {

   width = wid;

}

// Main function for the program

int main() {

   Box box;

   // set box length without member function

   box.length = 10.0; // OK: because length is public

   cout << "Length of box : " << box.length <<endl;

   // set box width without member function

   // box.width = 10.0; // Error: because width is private

   box.setWidth(10.0);  // Use member function to set it.

   cout << "Width of box : " << box.getWidth() <<endl;

   return 0;

}

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

Length of box : 10

Width of box : 10

The protected Members

A protected member variable or function is very similar to a private member but it provided one additional benefit that they can be accessed in child classes which are called derived classes.

You will learn derived classes and inheritance in next chapter. For now you can check following example where I have derived one child class SmallBox from a parent class Box.

Following example is similar to above example and here width member will be accessible by any member function of its derived class SmallBox.

#include <iostream>

using namespace std;

class Box {

   protected:

      double width;

};

class SmallBox:Box { // SmallBox is the derived class.

   public:

      void setSmallWidth( double wid );

      double getSmallWidth( void );

};

// Member functions of child class

double SmallBox::getSmallWidth(void) {

   return width ;

}

void SmallBox::setSmallWidth( double wid ) {

   width = wid;

}

// Main function for the program

int main() {

   SmallBox box;

   // set box width using member function

   box.setSmallWidth(5.0);

   cout << "Width of box : "<< box.getSmallWidth() << endl;

   return 0;

}

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

Width of box : 5

Q3) Explain Encapsulation in details with examples?

A3)

All C++ programs are composed of the following two fundamental elements −

Encapsulation is an Object Oriented Programming concept that binds together the data and functions that manipulate the data, and that keeps both safe from outside interference and misuse. Data encapsulation led to the important OOP concept of data hiding.

Data encapsulation is a mechanism of bundling the data, and the functions that use them and data abstraction is a mechanism of exposing only the interfaces and hiding the implementation details from the user.

C++ supports the properties of encapsulation and data hiding through the creation of user-defined types, called classes. We already have studied that a class can contain private, protected and public members. By default, all items defined in a class are private. For example −

class Box {

   public:

      double getVolume(void) {

         return length * breadth * height;

      }

   private:

      double length;      // Length of a box

      double breadth;     // Breadth of a box

      double height;      // Height of a box

};

The variables length, breadth, and height are private. This means that they can be accessed only by other members of the Box class, and not by any other part of your program. This is one way encapsulation is achieved.

To make parts of a class public (i.e., accessible to other parts of your program), you must declare them after the public keyword. All variables or functions defined after the public specifier are accessible by all other functions in your program.

Making one class a friend of another exposes the implementation details and reduces encapsulation. The ideal is to keep as many of the details of each class hidden from all other classes as possible.

Data Encapsulation Example

Any C++ program where you implement a class with public and private members is an example of data encapsulation and data abstraction. Consider the following example –

#include <iostream>

using namespace std;

class Adder {

   public:

      // constructor

      Adder(int i = 0) {

         total = i;

      }

      // interface to outside world

      void addNum(int number) {

         total += number;

      }

      // interface to outside world

      int getTotal() {

         return total;

      };

   private:

      // hidden data from outside world

      int total;

};

int main() {

   Adder a;

   a.addNum(10);

   a.addNum(20);

   a.addNum(30);

   cout << "Total " << a.getTotal() <<endl;

   return 0;

}

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

Total 60

Above class adds numbers together, and returns the sum. The public members addNum and getTotal are the interfaces to the outside world and a user needs to know them to use the class. The private member total is something that is hidden from the outside world, but is needed for the class to operate properly.

Designing Strategy

Most of us have learnt to make class members private by default unless we really need to expose them. That's just good encapsulation.

This is applied most frequently to data members, but it applies equally to all members, including virtual functions.

Q5) Explain Methods: Adding a Method to Class?

A5)

Methods are functions that belongs to the class.

There are two ways to define functions that belongs to a class:

In the following example, we define a function inside the class, and we name it "myMethod".

Note: You access methods just like you access attributes; by creating an object of the class and by using the dot syntax (.):

Inside Example

class MyClass {        // The class
  public:              // Access specifier
    void myMethod() {  // Method/function defined inside the class
      cout << "Hello World!";
    }
};

int main() {
  MyClass myObj;     // Create an object of MyClass
  myObj.myMethod();  // Call the method
  return 0;
}

To define a function outside the class definition, you have to declare it inside the class and then define it outside of the class. This is done by specifiying the name of the class, followed the scope resolution :: operator, followed by the name of the function:

Outside Example

class MyClass {        // The class
  public:              // Access specifier
    void myMethod();   // Method/function declaration
};

// Method/function definition outside the class
void MyClass::myMethod() {
  cout << "Hello World!";
}

int main() {
  MyClass myObj;     // Create an object of MyClass
  myObj.myMethod();  // Call the method
  return 0;
}

Parameters

You can also add parameters:

 Example

#include <iostream>
using namespace std;

class Car {
  public:
    int speed(int maxSpeed);
};

int Car::speed(int maxSpeed) {
  return maxSpeed;
}

int main() {
  Car myObj; // Create an object of Car
  cout << myObj.speed(200); // Call the method with an argument
  return 0;
}

Q6) Explain Returning a Value?

A6)

A C++ program can be made easier to read and maintain by using references rather than pointers. A C++ function can return a reference in a similar way as it returns a pointer.

When a function returns a reference, it returns an implicit pointer to its return value. This way, a function can be used on the left side of an assignment statement. For example, consider this simple program −

#include <iostream>

#include <ctime>

using namespace std;

double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};

double& setValues( int i ) {

   return vals[i];   // return a reference to the ith element

}

// main function to call above defined function.

int main () {

   cout << "Value before change" << endl;

   for ( int i = 0; i < 5; i++ ) {

      cout << "vals[" << i << "] = ";

      cout << vals[i] << endl;

   }

   setValues(1) = 20.23; // change 2nd element

   setValues(3) = 70.8;  // change 4th element

   cout << "Value after change" << endl;

   for ( int i = 0; i < 5; i++ ) {

      cout << "vals[" << i << "] = ";

      cout << vals[i] << endl;

   }

   return 0;

}

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

Value before change

vals[0] = 10.1

vals[1] = 12.6

vals[2] = 33.1

vals[3] = 24.1

vals[4] = 50

Value after change

vals[0] = 10.1

vals[1] = 20.23

vals[2] = 33.1

vals[3] = 70.8

vals[4] = 50

When returning a reference, be careful that the object being referred to does not go out of scope. So it is not legal to return a reference to local var. But you can always return a reference on a static variable.

int& func() {

   int q;

   //! return q; // Compile time error

   static int x;

   return x;     // Safe, x lives outside this scope

}

Q7) Explain Recursivity?

A7)

Recursivity is the property that functions have to be called by themselves. It is useful for some tasks, such as sorting elements, or calculating the factorial of numbers. For example, in order to obtain the factorial of a number (n!) the mathematical formula would be:

n! = n * (n-1) * (n-2) * (n-3) ... * 1
More concretely, 5! (factorial of 5) would be:

5! = 5 * 4 * 3 * 2 * 1 = 120
And a recursive function to calculate this in C++ could be:

Notice how in function factorial we included a call to itself, but only if the argument passed was greater than 1, since, otherwise, the function would perform an infinite recursive loop, in which once it arrived to 0, it would continue multiplying by all the negative numbers (probably provoking a stack overflow at some point during runtime).

Q8)Explain The ‘this’ Keyword?

A8)

In C++ programming, this is a keyword that refers to the current instance of the class. There can be 3 main usage of this keyword in C++.

C++ this Pointer Example

Let's see the example of this keyword in C++ that refers to the fields of current class.

Output:

101  Sonoo  890000

102  akul  59000

Q9) Explain Function Overloading?

Q9)

Function Overloading is defined as the process of having two or more function with the same name, but different in parameters is known as function overloading in C++. In function overloading, the function is redefined by using either different types of arguments or a different number of arguments. It is only through these differences compiler can differentiate between the functions.

The advantage of Function overloading is that it increases the readability of the program because you don't need to use different names for the same action.

C++ Function Overloading Example

Let's see the simple example of function overloading where we are changing number of arguments of add() method.

// program of function overloading when number of arguments vary.

Output:

30

55

Let's see the simple example when the type of the arguments vary.

// Program of function overloading with different types of arguments.

Output:

r1 is : 42

r2 is : 0.6 

Q10) Explain Operators Overloading?

Q10)

Operator overloading is a compile-time polymorphism in which the operator is overloaded to provide the special meaning to the user-defined data type. Operator overloading is used to overload or redefines most of the operators available in C++. It is used to perform the operation on the user-defined data type. For example, C++ provides the ability to add the variables of the user-defined data type that is applied to the built-in data types.

The advantage of Operators overloading is to perform different operations on the same operand.

Operator that cannot be overloaded are as follows:

Syntax of Operator Overloading

Where the return type is the type of value returned by the function.

class_name is the name of the class.

operator op is an operator function where op is the operator being overloaded, and the operator is the keyword.

Rules for Operator Overloading

Q11) Explain Array of Objects

A11)

Syntax:

class_name array_name [size] ;

Example:

#include <iostream> 

class MyClass { 

  int x; 

public: 

  void setX(int i) { x = i; } 

  int getX() { return x; } 

}; 

void main() 

{ 

  MyClass obs[4]; 

  int i; 

  for(i=0; i < 4; i++) 

    obs[i].setX(i); 

  for(i=0; i < 4; i++) 

    cout << "obs[" << i << "].getX(): " << obs[i].getX() << "\n"; 

  getch(); 

}

Output:

obs[0].getX(): 0
obs[1].getX(): 1
obs[2].getX(): 2
obs[3].getX(): 3