SOLUTION

Polymorphism is the ability to use an operator or function in different ways. Polymorphism gives different meanings or functions to the operators or functions. Poly, referring to many, signifies the many uses of these operators and functions.

SOLUTION

If an object has a global scope, then the objects can be used anywhere in the program by any function. If an object has a local scope, then the objects can be used only within the function that declares it.

SOLUTION

A class is a way to bind the data describing an entity and its associated functions together. In C++, class makes a data type that is used to create objects of this type.

SOLUTION

Member functions are the set of operations that may be applied to objects of that class. There may be zero or more member functions for a class. They are referred to as the class interface.

SOLUTION

A class is a way to bind the data describing an entity and its associated functions together.

SOLUTION

A friend function is used in object-oriented programming to allow access to private or protected data in a class from outside the class.

SOLUTION

In computer science, an inline function is a programming language construct used to tell a compiler it should perform in-line expansion on a particular function.These functions are defined inside the class.

SOLUTION

:: is scope resolution operator. If the Count integer belongs to class X, then it would have been declared as X :: Count. But, since it is global variable, it will be declared as ::Count outside class.

SOLUTION

Accessor functions allow us to access the data number/ field of an object. Example getRollNo()can be an accessor function to roll no. of students.

SOLUTION

Protected means data members and member functions can be used in same class and its derived class.

SOLUTION

With inline code, the compiler replaces the function call statement with the function code itself and then compiles the entire code. This speeds up the process as the compiler doesnot have to jump to another location to execute the function.

SOLUTION

An object may be passed to a member function, a non-member function, and a friend function.

SOLUTION

In dynamic memory allocation, whenever the object is out of scope, its memory would be freed and deallocated. So, a destructor is automatically invoked by the class.

SOLUTION

A friend function is a function that can access the private members of a class as though it were a member of that class. In all other regards, the friend function is just like a normal function. A friend function may or may not be a member of another class.
To declare a friend function, use the friend keyword in front of the prototype of the function you wish to be a friend of the class. It does not matter whether you declare the friend function in the private or public section of the class.

SOLUTION

Private Members are the class members that are hidden from outside world. The private members implement the OOP concept of data hiding. The private members of a class can be used only by member functions (and friends) of the class in which it is declared.

SOLUTION

With inline code, the compiler code replaces the function call statement with the function code itself and then compiles the entire code. Thus, with inline functions, the compiler does not have to jump to another location to execute the function and then jumps back as the code of the called function is already available to the calling program.

SOLUTION

Inline functions run a little faster than the normal functions as function-calling overheads are saved, however, there is a memory penalty. If 10 times an inline function is called, there will be 10 copies of the function inserted into the code.

SOLUTION

Polymorphism : An object is in different forms and in each form it exhibits the same functionality but the implementation is different.

SOLUTION

A static data member is different from ordinary data members of a class in the following aspects :

1. There is only one copy of this data member maintained for the entire class which is shared by all the objects of that class.
2. It is visible only within the class, however, its lifetime is the entire program.

SOLUTION

A member function that accesses only the static members of a class may be declared as static. A static member function can access only static members of the same class. A static member function is invoked by using the class name instead of its objects as it is shown below:
classname::function-name; 

SOLUTION

Private Members are the class members that are hidden from the outside world. The private members implement the OOP concept of data hiding.

SOLUTION

Data members are the data type properties that describe the characteristics of a class. There may be zero or more data members of any type in a class.

SOLUTION

Object is an identifiable entity with some characteristics and behaviour. In OOP, object represents an entity that can store data and has its interface through functions.

SOLUTION

The general form of a class definition looks like :
class class-name
{
   private:
     [variable declarations;]
     [function declarations;]
  protected:
     [variable declarations;]
     [function declarations;]
   public:
     [variable declarations;]
     [function declarations;]
};  For example,
class Sample
{
    int a;
    double b;
    public:
      void add();
      void print();
      ...
};     

SOLUTION

Polymorphisms is the ability to take more than one forms. For example, say a door. A door to a temple, a door to a house, a door to a kitty house,
all are doors, but all look different.

SOLUTION

Abstraction refers to the act of representing essential features without including the background details or explanations.

SOLUTION

Encapsulation refers to wrapping up data and associated functions into one single unit.

SOLUTION

