pompey

--------------------------
Post Title 'OOC Assignment-2 Answers'
Post by user 'Adusumilli-Uday-Kumar'
Post encryped with secure 256-bit MD5 Encryption
Post accesable only VIA link
Post will Expire on '3-OCT-2017'
--------------------------

Q1.

C   is able to input and output the built-in data types using the stream extraction operator >> and the stream insertion operator <<. The stream insertion and stream extraction operators also can be overloaded to perform input and output for user-defined types like an object. It's an alternative to the printf() function and is used in combination with the 'cin' and 'cout' operators, which are objects of the istream_withassign and ostream_withassign classes respectively.

Eg...
Let Distance be a class with a 2-parameter constructor with elemnts like feet, inches, etc.
We can use the insertion operators as follows operators as shown below,

   Distance D1(11, 10), D2(5, 11), D3;
   cin >> D3;
   cout << "First value : " << D3.feet << endl;
   cout << "Second value :" << 234 << endl;
   cin >> SOME_VARIABLE ;
   cout << "Third value :" << SOME_VARIABLE << endl;

Q2.

Any C/C  / Java program starts from main function and all functionss are called directly or indirectly through the main function. Just like variables we also need to declare function before using it in our programs. Function declaration is also called as function prototype.
If function definition is written after main then and only then do we write the  prototype declaration in global declaration section.

Examples of prototype declaration...

Function with two integer arguments and integer as return type is represented using below syntax

int sum(int,int);

Function with integer argument and integer as return type is represented using below syntax

int square(int);

Why do we need them ?

Program Execution always starts from main , but during lexical analysis (1st Phase of Compiler) token generation starts from left to right and from top to bottom. Thus, If function definition is written after main function, then, during the code generation phase of compiler it may face issue of backward reference and throws an error.
to avoid this we use prototype declaration, which tells compiler that we are going to define this function somewhere in the program. Now, the compiler will have prior information ,during function calling compiler looks forward in the program for the function definition.

Q3.

Members of a class are private by default and members of struct are public by default. STRUCT is a type of Abstract Data Type that divides up a given chunk of memory according to the structure specification.
Classes are a different type of abstract data type that attempt to ensure information hiding. Internally, there can be a variety of machinations, methods, temp variables, state variables. etc. that are all used to present a consistent API to any code which wishes to use the class.

In effect, structs are about data, classes are about code.

Q4.

Class

Class is a user defined data type, which holds its own data members and member functions, which can be accessed and used by creating instance of that class.
For example : Class of birds, all birds can fly and they all have wings and beaks. So here flying is a behavior and wings and beaks are part of their characteristics.
And there are many different birds in this class with different names but they all posses this behavior and characteristics.
Similarly, class is just a blue print, which declares and defines characteristics and behavior, namely data members and member functions respectively. And all objects of this class will share these characteristics and behavior.

Objects

Class is mere a blueprint or a template. No storage is assigned when we define a class. Objects are instances of class, which holds the data variables declared in class and the member functions work on these class objects.
Each object has different data variables. Objects are initialised using special class functions called Constructors. We will study about constructors later.
And whenever the object is out of its scope, another special class member function called Destructor is called, to release the memory reserved by the object. C   doesn't have Automatic Garbage Collector like in JAVA, in C   Destructor performs this task.
Example :

class Abc
{
 int x;
 void display(){} //empty function
};

in main()
{
 Abc obj;   // Object of class Abc created
}

Q5.

class cuboid
{
public:
float lenght, breadth, height;
void input(){cout<<"enter the lenght, breadth and height : "; cin >>lenght>>breadth>>height;}
void output(){cout<<"lenght is "<<lenght<<"\n breadth is "<<breadth<<"\n height is"<<height<<endl;}
void surface-area(){cout<<"surcafe area is<<(2*(lenght breadth height));}
}

Q6.

Data abstraction refers to, providing only essential information to the outside world and hiding their background details, i.e., to represent the needed information in program without presenting the details.
Data abstraction is a programming (and design) technique that relies on the separation of interface and implementation.
C   classes provides great level of data abstraction. They provide sufficient public methods to the outside world to play with the functionality of the object and to manipulate object data, i.e., state without actually knowing how class has been implemented internally.

For example, your program can make a call to the sort() function without knowing what algorithm the function actually uses to sort the given values. In fact, the underlying implementation of the sorting functionality could change between releases of the library, and as long as the interface stays the same, your function call will still work.
Example...
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;
};

Q7.

A member function can either be defined inside the class itself, or, the func can be prototyoed in side the class and defined outside.
defining a func inside a class makes it an inline func.
Example...
class abc{
int a(){return 232;} // inline function
int b; // function prototype
}

int abc::b(){return 9993;} // function definition outside the class

Q8.

Every object in C   has access to its own address through an important pointer called this pointer. The this pointer is an implicit parameter to all member functions. Therefore, inside a member function, this may be used to refer to the invoking object. 'this' pointer is crutial in the process of compilation where, c   code is first converted to c lang code before converting it into an object file.
Example...
class Test
{
private:
   int x;
public:
   void setX (int x)
   {
       // The 'this' pointer is used to retrieve the object's x
       // hidden by the local variable 'x'
       this->x = x;
   }
   void print() { cout << "x = " << x << endl; }
};

int main()
{
   Test obj;
   int x = 20;
   obj.setX(x);
   obj.print();
   return 0;
}

Q9.

Member functions of a class can be overloaded the same way we overload regular functions, except, we do so within a class.

Q10.

When a normal function call instruction is encountered, the program stores the memory address of the next instruction, loads the function being called into the memory, copies argument values, jumps to the memory location of the called function, executes the function codes, stores the return value of the function, and then jumps back to the address of the instruction that was saved just before executing the called function. Too much run time overhead.
The inline functions are a C   enhancement feature to increase the execution time of a program. Functions can be instructed to compiler to make them inline so that compiler can replace those function definition wherever those are being called. Compiler replaces the definition of inline functions at compile time instead of referring function definition at runtime.
NOTE- This is just a suggestion to compiler to make the function inline, if function is big (in term of executable instruction etc) then, compiler can ignore the “inline” request and treat the function as normal function.
To make any function as inline, start its definitions with the keyword “inline”.
Pros :-
1.	It speeds up your program by avoiding function calling overhead.
2.	It save overhead of variables push/pop on the stack, when function calling happens.
3.	It save overhead of return call from a function.