There are generally two types of members in a class : private and public. If no label (public or private) is specified then by default, members are private.

SOLUTION

The keyword class specifies that it is a class; class-name is the tagname of the class that acts as a type specifier for it, using which objects of this class type can be created. The braces { and } surround the body of the class. The class body contains the declaration of its members ( data and functions). These are generally two types of members in a class : private and public. 
The class declaration looks like :
class class-name
{
   private:
     [variable declarations;]
     [function declarations;]
  protected:
     [variable declarations;]
     [function declarations;]
   public:
     [variable declarations;]
     [function declarations;]
};         

SOLUTION

Program access levels control access to members from within the program. These access levels are private, protected or public. Depending upon the access level of a class member, access to it is allowed or denied.

SOLUTION

A class is a way to bind the data describing an entity and its associated functions together. In C++, class makes a data type that is used to create objects of this type.

SOLUTION

Abstraction is the process or result of generalization by reducing the information content of a concept or an observable phenomenon, typically to retain only information which is relevant for a particular purpose.

SOLUTION

Encapsulation is the inclusion of one thing within another thing so that the included thing is not apparent. A class implements encapsulation by bundling data and functions together.

SOLUTION

The member functions are the set of operations that may be applied to objects of that class. There may be zero or more member functions for a class. They are referred to as the class interface.

SOLUTION

The correct syntax for class definition is class classname { data members }

SOLUTION

Member functions cannot access non-member functions of a class and private data can be accessed only by member functions of class.

SOLUTION

The scope resolution operator ::, when used with classname depicts the class member as in classname :: functionname and when used only with the variable name as in ::svariablename, depicts the global variable (the one with the file scope).

SOLUTION

A reference has to be properly initialized, otherwise it will result in an error. In C++, special care is taken for assignment of void pointers to other pointer types. While we can assign a pointer of any type to a void pointer the reverse is not true until we do explicit typecasting.

SOLUTION

An empty class has no variable declarations, no functions or methods but the objects of these classes can have non–zero size.

SOLUTION

Objects are created separately using new operator. A class definition just defines a class and its data members.

SOLUTION

Public member functions can be accessed by any other member or non-member functions of the class as well as outside the class.

SOLUTION

Book Bk[15];

SOLUTION

Public members, that can be called in any function (using the object) constitute the public interface of the class.

SOLUTION

Make only small functions inline. It must fulfill certain other conditions - it must not have a loop, switch or goto if it returns a value, it must not have static variables and must not be recursive.

SOLUTION

Containership refers to an object of a class being a member of another class.

SOLUTION

In object-oriented programming (OOP), an inner class or nested class is a class declared entirely within the body of another class or interface.

SOLUTION

Public members can be called outside the class but Private members can be accessed only by other members of the class. Also, public members can be inherited while private members cannot be.

SOLUTION

When a member function of a class calls another member function, it is known as nesting of member functions.

SOLUTION

The only difference is that private members cannot be inherited outside the class while protected members can be inherited by its derived classes.

SOLUTION

An object is an instance of a class. For a class that has been defined, objects can be created as variables of that class. Each object will have a set of data members defined in the class.

SOLUTION

A friend function is used in object-oriented programming to allow access to private or protected data in a class from the outside. Normally, a function that is not a member of a class cannot access such information; neither can an external class. Occasionally, such access will be advantageous for the programmer. Under these circumstances, the function or external class can be declared as a friend of the class using the friend keyword.

SOLUTION

Members of a class are private by default whereas members of a structure are public by default.

SOLUTION

A static member function is a member function that can access only static data members. It is called using the class name and not with the object as is the case with other member functions.

SOLUTION

char file(); is incorrect as constructor does not have any return type.

SOLUTION

In line 3, the class member cannot be initialized inside a class. In line 10, a1 is assigned a value that is never used.

SOLUTION

exam is the name of the class and In is the name of the object. Inside the brackets, integer value is passed.

SOLUTION

A member function with the same name as its class is called constructor and it is used to initialize the objects of that class type with a legal initial value.

SOLUTION

The object creation is a two-step process. At first, the memory is allocated and then its data members are initialised. For initialisation, constructors are provided which gets called automatically.

SOLUTION

Constructors are like other member functions of the class and hence, can be overloaded. The only difference is that the constructors do not return any value.

SOLUTION

Static memory allocation takes place during compilation whereas dynamic memory allocation takes place during execution.

SOLUTION

Static memory allocation takes place during compilation, whereas, dynamic memory allocation takes place during execution.

SOLUTION

The destructor is a member function that has the same name as the class. It is used to deallocate the memory space and always preceded with a tilde sign(~).

SOLUTION

The copy constructor is invoked when an object is passed by value to a function. The pass-by-value method requires a copy of the passed argument to be created for the function to operate upon.

SOLUTION

A copy constructor is a special constructor in the C++ programming language used to create a new object as a copy of an existing object. This constructor takes a single argument: a reference to the object to be copied.

SOLUTION

A copy constructor is a constructor of the form classname(classname &). The compiler will use the copy constructor whenever you initialize an instance using values of another instance of same type. In copy constructor, if the argument is passed by value instead of reference, the compiler runs out of memory.

SOLUTION

Member functions are used to modify, retrieve or print data whenever required and hence are called explicitly.

SOLUTION

One of the main characteristic of constructor is that it cannot be static.

SOLUTION

Default constructor does not accept any argument. Thats why it is also called as zero-argument constructor.

SOLUTION

Copy constructor takes one argument. Also called as one argument constructor. The main use of copy constructor is to initialize the objects while in creation. Also it is used to copy values of one object into another object.

SOLUTION

In dynamic initialization, values are assigned to the variables during run-time.

SOLUTION

when disp1() function will be called, it will print multiplication of a and b, i.e., 11 and 4 respectively. So 44 will be printed.   when disp2() function will be called, it will print addition of a and b, i.e. , 12 and 21 respectively. So 33 will be displayed.  

SOLUTION

The variables a and b are initialized with 11 and 44 respectively. When object obj called the function disp(), it will display the multiplication of a and b, i.e., 484 

SOLUTION

Function 3 : Destructor
A destructor is called or invoked when an object of that class is destroyed. When a variable goes out of scope or a dynamically allocated variable is explicitly deleted using the delete keyword, the class destructor is called to help clean up the  class  before it is removed from the memory.  

SOLUTION

Static data members are class variables. Only one copy of the static data member is maintained and this is shared by all the objects. They are visible only within the class but their lifetime is the entire program. They can be accessed in all member functions.

SOLUTION

Function f2( ) is a static member function. It is accessing a, which is a non-static data member. Secondly, static data member b is not defined outside the class. 

SOLUTION

      class AC{ int acc_no;

         char name[20];

         char type;

         float balance;

      public:

        void init(){

             cout<<"nEnter Account No.";

             cin>>acc_no;

             cout<<"nName of Account Holder : ";

             cin.getline(name,20);

             cout<<"nType = S or C ";

             cin>>type;

             type=toupper(type);

             cout<<"nBalance : ";

             cin>>balance;

         }

         void disp(){

             cout<<"nAccount No."<< acc_no;

             cout<<"nName of Account Holder : "<< name;

             cout<<"nType = "<< type;

             cout<<"nBalance : "<< balance;

         }

         void deposit(float d){

             balance = balance + d;

             cout<<"nBalance Updated";

         }

         void draw(float d){

             if(balance - d>=1000)

             { balance=balance-d;

             cout<<"nBalance Updated";

            }

             else

             cout<<"Leaves insufficient balance";

         }

SOLUTION

sums( ) can access A::x,   A::y,  A::z,  A::a,  A::b,  ::a,  ::b  

fn( ) can access   A::x,   A::y,  A::z,  A::a,  A::b,  ::a,  ::b

SOLUTION

          class Book{

             int book_code;

             char title[20];

             char author[20];

             int Price;

           public:

             void getbook(){

                 cout << "nEnter Book Code : ";

                 cin >> book_code;

                 cout << "nBook Title : ";

                 cin.getline(title,20);

                 cout << "nBook Author : ";

                 cin.getline(author,20);

                 cout << "nPrice : ";

                 cin >> Price;

             }

             void buybook(){

                 int c;

                 cout << "nHow many copies to buy? ";

                 cin >> c;

                 cout << "nPay Rs."<< price*c;

             }

        };                         

SOLUTION

Yes they can.

The scope of a member function is restricted to the class. It may be called by other members of the class or if called in a non member function, it is linked with an object of the class.

SOLUTION

The class definition gives the data members and member functions. Based on the class definition, objects are declared. Each object will have its own set of data members but there will be one set of functions accessed by all the objects. So, when the class is defined, memory is allocated for member functions and they are stored there. When objects are declared, separate memory space is allocated for each object, sufficient to accommodate all its data members.

SOLUTION

1. Member functions can access private and protected members of the class while non member functions have access to only public members and that too, through the objects.
2. Member functions don't have scope outside the class while non member functions have scope outside the class.

SOLUTION

Advantages of inline function are:-
1) It does not require function calling overhead.
2) It also save overhead of variables push/pop on the stack, while function calling.
3) It also save overhead of return call from a function.
4) It increases locality of reference by utilizing instruction cache.
5) After in-lining compiler can also apply intraprocedural optmization if specified. This is the most important one, in this way compiler can now focus on dead code elimination, can give more stress on branch prediction, induction variable elimination etc..

SOLUTION

    #include < iostream.h>
    #include < ctype.h>

    class DH{int seat;

         char name[20];

         static int taken;

      public:

         void getdata(){

             taken++;

             cout<<"nSeat Number = "<< taken;

             cout<<"nName = ";

             cin.getline(name,20);

             seat=taken;

         }

         static void status(){

             cout<<"nTotal Seats = 50";

             cout<<"nSeats Taken = "<< taken;

             cout<<"n Available = "<< 50-taken;

         }

         void disp( ){

             cout<<"nSeat No. = "<< seat;

             cout<<"nName = "<< name;

         }

    };

    DH ob[50];

    int DH::taken;

    void main(){

         int i,s;

         char mo='Y',c;

         for(i=0;mo=='Y' && i<50;i++){

             ob[i].getdata();

             DH::status();

             cout<<"nMore? (Y/N) ";

             cin>>mo;

             mo=toupper(mo);

             c=cin.get();

         }

         cout<<"Enter Seat No. to display";

         cin>>s;

         ob[s-1].disp();

SOLUTION

Three access specifiers are given by C++ :-

1. private : which disallow the accessibility of block outside the class
2. public : which allow the accessibility to outside of the class by any function
3. protected : which restrict the accessibility upto derived class only

With the proper use of access specifier the data can be hidden from unauthorized access.

SOLUTION

A class binds together data and functions in a single unit to enforce encapsulation.

The class represents essential features of the object only, thus implementing data abstraction.

SOLUTION

Some situations where defining a function as inline will not work – 

        1. If the function returns a value and contains a loop, switch or goto statement.

        2. If the function does not return a value and contains a return statement.

        3. If the function contains static variables.

SOLUTION

The minimum amount of memory that can be reserved is 1 byte. Hence, the size of the object of empty class will be 1 byte.

SOLUTION

The way to access global data and functions is to use the scope resolution operator (::).

SOLUTION

The keyword 'new' is used to create an object dynamically. For Example : Sample p = new Sample; Here 'p' is an object of Sample type.

SOLUTION

Destructors cannot be overloaded. It does not make any sense in passing any arguments to the destructors.

SOLUTION

Constructors are called whenever an object gets invoked. While creating an object it is not required to return a value.

SOLUTION

An error value can never be returned from a constructor. However, when a runtime error occurs, an exception can be thrown from within a constructor.

SOLUTION

Functions defined in class are by default inline and those defined outside are not inline. Functions can be made inline by writing the keyword inline in function’s definition.

SOLUTION

The desructor has specific naming rules as follows:
The destructor has the same name as that of the class, preceded by tilde (~).
The destructor cannot take arguments. 
The destructor has no return type.

SOLUTION

C++ constructors have an implicit return type used by the compiler but we can't declare a return type or return a value.

SOLUTION

Parameterized constructor contains arguments to assign the values to the class elements.

SOLUTION

As the object is created, it invokes the constructor and then the destructor followed by it. Output:

SOLUTION

A temporary instance is the one that lives in the memory as long as it is being used or referenced in an expression and after this it dies. The temporary instances are anonymous i.e. they do not bear a name.

SOLUTION

The program will start to print 1 from because the variable is initialized to zero as val = 0. Then, it is incremented by 1, each time constructor is called, till val = 4. After that, destructor is called, which decrements val from 4 to 1. Output:

SOLUTION

When an object is returned by a function the copy constructor is called to create a copy of the value returned by the function.