What are containers in C++ and in Object Oriented Programming ? Which objects are available as containers ?
A container is an object that can store other objects as its elements. However all the objects stored in a container should be of the
same data type. E.g. array is a container as it allows you to store multiple objects. However there are a few problems with arrays like
an array can’t allow you to store an element anywhere in the middle of the array, an array cannot grow dynamically to append new
elements at the end of the array. A sequence container is the one which allows storing elements of the same type in a linear fashion.
There are three objects which are sequence containers: 1. Vector: an array like container that allows storing elements of the same
type and provides random access to these elements. Insertions and deletions at the end of the vector are efficient.2. List: provides
efficient insertions and deletions at any position within a list.3. dequeue: double ended queue with constant time insertions and
deletions both at the end and the beginning of the queue.
===================
Explain the Concept of Data Abstraction and Data Encapsulation in Object Oriented Programming (OOPS)
Data encapsulation: the wrapping up of data and functions that act upon that data in a single unit is termed as data encapsulation. It
binds together both the data and code and thus keeps both safe from the outside world. The data and the code to manipulate the data
are combined in such a way that a black box is created which is self contained and modular. This box is termed as a class in object
oriented terminology. Within a class the code or the data can be private or public. If it is private then these cannot be accessed by the
outside world whereas public means that the code and the data is accessible to everyone. Typically the data is private and the
methods are an interface to the private elements of the object. Data abstraction: The term data abstraction is similar to data
encapsulation. All the data and the methods that make sense to the objects of a class that is been designed need to be a part of the
class. All unnecessary details should be left behind. E.g. when designing a class to represent a student we need data elements such
as student no, student name, marks, grade, etc. If we now design a class representing a cricket player we need details like no of
centuries, striking rate, no of matches played, etc. It will not make sense to add the player’s marks, grades which are applicable to a
student class to this player class. The classes designed in object oriented language are also termed as User defined data types
(UDT).
========================
What are classes ? How are they defined ?
A class in an object oriented language is a User defined data type (UDT). A class is made up of member variables (data) and
member functions (interface).
A class is created or declared using the class keyword. It defines a new type to represent a real life entity. This type is composed of
data that is private to the class and accessible through the public member functions of the class.
As an analogy consider a home. A home is like an object that has a state (whether lights are on, number of walls, temperature, etc)
and it provides services (like buttons to switch off the lights, a thermostat that controls the temperature). This blueprint for a home is a
class since it defines the characteristics of a group of such houses.
Syntactically a class structure is similar to a structure except that everything in a class by default is made private whereas everything
is public in a structure by default.
E.g. class student{ public: //public interface private://private implementation}
================================
What are objects ? What is common between all objects of a class ?
Objects are physical or conceptual things that are found in the universe. Objects are thought of having state associated with them.
E.g. state of an account would be the account balance; the state of a clock would be the time.
In object oriented terminology a class is just a plain structure and an object is an instance of a structure. A class is a blueprint that
does not take memory however when a class is instantiated by creating an object of that class then each such object takes up
memory space.
All objects of a class have identical structure however each object will have its own private data. E.g. a class student will have multiple
instances of students where each student instance will have distinct values for their attributes.
Each object will have its own memory with its data however all the objects of a class share the member functions of a class.
E.g. we will define a class called account and create two objects of this class.
class Account
{
private:
double account_balance;
int account_no;
public:
double calculateInterest();
void deposit(double);
double withdraw();
}
==============================
State all the class access modifiers and explain each one of them
C++ has three access modifiers namely public, private and protected.
Public: a public modifier means that the data or the functions of a class are accessible by any program. There are no restrictions in
accessing public members of a class. Ideally all the functions that allow manipulating or accessing the class data are made public.
Private: the private keyword means that the data and member functions that are private cannot be accessed by other programs. They
are accessible only within the class or struct in which they are declared. If one tries to access the private members of a class it results
in a compile time error. Encapsulation is possible due to the private access modifier.
Protected: this access modifier plays a key role in inheritance. This keyword gives a protected access to the member variables and
functions which means that these are accessible from within the class as well as any classes that are derived from the class that
declared this member. However the protected members are not accessible to the any other programs.
=====================
What are Vectors in C++(Object Oriented Programming) and how are they used ?
Vector is a part of the sequential container which holds an ordered collection of elements of one type. A vector holds all these
elements in a contiguous area of memory. Random access of elements is efficient however insertion of elements at any other position
other than the end of the vector is inefficient since each element to the right of the element to be inserted has to be shifted one by one
which leads to inefficiency. Similarly deletion of an element besides the last element is inefficient as well.
The vector is a part of the std namespace and one must include #include header in order to use a vector.
#include
using namespace std;
int main()
{
vector v1;
v1.push_back(1);
v1.push_back(2);
}
The function capacity () returns the total number of elements that the vector can hold and size () returns the number of elements that
are currently stored in the vector
=====================
What are Iterators in C++ and Object Oriented Programming ? Explain where we use them
Iterators allow the traversal of a container object. They provide a generic interface to navigate a container without having to know the
actual type of its elements. Several member functions of containers like begin () and end () return a pointer to iterators. Begin ()
returns a pointer to the beginning of a container and end returns a pointer one position past the last valid element of a container. This
element past the last element marks the end of the container like a \0 is used to mark the end of strings.
The functions begin () and end () come in two flavors: const and non const. The non cons version returns non const iterator that
enables a user to modify the value of its container while const iterators cannot modify its container.
e.g. vector v1;
vector ::iterator p = v.begin ();
====================
What are the Algorithms namespace used for ?
Algorithms are an important part of STL. These are generic algorithms that can be applied to containers. The algorithms are divided
into three categories:
1. Non-modifying sequence operations: these algorithms do not directly modify the object they work on. These are basically the
search algorithms, checking for equality and counting. E.g. find () algorithm is used to locate an element within a sequence.
2. Mutations sequence operations: these algorithms modify the object that they operate on. These are operations such as copy,
fill, replace and transform. E.g. copy () algorithm is used to copy a sequence of objects to a target object.
3. sorting algorithms: these algorithms provide sorting and merging sequences and they operate on sorted sequences. E.g. sort
(), partial_sort (), binary_search (), etc.
==============================
What are Enumerations in C++ and Object Oriented Programming ? Explain with an example ?
An enumeration is a type that can hold a set of constant values that are defined by the user. Once you define an enumeration you can
use it like integer types.E.g. enum {OFF, ON};The enum defines two integer constants called enumerators and these constants are
assigned values by default. The value assigned to OFF = 0 and ON = 1. The above is an unnamed enumeration, however an enum
can be named. E.g. enum STATE {OFF, ON};Each enumeration is a distinct type and the type of the enumeration is the enumerator.
For example OFF is of type STATE. An enumerator can optionally be initialized by a constant expression of integral type. E.g. enum
{WHITE = 3, BLACK = 5}; A value of an integral type can be converter to an enumeration type. This needs to be done explicitly. The
results are undefined unless the value is within the range of the enumeration.E.g. enum COLORS {RED = 1; BLUE = 3, WHITE =
7};COLORS c1 = COLORS (5); All enumerators are converted to integral type for any arithmetic operation.
==============================
What are References in C++ and OOPS ? How are they used ?
A reference means an alias. It is an alternative name to an object. An object can have multiple references. However the most
important use of references is to pass arguments to function and return values for functions as well as for overloaded operators. E.g.
consider a reference for a variable x created as x1.int x = 10;int &x1 = x; To make sure that the reference denotes an object it has to
be initialized. Once initialized the value of a reference cannot be changed. In order to get a pointer to the object denoted by the
reference x1 we can write it as &x1; One of the important uses of reference is to pass an object to a function as a reference so that
the function can change the value of that object. e.g. void swap (int &a, int &b){ int tmp = a; a = b; b = a;}void main (){ int x =
10, y = 12; swap (x, y );} Since x and y are passed by reference to the function swap their values get actually swapped.
============================
Explain the Rules for using Default Arguments with an example in C++.
A default argument is used by functions to free the programmer from specifying values which can be set to default by the function.
E.g. consider a function for printing an integer. A user can be given an option to decide of what base the integer should be printed
however in most cases it will be decimal. E.g. void print (int value, int base = 10); //here the base is set to 10 by defaultThe above
function can be called as: print (10); //here default base will be taken as 10 print (10, 8); a function can specify a default argument
for one or more of its parameters at the initialization time within the parameter list. A function that has a default parameter can be
invoked with or without that parameter. If it gets invoked without the parameter then the default value applies to that parameter.
Arguments to the call are resolved by position and hence the default arguments can be specified as trailing arguments only.e.g. void
display (int a, int b = 0, int c = 9); // correct void display (int a = 0, int b, int c = 9); //wrong void display (int a = 0, int b = 9, int c);
//wrong The default arguments are specified in the function declaration and not in the function definition.
==================================
What do you mean by “Pointers to Function”? What are Function Pointers ?
We can use a function in two ways: one is to invoke a function and the second is to obtain the address of a function. This address that
is obtained is called as pointer to the function and is used to invoke the function.E.g. we have a function named display and we will
invoke this function using a pointer to this function as follow:void display (string s) /* … */void (*ptr)(string); //pointer to a function ptr =
&display; //assign the address of the function ptr (“hello”); // call the function In the above example the compiler will discover that ptr is
a pointer to the function display and calls the function. The dereferencing of a pointer to a function using a * is optional. Similarly it is
not necessary to use & to get the address to the pointer. As pointers to functions have argument types declared just like the functions
themselves, therefore in pointer assignments the complete function type must exactly match. A function name does not constitute its
type. A function type is determined by its return type and its parameter list
======================
What are NameSpaces in C++ ? How do we use namespaces in C++ ?
The purpose of namespaces is to reduce the name clashes that occur with multiple independently developed libraries. It is used to
package names, improve program readability and reduce the name clashes in the global namespace.
e.g. namespace mynamespace{ class Stack { }}The class Stack has to be referred as mynamespace::Stack.
In this way namespace facilitate building large systems by partitioning names into logical groups. Java has a similar concept called
packages. One can access the names within the namespace in the following ways: a. Use the scope resolution operator to prefix
the object declared in the namespace with the name of the namespace. e.g. mynamespace::Stack *s = new
mynamespace::Stack (); b. Using directive E.g. using namespace Stack; Stack *s = new Stack ();
===============
What is the Exception Handling mechanism in C++ ? What is Try and Catch in C++ ?
The ability to gracefully handle an error or an exception is known as exception handling. C++ has built exception handling techniques
which allows the program to handle and exceptions and deal with them.
- try block: the code that is likely to throw an exception should be enclosed in a try lock. This allows the function to recover from
this exception. If a code called from a try block cannot throw an exception then there is no need for the try block.
- Catch block: the exception that is thrown in the try block has to be caught in the catch block. There can be multiple catch blocks
for a try block however there cannot be any code between try and catch block. Once an exception is caught and if the function can
recover from that error then it can either continue normal processing or restart the try block by putting the try block in a loop. If
required the catch block can also propagate the exception to the calling function either by throwing the same exception object or
throwing a different exception object.
e.g.
try { File x (filename); } catch (BadFileName& e) { cout << " second(): " << e.what() << ": Partial recovery\n"; throw; } catch
(AccessViolation& e) { cout << " second(): " << e.what() << ": Full recovery\n"; }
* Login or register to post comments
Re: What is the Exception Handling mechanism in C++ ? What is Tr
Submitted by Anonymous on Wed, 2007-07-11 16:19.
Exception handling in C++ is complex and subtle. It is not as trivial as the above would make you believe.
If you are interested in learning, go and read Meyers, Sutter/GOTW et al.
For a proper treatment, you need to discuss (at a bare minimum):
- What happens to x when an exception is thrown.
- What happens if the destructor of File throws.
- Why you want to catch by reference.
- What can throw (answer: a lot more than you think).
- RAII.
===================================
What is Operator Overloading in C++ ?
The ability to overload operators is one of the most powerful features of C++. The operators are overloaded so that they can perform
special operations on the user defined classes. Say for example you create a class representing complex number. We can overload
the + operator to add two complex numbers. When an operator is overloaded it original meaning is not lost in fact the type of objects
that the operator can operate expands. Operators are overloaded by creating operator functions. It is created using the keyword
operator. These functions can either be member of a class or then they have to be friend functions. Syntax: returntype classname::
operator#(arg-list) { } E.g. class Complex { private: float real; float imaginary; public: Complex operator+ (Complex); };
//overloaded + operator for class Complex Complex Complex::operator+ (Complex c) { Complex tmp; tmp.real = this.real + c.real;
tmp.imaginary = this.imaginary + c.imaginary; return temp; } The only C++ operators that cannot be overloaded are dot (.), .*, ?:,
sizeof, typeid and scope resolution operator (::).
========================
What are Friend Functions and Friend Classes in C++ ?
A friend can be a function, another class or individual member function of a class. With the help of a friend function it is possible to
grant a non member function access to the private members of a class using a friend. A friend function has all access to all the
private and protected members of the class for which it is the friend. To declare a friend function includes the function prototype within
the class preceding it with the keyword friend. When a friend function is called it need to be qualified by the object name as it is not a
member function of the class. E.g. class Complex { private: float real; float imaginary; public: friend Complex operator+ (Complex,
Complex); };//overloaded + operator for class Complex Complex operator+ (Complex c, Complex d) { Complex tmp; tmp.real = d.real
+ c.real; tmp.imaginary = d.imaginary + c.imaginary; return temp; } To call the function: int main (){ Complex a, b, c; a = b + c; //this
will be called as operator+(b, c)} Friend classes are used when two or more classes are designed to work together and need access
to each other’s implementation. E.g. a class DataBaseCursor may want more privileges to the class Database. E.g. class
DatabaseCursor; class Database { //member variable and function declarations friend DatabaseCursor; };
=============================
What are Constructors and Destructors in C++ ?
A constructor constructs an object i.e. it initializes the objects internal data members as well as it may allocate resource (memory,
files, sockets, etc). The constructor has the same name as the class name and cannot have a return type not even void. A constructor
can take multiple arguments as its parameters. A class can have multiple constructors i.e. a constructor can be overloaded.
Whenever an object of a class is created it calls a constructor by default which is responsible for initializing the object. By default
every class has a default constructor which is a constructor with no arguments. However once you provide a constructor to a class
then the default constructor does not exist. e.g. class Stack{ int size;int top; int arr []; Stack(int a) //constructor of the class { size = a;
arr = new int[size]; }}; The destructor is the last member function called in the lifetime of a class object. Its job is to free the resources
that an object is holding. A class can have no more than a single destructor. The name of the destructor is ~ classname (). Like a
constructor, a destructor cannot have a void return type. e.g. ~Stack () //destructor { delete [] arr; }
======================
What is Inheritance ? How is a Class Inherited in C++ ?
Inheritance is one of the most important principles of object oriented language. Using inheritance one can create a class that can
have traits common to a set of related items. This class is then inherited by other classes each adding things are specific to them.
The class that is inherited is called the base class and the class that inherits from it is called as the derived class. When a class
inherits a base class, then all the members of the base class become members of the derived class. E.g. class derived-class-name::
access base-class-name{ //body of class}; The access of the members in the base class by derived class depends on the access
parameter. The access specifier must either be private, public or protected. If one doesn’t provide an access specifier then it is taken
as private by default. When access specifier is private then these members remain private to base class and the derived class cannot
access them. When access specifier is public then all the public members of a base class become public members of the derived
class and all the protected members of the base class become protected in the derived class. On using a protected access specifier
all public and protected members of the base class become protected members of the derived class.
================================
What are Virtual Functions ? Why do we need Virtual Functions? Explain with an example.
A function that is defined in a base class but overridden by the derived class is called a virtual function. To create virtual functions
precede the function declaration in the base class with the keyword virtual. When a class containing a virtual function is inherited the
derived class overrides the virtual function with its own definition. Virtual functions are like member functions however what makes
them different is the capability to support run time polymorphism when accessed via a pointer. A base class pointer can point to an
object of a derived class. When a base class pointer points to an object of a derived class that contains a virtual function, C++
determines which function version to call based on the type of object pointed by the base class pointer. This is runtime polymorphism
as it can be determined at run time. In this way when different objects are pointed to then different versions of virtual functions are
executed. Whenever a virtual function is defined all aspects of its prototype should match. Also virtual functions should be non static
members of the class and they cannot be friend functions too. E.g. class base { public: virtual void display (); }; class derived: public{
public: virtual void display ();};base *p, b;derived d1, d2;p = &b;p->display (); //calls base class functionp = &d1;p->display (); //calls
derived class function
======================
What are Templates in C++ ? How are Templates declared and used ?
Many data structures and algorithms can be defined independently of the type of data they manipulate. A template allows the
separation of the type dependent part from the type independent part. This results in a significant amount of code reusability.
Templates can be class templates or function templates. A class template is used for creating a class in which one more values are
parameterized. The syntax of a class template is:
template class class-name{ ...};
A class template can also have multiple parameters.
template class class-name{ ...};
Example -
template class Array{ private: T *arr []; public: Array (int size = 10); };template Array::Array(int
size){ arr = new T[size];}
Create an Array object as: Array a; The function template is also written using the keyword template.
E.g. template class void push (T &element) { arr[top] = elemen
========================
What is Polymorphism ? How is Polymorphism achieved in C++ ?
Polymorphism is one of the most important principle of object oriented language. Polymorphism means many forms i.e. one interface
multiple methods. The specific method to call depends on the nature of the situation. No matter what type of car it is the driving
mechanism is the same. For example, you might have a program that defines three different types of stacks. One stack is used for
integer values, one for character values, and one for floating-point values. Because of polymorphism, you can define one set of
names, push() and pop() , that can be used for all three stacks. In your program you will create three specific versions of these
functions, one for each type of stack, but names of the functions will be the same. The compiler will automatically select the right
function based upon the data being stored. Thus, the interface to a stack—the functions push() and pop() —are the same no matter
which type of stack is being used. C++ supports both run time and compile time polymorphism. Function overloading is a form of
compile time polymorphism while dynamic binding is a form of runtime polymorphism.
===============
What are the Standard Exceptions in C++ ?
C++ defined a hierarchy of standard exceptions that are thrown at runtime whenever an abnormal condition takes place. These
exceptions are derived from std::exception class defined in the header. Since there is a common base class of all these exceptions it
enables the application to catch these exceptions in a single catch statement. E.g. catch (std::exception &e){//code to handle the
exception} Some of the standard exceptions that are built in the language are: - std::bad_alloc: thrown by operator new -
std::bad_cast: as a result of dynamic_cast - std::bad_typeid: as a result of operator typeid - std::bad_exception: Whenever you want
to catch all exceptions then the exception parameter in the catch block should be an ellipsis. E.g. catch (…){ //this block will catch all
exceptions}
==============
What is Multiple Inheritance in C++ ? Explain with an example
It is possible for a derived class to inherit more than a single base class. This is referred as multiple inheritance. The class inherits
from multiple base classes where these classes are comma separated. Each listed base class must specify its own access level.
E.g.
class base1
{}
;
class base2
{}
;
class derived: public base1, public base2
{
};
The base class constructors are invoked in the declaration order within the class derivation list. In the above example the constructor
for base1 will be called first followed by the base2 constructor. Similarly the order of destructor is reverse of the constructor order.
If a class inherits from one or more base classes which themselves inherit from a common base class then it can lead to problems. In
such case one should use virtual inheritance. Under virtual inheritance only a single shared base class object is inherited regardless
of how many times the base class occurs in the derivation hierarchy.
E.g.
class derived: public virtual base1, public virtual base2
{}
;
==================
What is a Copy Constructor in C++ ? Give an example
Copy constructor is a type of constructor which constructs an object by copying the state from another object of the same class.
Whenever an object is copied, another object is created and in this process the copy constructor gets called. If the class of the object
being copied is x, the copy constructor’s signature is usually x::x (const x&).
Let’s take an example to illustrate this:
class Complex
{ int real, img;
public:
Complex (int, int);
Complex (const Complex& source); //copy constructor
};Complex:: Complex (const Complex& source)
{ this.real =
source.real;
this.img = source.img;
}
main ()
{
Complex a (2, 3);
Complex b = a; // this invokes the copy constructor
}
A copy constructor is called whenever an object is passed by value, returned by value or explicitly copied.
==================================
What is Function Overloading in C++ ?
Function overloading is the process of using the same name for two or more functions. However each function will be different in
terms of either different types of parameters or a different number of parameters. It is only through these differences that the compiler
knows which function to call in any given situation. Even if the number of parameters are same and types are same but they are
written in a different order then these functions will still be considered different. The return type parameter does not hold any
relevance to make two functions distinct. E.g. void display (int a);void display (string str); Both the above functions have the same
name but different parameters. So when a function display (2) is called the compiler calls the first function and when the argument
passed to display is a string then the second version is invoked.E.g. int display (int a );void display (int a); In the above example the
compiler will generate a compile time error as the return types are insufficient to overload functions
====================================
What are Pointers in C++ (Object Oriented Programming) ?
Pointers are used to store memory address values of objects. C++ defines a special address-of operator that when applied to an
object returns that object’s address value. E.g. int *pint; //this defines a pointer variableIn order store the address of the variable ‘j’ into
pint one should assign the address of j into pint variable as follows:pint = &j; // assigning the address of variable j into pointer pint In
order to access the actual object pint addresses we must first dereference pint using the dereference operator (*). *pint = *pint + 1; //
this statement will increment the value pint points to by 1 The type of the pointer variable should be the same as the variable whose
address it is used to hold. E.g. you cannot define a pointer variable of type float and use it to assign the address of a variable of type
integer
========================
What are volatile variables ? Explain Volatile variables
A variable is declared as volatile if its value can possibly be changed in ways outside either the control or detection of the compiler.
For example a variable that is updated by the system clock. Certain optimizations ordinarily performed by a compiler should therefore
not be applied to objects the programmer specifies as volatile. The volatile qualifier is used in much the same way as is the const
qualifier as an additional modifier to a type.E.g. volatile int count_value; The purpose of defining a variable as volatile is to inform the
compiler that the variable can change in ways undetectable by the compiler and hence the compiler should not perform any kind of
optimizations on these variables.
============================
What is the Difference between Overloaded Functions and Overridden Functions ?
In C++, overloading is simply the use of the same function identifier for different functions declared in the same scope.
E.g. void display (int);void display (string);
The above two functions are clearly overloaded. The compiler will distinguish among them by the actual argument used in the call to
display.
Overriding can occur only in the presence of a base class virtual function. Overriding has nothing whatsoever to do with overloading.
A nonvirtual base class function cannot be overridden, only hidden. In overriding the function prototype in the derived class has to be
exactly the same as the one in the base class
=============================
What are Inline Functions ? When are Inline Functions used ?
The idea behind inline functions is to insert the code of a called function at the point where the function is called. It is useful to
distinguish between "inline," a keyword qualifier that is simply a request to the compiler, and "inlined," which refers to actual inline
expansion of the function. A function can be decorated with the inline keyword either in the class definition or in its own definition if the
definition physically occurs before the function is invoked. The compiler does not promise that an inline function will be inlined, and the
details of when/when not are compiler-dependent. On the other hand, any function that is defined within the class body will be treated
implicitly as an inline function with or without the explicit inline keyword. Inline code is faster than a function call for two reasons. First,
a CALL instruction takes time to execute. Second, if there are arguments to pass, these have to be placed on the stack, which also
takes time
============================
What are Mutable and Const in C++ ?
Class member functions may be declared as const, which causes them to be treated as a const pointer. Thus, that function cannot
modify the object that invokes it. Also, a const object may not invoke a non-const member function. However, a const member
function can be called by either const or non-const objects. Sometimes there will be one or more members of a class that you want a
const function to be able to modify even though you don't want the function to be able to modify any of its other members. You can
accomplish this through the use of mutable. It overrides constness. That is, a mutable member can be modified by a const member
function. E.g. class MyClass{ int i; mutable int j; Public: void setValues const () { i = 10; //wrong j = 15; //correct }};
===========================
What is ‘this’ Pointer (object) in C++
When a member function is called, it is automatically passed an implicit argument that is a pointer to the invoking object (that is, the
object on which the function is called).This pointer is called this.Within a member function, the members of a class can be accessed
directly, withoutany object or class qualification. The this pointer points to the object that invoked the member function. Also the this
pointer is automatically passed to all member functions. Another thing to note is that the friend functions are not members of a class
and, therefore, are not passed a this pointer. Second, static member functions do not have a this pointer. e.g. class Stack { int top; int
size; Stack (int top, int size) { this.top = top; this.size = size; }};
========================
What is Scope Resolution Operator in C++?
There are two used of the scope resolution operator in C++. The first use being that a scope resolution operator is used to unhide the
global variable that might have got hidden by the local variables. Hence in order to access the hidden global variable one needs to
prefix the variable name with the scope resolution operator (::). e.g. int i = 10; int main () { int i = 20; Cout << i; // this prints the value
20 Cout << ::i; // in order to use the global i one needs to prefix it with the scope //resolution operator. } The second use of the
operator is used to access the members declared in class scope. Whenever a scope resolution operator is used the name of the
member that follows the operator is looked up in the scope of the class with the name that appears before the operator.
==================================
What is Scope Resolution Operator in C++?
There are two used of the scope resolution operator in C++. The first use being that a scope resolution operator is used to unhide the
global variable that might have got hidden by the local variables. Hence in order to access the hidden global variable one needs to
prefix the variable name with the scope resolution operator (::). e.g. int i = 10; int main () { int i = 20; Cout << i; // this prints the value
20 Cout << ::i; // in order to use the global i one needs to prefix it with the scope //resolution operator. } The second use of the
operator is used to access the members declared in class scope. Whenever a scope resolution operator is used the name of the
member that follows the operator is looked up in the scope of the class with the name that appears before the operator.
===================
What are Const Member Functions in C++ ?
There can be two cases in which a member function can be declared as a const function: whenever the member function wants to
guarantee that it won't make any changes to its this object or whenever a caller needs to invoke the member function via a referenceto-
const or pointer-to-const. The compiler wont allow a const member function to change *this or to invoke a non-const member
function for this object. E.g. int getCount() const;int getCount () const{ //function definition}
===========================
Explain Composition in C++ with an example
Composition allows software to be developed by assembling existing components rather than creating new ones. Composition is also
sometimes called as aggregation and defines the process of putting an object inside another object. It models the has-a relationship.
E.g. a class employee can contain an object of type salary which itself is another type of object. e.g.
class Salary{ private: double DA; double HRA; double travelAllowance; double basic salary; public: //member functions};Class
Employee{ private: int empno; Salary salary; //composition: salary object is contained inside employee public: //member functions};
==================
What do you mean by ‘Return by Reference’ in C++ ?
A function can be declared to return a pointer or a reference. When the function is returning a reference, the calling function receives
the lvalue for the variable. The calling function can then modify the variable or take its address.
If the return value is a large class object, using a reference (or pointer) return type is more efficient than returning the class object by
value. In some cases, the compiler can automatically transform a return by value to a return by reference.
E.g.
Complex& compute (Complex c)
{
Complex *tmp = new Complex ();
// …
return tmp;
}However care should be exercised when returning a reference to a local object. The lifetime of the local object terminates with the
termination of the function. The reference is left aliasing undefined memory after the function terminates.
====================
What are static Data and Static Member Functions in C++ ?
Static data members are data and functions that are associated with the class itself, rather than with the objects of the class. For
example a count is needed of how many objects of a particular class type have been created at any one point in the program. A static
data member acts as a global object that belongs to its class type. Unlike other data members where each class object has its own
copy, there is only one copy of a static data member per class type. A static data member is a single, shared object accessible to all
objects of its class type. A data member is made static by prefixing the data member declaration within the class body with the
keyword static or prefixing the function declaration with the keyword static. A static function cannot access any other member
variables of the object. One does not need to create a class object for accessing a static member or a static function; a static function
can be invoked using the class name as class_name::static_member_function. e.g. class ShoppingCart{ private: static int totalItems;
//static data member public: static int getTotalItems (); //static member function};
===========================
What is a Pure Virtual Member Function ?
Whenever a virtual function in a base class is not redefined by the derived class then the version defined in the base class will be
used. However in many cases it may so happen that there can be no meaningful definition of a virtual function within the base class.
Or you may want to ensure that all derived classes override a virtual function. To handle both these cases the solution is a pure virtual
function.
A pure virtual function is a function that has no definition in the base class. The definition of such a function is equal to 0.E.g. void
draw () = 0; // this is a pure virtual function
If a class contains at least one virtual function then that class is called an abstract class and one cannot create an instance of an
abstract class. Also if a class inherits from a class that contains a pure virtual function then the derived class has to provide a
definition for the pure virtual function. Failure to do so will result in an abstract derived class.
==============================
What are Preprocessor Directives ?
The preprocessor directives are instructions to the compiler. All these preprocessor lines begin with a pound (#). They are executed
before the compilation of the code begins. These directives can only span a single line and does not need to end in a semicolon.
The preprocessor contains the following directives:
- #define: this defines an identifier and some value to this identifier. This value can be any character sequence and will be substituted
in the code file for each instance of the corresponding identifier.
e.g. #define MIN 0
- #include: it tells the compiler to link to another source file. The name of the source file can be in angle brackets or double quotes.
e.g. #include
- #error: tells the compiler to stop compilation. Used primarily for debugging purposes.
- #if:
- #elif
- #endif
- #else: The above four directives are conditional directives. They allow you to conditionally include portions of code based on
outcome of a constant expression.
E.g. #if OPTION == 1
//do something
#else
//do something else
#endif
- #ifndef
- #undef: the above indicates conditional compilation dependinf upon if a variable is defined or not defined.
======================================
A container is an object that can store other objects as its elements. However all the objects stored in a container should be of the
same data type. E.g. array is a container as it allows you to store multiple objects. However there are a few problems with arrays like
an array can’t allow you to store an element anywhere in the middle of the array, an array cannot grow dynamically to append new
elements at the end of the array. A sequence container is the one which allows storing elements of the same type in a linear fashion.
There are three objects which are sequence containers: 1. Vector: an array like container that allows storing elements of the same
type and provides random access to these elements. Insertions and deletions at the end of the vector are efficient.2. List: provides
efficient insertions and deletions at any position within a list.3. dequeue: double ended queue with constant time insertions and
deletions both at the end and the beginning of the queue.
===================
Explain the Concept of Data Abstraction and Data Encapsulation in Object Oriented Programming (OOPS)
Data encapsulation: the wrapping up of data and functions that act upon that data in a single unit is termed as data encapsulation. It
binds together both the data and code and thus keeps both safe from the outside world. The data and the code to manipulate the data
are combined in such a way that a black box is created which is self contained and modular. This box is termed as a class in object
oriented terminology. Within a class the code or the data can be private or public. If it is private then these cannot be accessed by the
outside world whereas public means that the code and the data is accessible to everyone. Typically the data is private and the
methods are an interface to the private elements of the object. Data abstraction: The term data abstraction is similar to data
encapsulation. All the data and the methods that make sense to the objects of a class that is been designed need to be a part of the
class. All unnecessary details should be left behind. E.g. when designing a class to represent a student we need data elements such
as student no, student name, marks, grade, etc. If we now design a class representing a cricket player we need details like no of
centuries, striking rate, no of matches played, etc. It will not make sense to add the player’s marks, grades which are applicable to a
student class to this player class. The classes designed in object oriented language are also termed as User defined data types
(UDT).
========================
What are classes ? How are they defined ?
A class in an object oriented language is a User defined data type (UDT). A class is made up of member variables (data) and
member functions (interface).
A class is created or declared using the class keyword. It defines a new type to represent a real life entity. This type is composed of
data that is private to the class and accessible through the public member functions of the class.
As an analogy consider a home. A home is like an object that has a state (whether lights are on, number of walls, temperature, etc)
and it provides services (like buttons to switch off the lights, a thermostat that controls the temperature). This blueprint for a home is a
class since it defines the characteristics of a group of such houses.
Syntactically a class structure is similar to a structure except that everything in a class by default is made private whereas everything
is public in a structure by default.
E.g. class student{ public: //public interface private://private implementation}
================================
What are objects ? What is common between all objects of a class ?
Objects are physical or conceptual things that are found in the universe. Objects are thought of having state associated with them.
E.g. state of an account would be the account balance; the state of a clock would be the time.
In object oriented terminology a class is just a plain structure and an object is an instance of a structure. A class is a blueprint that
does not take memory however when a class is instantiated by creating an object of that class then each such object takes up
memory space.
All objects of a class have identical structure however each object will have its own private data. E.g. a class student will have multiple
instances of students where each student instance will have distinct values for their attributes.
Each object will have its own memory with its data however all the objects of a class share the member functions of a class.
E.g. we will define a class called account and create two objects of this class.
class Account
{
private:
double account_balance;
int account_no;
public:
double calculateInterest();
void deposit(double);
double withdraw();
}
==============================
State all the class access modifiers and explain each one of them
C++ has three access modifiers namely public, private and protected.
Public: a public modifier means that the data or the functions of a class are accessible by any program. There are no restrictions in
accessing public members of a class. Ideally all the functions that allow manipulating or accessing the class data are made public.
Private: the private keyword means that the data and member functions that are private cannot be accessed by other programs. They
are accessible only within the class or struct in which they are declared. If one tries to access the private members of a class it results
in a compile time error. Encapsulation is possible due to the private access modifier.
Protected: this access modifier plays a key role in inheritance. This keyword gives a protected access to the member variables and
functions which means that these are accessible from within the class as well as any classes that are derived from the class that
declared this member. However the protected members are not accessible to the any other programs.
=====================
What are Vectors in C++(Object Oriented Programming) and how are they used ?
Vector is a part of the sequential container which holds an ordered collection of elements of one type. A vector holds all these
elements in a contiguous area of memory. Random access of elements is efficient however insertion of elements at any other position
other than the end of the vector is inefficient since each element to the right of the element to be inserted has to be shifted one by one
which leads to inefficiency. Similarly deletion of an element besides the last element is inefficient as well.
The vector is a part of the std namespace and one must include #include header in order to use a vector.
#include
using namespace std;
int main()
{
vector v1;
v1.push_back(1);
v1.push_back(2);
}
The function capacity () returns the total number of elements that the vector can hold and size () returns the number of elements that
are currently stored in the vector
=====================
What are Iterators in C++ and Object Oriented Programming ? Explain where we use them
Iterators allow the traversal of a container object. They provide a generic interface to navigate a container without having to know the
actual type of its elements. Several member functions of containers like begin () and end () return a pointer to iterators. Begin ()
returns a pointer to the beginning of a container and end returns a pointer one position past the last valid element of a container. This
element past the last element marks the end of the container like a \0 is used to mark the end of strings.
The functions begin () and end () come in two flavors: const and non const. The non cons version returns non const iterator that
enables a user to modify the value of its container while const iterators cannot modify its container.
e.g. vector v1;
vector ::iterator p = v.begin ();
====================
What are the Algorithms namespace used for ?
Algorithms are an important part of STL. These are generic algorithms that can be applied to containers. The algorithms are divided
into three categories:
1. Non-modifying sequence operations: these algorithms do not directly modify the object they work on. These are basically the
search algorithms, checking for equality and counting. E.g. find () algorithm is used to locate an element within a sequence.
2. Mutations sequence operations: these algorithms modify the object that they operate on. These are operations such as copy,
fill, replace and transform. E.g. copy () algorithm is used to copy a sequence of objects to a target object.
3. sorting algorithms: these algorithms provide sorting and merging sequences and they operate on sorted sequences. E.g. sort
(), partial_sort (), binary_search (), etc.
==============================
What are Enumerations in C++ and Object Oriented Programming ? Explain with an example ?
An enumeration is a type that can hold a set of constant values that are defined by the user. Once you define an enumeration you can
use it like integer types.E.g. enum {OFF, ON};The enum defines two integer constants called enumerators and these constants are
assigned values by default. The value assigned to OFF = 0 and ON = 1. The above is an unnamed enumeration, however an enum
can be named. E.g. enum STATE {OFF, ON};Each enumeration is a distinct type and the type of the enumeration is the enumerator.
For example OFF is of type STATE. An enumerator can optionally be initialized by a constant expression of integral type. E.g. enum
{WHITE = 3, BLACK = 5}; A value of an integral type can be converter to an enumeration type. This needs to be done explicitly. The
results are undefined unless the value is within the range of the enumeration.E.g. enum COLORS {RED = 1; BLUE = 3, WHITE =
7};COLORS c1 = COLORS (5); All enumerators are converted to integral type for any arithmetic operation.
==============================
What are References in C++ and OOPS ? How are they used ?
A reference means an alias. It is an alternative name to an object. An object can have multiple references. However the most
important use of references is to pass arguments to function and return values for functions as well as for overloaded operators. E.g.
consider a reference for a variable x created as x1.int x = 10;int &x1 = x; To make sure that the reference denotes an object it has to
be initialized. Once initialized the value of a reference cannot be changed. In order to get a pointer to the object denoted by the
reference x1 we can write it as &x1; One of the important uses of reference is to pass an object to a function as a reference so that
the function can change the value of that object. e.g. void swap (int &a, int &b){ int tmp = a; a = b; b = a;}void main (){ int x =
10, y = 12; swap (x, y );} Since x and y are passed by reference to the function swap their values get actually swapped.
============================
Explain the Rules for using Default Arguments with an example in C++.
A default argument is used by functions to free the programmer from specifying values which can be set to default by the function.
E.g. consider a function for printing an integer. A user can be given an option to decide of what base the integer should be printed
however in most cases it will be decimal. E.g. void print (int value, int base = 10); //here the base is set to 10 by defaultThe above
function can be called as: print (10); //here default base will be taken as 10 print (10, 8); a function can specify a default argument
for one or more of its parameters at the initialization time within the parameter list. A function that has a default parameter can be
invoked with or without that parameter. If it gets invoked without the parameter then the default value applies to that parameter.
Arguments to the call are resolved by position and hence the default arguments can be specified as trailing arguments only.e.g. void
display (int a, int b = 0, int c = 9); // correct void display (int a = 0, int b, int c = 9); //wrong void display (int a = 0, int b = 9, int c);
//wrong The default arguments are specified in the function declaration and not in the function definition.
==================================
What do you mean by “Pointers to Function”? What are Function Pointers ?
We can use a function in two ways: one is to invoke a function and the second is to obtain the address of a function. This address that
is obtained is called as pointer to the function and is used to invoke the function.E.g. we have a function named display and we will
invoke this function using a pointer to this function as follow:void display (string s) /* … */void (*ptr)(string); //pointer to a function ptr =
&display; //assign the address of the function ptr (“hello”); // call the function In the above example the compiler will discover that ptr is
a pointer to the function display and calls the function. The dereferencing of a pointer to a function using a * is optional. Similarly it is
not necessary to use & to get the address to the pointer. As pointers to functions have argument types declared just like the functions
themselves, therefore in pointer assignments the complete function type must exactly match. A function name does not constitute its
type. A function type is determined by its return type and its parameter list
======================
What are NameSpaces in C++ ? How do we use namespaces in C++ ?
The purpose of namespaces is to reduce the name clashes that occur with multiple independently developed libraries. It is used to
package names, improve program readability and reduce the name clashes in the global namespace.
e.g. namespace mynamespace{ class Stack { }}The class Stack has to be referred as mynamespace::Stack.
In this way namespace facilitate building large systems by partitioning names into logical groups. Java has a similar concept called
packages. One can access the names within the namespace in the following ways: a. Use the scope resolution operator to prefix
the object declared in the namespace with the name of the namespace. e.g. mynamespace::Stack *s = new
mynamespace::Stack (); b. Using directive E.g. using namespace Stack; Stack *s = new Stack ();
===============
What is the Exception Handling mechanism in C++ ? What is Try and Catch in C++ ?
The ability to gracefully handle an error or an exception is known as exception handling. C++ has built exception handling techniques
which allows the program to handle and exceptions and deal with them.
- try block: the code that is likely to throw an exception should be enclosed in a try lock. This allows the function to recover from
this exception. If a code called from a try block cannot throw an exception then there is no need for the try block.
- Catch block: the exception that is thrown in the try block has to be caught in the catch block. There can be multiple catch blocks
for a try block however there cannot be any code between try and catch block. Once an exception is caught and if the function can
recover from that error then it can either continue normal processing or restart the try block by putting the try block in a loop. If
required the catch block can also propagate the exception to the calling function either by throwing the same exception object or
throwing a different exception object.
e.g.
try { File x (filename); } catch (BadFileName& e) { cout << " second(): " << e.what() << ": Partial recovery\n"; throw; } catch
(AccessViolation& e) { cout << " second(): " << e.what() << ": Full recovery\n"; }
* Login or register to post comments
Re: What is the Exception Handling mechanism in C++ ? What is Tr
Submitted by Anonymous on Wed, 2007-07-11 16:19.
Exception handling in C++ is complex and subtle. It is not as trivial as the above would make you believe.
If you are interested in learning, go and read Meyers, Sutter/GOTW et al.
For a proper treatment, you need to discuss (at a bare minimum):
- What happens to x when an exception is thrown.
- What happens if the destructor of File throws.
- Why you want to catch by reference.
- What can throw (answer: a lot more than you think).
- RAII.
===================================
What is Operator Overloading in C++ ?
The ability to overload operators is one of the most powerful features of C++. The operators are overloaded so that they can perform
special operations on the user defined classes. Say for example you create a class representing complex number. We can overload
the + operator to add two complex numbers. When an operator is overloaded it original meaning is not lost in fact the type of objects
that the operator can operate expands. Operators are overloaded by creating operator functions. It is created using the keyword
operator. These functions can either be member of a class or then they have to be friend functions. Syntax: returntype classname::
operator#(arg-list) { } E.g. class Complex { private: float real; float imaginary; public: Complex operator+ (Complex); };
//overloaded + operator for class Complex Complex Complex::operator+ (Complex c) { Complex tmp; tmp.real = this.real + c.real;
tmp.imaginary = this.imaginary + c.imaginary; return temp; } The only C++ operators that cannot be overloaded are dot (.), .*, ?:,
sizeof, typeid and scope resolution operator (::).
========================
What are Friend Functions and Friend Classes in C++ ?
A friend can be a function, another class or individual member function of a class. With the help of a friend function it is possible to
grant a non member function access to the private members of a class using a friend. A friend function has all access to all the
private and protected members of the class for which it is the friend. To declare a friend function includes the function prototype within
the class preceding it with the keyword friend. When a friend function is called it need to be qualified by the object name as it is not a
member function of the class. E.g. class Complex { private: float real; float imaginary; public: friend Complex operator+ (Complex,
Complex); };//overloaded + operator for class Complex Complex operator+ (Complex c, Complex d) { Complex tmp; tmp.real = d.real
+ c.real; tmp.imaginary = d.imaginary + c.imaginary; return temp; } To call the function: int main (){ Complex a, b, c; a = b + c; //this
will be called as operator+(b, c)} Friend classes are used when two or more classes are designed to work together and need access
to each other’s implementation. E.g. a class DataBaseCursor may want more privileges to the class Database. E.g. class
DatabaseCursor; class Database { //member variable and function declarations friend DatabaseCursor; };
=============================
What are Constructors and Destructors in C++ ?
A constructor constructs an object i.e. it initializes the objects internal data members as well as it may allocate resource (memory,
files, sockets, etc). The constructor has the same name as the class name and cannot have a return type not even void. A constructor
can take multiple arguments as its parameters. A class can have multiple constructors i.e. a constructor can be overloaded.
Whenever an object of a class is created it calls a constructor by default which is responsible for initializing the object. By default
every class has a default constructor which is a constructor with no arguments. However once you provide a constructor to a class
then the default constructor does not exist. e.g. class Stack{ int size;int top; int arr []; Stack(int a) //constructor of the class { size = a;
arr = new int[size]; }}; The destructor is the last member function called in the lifetime of a class object. Its job is to free the resources
that an object is holding. A class can have no more than a single destructor. The name of the destructor is ~ classname (). Like a
constructor, a destructor cannot have a void return type. e.g. ~Stack () //destructor { delete [] arr; }
======================
What is Inheritance ? How is a Class Inherited in C++ ?
Inheritance is one of the most important principles of object oriented language. Using inheritance one can create a class that can
have traits common to a set of related items. This class is then inherited by other classes each adding things are specific to them.
The class that is inherited is called the base class and the class that inherits from it is called as the derived class. When a class
inherits a base class, then all the members of the base class become members of the derived class. E.g. class derived-class-name::
access base-class-name{ //body of class}; The access of the members in the base class by derived class depends on the access
parameter. The access specifier must either be private, public or protected. If one doesn’t provide an access specifier then it is taken
as private by default. When access specifier is private then these members remain private to base class and the derived class cannot
access them. When access specifier is public then all the public members of a base class become public members of the derived
class and all the protected members of the base class become protected in the derived class. On using a protected access specifier
all public and protected members of the base class become protected members of the derived class.
================================
What are Virtual Functions ? Why do we need Virtual Functions? Explain with an example.
A function that is defined in a base class but overridden by the derived class is called a virtual function. To create virtual functions
precede the function declaration in the base class with the keyword virtual. When a class containing a virtual function is inherited the
derived class overrides the virtual function with its own definition. Virtual functions are like member functions however what makes
them different is the capability to support run time polymorphism when accessed via a pointer. A base class pointer can point to an
object of a derived class. When a base class pointer points to an object of a derived class that contains a virtual function, C++
determines which function version to call based on the type of object pointed by the base class pointer. This is runtime polymorphism
as it can be determined at run time. In this way when different objects are pointed to then different versions of virtual functions are
executed. Whenever a virtual function is defined all aspects of its prototype should match. Also virtual functions should be non static
members of the class and they cannot be friend functions too. E.g. class base { public: virtual void display (); }; class derived: public{
public: virtual void display ();};base *p, b;derived d1, d2;p = &b;p->display (); //calls base class functionp = &d1;p->display (); //calls
derived class function
======================
What are Templates in C++ ? How are Templates declared and used ?
Many data structures and algorithms can be defined independently of the type of data they manipulate. A template allows the
separation of the type dependent part from the type independent part. This results in a significant amount of code reusability.
Templates can be class templates or function templates. A class template is used for creating a class in which one more values are
parameterized. The syntax of a class template is:
template class class-name{ ...};
A class template can also have multiple parameters.
template class class-name{ ...};
Example -
template class Array{ private: T *arr []; public: Array (int size = 10); };template Array::Array(int
size){ arr = new T[size];}
Create an Array object as: Array a; The function template is also written using the keyword template.
E.g. template class void push (T &element) { arr[top] = elemen
========================
What is Polymorphism ? How is Polymorphism achieved in C++ ?
Polymorphism is one of the most important principle of object oriented language. Polymorphism means many forms i.e. one interface
multiple methods. The specific method to call depends on the nature of the situation. No matter what type of car it is the driving
mechanism is the same. For example, you might have a program that defines three different types of stacks. One stack is used for
integer values, one for character values, and one for floating-point values. Because of polymorphism, you can define one set of
names, push() and pop() , that can be used for all three stacks. In your program you will create three specific versions of these
functions, one for each type of stack, but names of the functions will be the same. The compiler will automatically select the right
function based upon the data being stored. Thus, the interface to a stack—the functions push() and pop() —are the same no matter
which type of stack is being used. C++ supports both run time and compile time polymorphism. Function overloading is a form of
compile time polymorphism while dynamic binding is a form of runtime polymorphism.
===============
What are the Standard Exceptions in C++ ?
C++ defined a hierarchy of standard exceptions that are thrown at runtime whenever an abnormal condition takes place. These
exceptions are derived from std::exception class defined in the header. Since there is a common base class of all these exceptions it
enables the application to catch these exceptions in a single catch statement. E.g. catch (std::exception &e){//code to handle the
exception} Some of the standard exceptions that are built in the language are: - std::bad_alloc: thrown by operator new -
std::bad_cast: as a result of dynamic_cast - std::bad_typeid: as a result of operator typeid - std::bad_exception: Whenever you want
to catch all exceptions then the exception parameter in the catch block should be an ellipsis. E.g. catch (…){ //this block will catch all
exceptions}
==============
What is Multiple Inheritance in C++ ? Explain with an example
It is possible for a derived class to inherit more than a single base class. This is referred as multiple inheritance. The class inherits
from multiple base classes where these classes are comma separated. Each listed base class must specify its own access level.
E.g.
class base1
{}
;
class base2
{}
;
class derived: public base1, public base2
{
};
The base class constructors are invoked in the declaration order within the class derivation list. In the above example the constructor
for base1 will be called first followed by the base2 constructor. Similarly the order of destructor is reverse of the constructor order.
If a class inherits from one or more base classes which themselves inherit from a common base class then it can lead to problems. In
such case one should use virtual inheritance. Under virtual inheritance only a single shared base class object is inherited regardless
of how many times the base class occurs in the derivation hierarchy.
E.g.
class derived: public virtual base1, public virtual base2
{}
;
==================
What is a Copy Constructor in C++ ? Give an example
Copy constructor is a type of constructor which constructs an object by copying the state from another object of the same class.
Whenever an object is copied, another object is created and in this process the copy constructor gets called. If the class of the object
being copied is x, the copy constructor’s signature is usually x::x (const x&).
Let’s take an example to illustrate this:
class Complex
{ int real, img;
public:
Complex (int, int);
Complex (const Complex& source); //copy constructor
};Complex:: Complex (const Complex& source)
{ this.real =
source.real;
this.img = source.img;
}
main ()
{
Complex a (2, 3);
Complex b = a; // this invokes the copy constructor
}
A copy constructor is called whenever an object is passed by value, returned by value or explicitly copied.
==================================
What is Function Overloading in C++ ?
Function overloading is the process of using the same name for two or more functions. However each function will be different in
terms of either different types of parameters or a different number of parameters. It is only through these differences that the compiler
knows which function to call in any given situation. Even if the number of parameters are same and types are same but they are
written in a different order then these functions will still be considered different. The return type parameter does not hold any
relevance to make two functions distinct. E.g. void display (int a);void display (string str); Both the above functions have the same
name but different parameters. So when a function display (2) is called the compiler calls the first function and when the argument
passed to display is a string then the second version is invoked.E.g. int display (int a );void display (int a); In the above example the
compiler will generate a compile time error as the return types are insufficient to overload functions
====================================
What are Pointers in C++ (Object Oriented Programming) ?
Pointers are used to store memory address values of objects. C++ defines a special address-of operator that when applied to an
object returns that object’s address value. E.g. int *pint; //this defines a pointer variableIn order store the address of the variable ‘j’ into
pint one should assign the address of j into pint variable as follows:pint = &j; // assigning the address of variable j into pointer pint In
order to access the actual object pint addresses we must first dereference pint using the dereference operator (*). *pint = *pint + 1; //
this statement will increment the value pint points to by 1 The type of the pointer variable should be the same as the variable whose
address it is used to hold. E.g. you cannot define a pointer variable of type float and use it to assign the address of a variable of type
integer
========================
What are volatile variables ? Explain Volatile variables
A variable is declared as volatile if its value can possibly be changed in ways outside either the control or detection of the compiler.
For example a variable that is updated by the system clock. Certain optimizations ordinarily performed by a compiler should therefore
not be applied to objects the programmer specifies as volatile. The volatile qualifier is used in much the same way as is the const
qualifier as an additional modifier to a type.E.g. volatile int count_value; The purpose of defining a variable as volatile is to inform the
compiler that the variable can change in ways undetectable by the compiler and hence the compiler should not perform any kind of
optimizations on these variables.
============================
What is the Difference between Overloaded Functions and Overridden Functions ?
In C++, overloading is simply the use of the same function identifier for different functions declared in the same scope.
E.g. void display (int);void display (string);
The above two functions are clearly overloaded. The compiler will distinguish among them by the actual argument used in the call to
display.
Overriding can occur only in the presence of a base class virtual function. Overriding has nothing whatsoever to do with overloading.
A nonvirtual base class function cannot be overridden, only hidden. In overriding the function prototype in the derived class has to be
exactly the same as the one in the base class
=============================
What are Inline Functions ? When are Inline Functions used ?
The idea behind inline functions is to insert the code of a called function at the point where the function is called. It is useful to
distinguish between "inline," a keyword qualifier that is simply a request to the compiler, and "inlined," which refers to actual inline
expansion of the function. A function can be decorated with the inline keyword either in the class definition or in its own definition if the
definition physically occurs before the function is invoked. The compiler does not promise that an inline function will be inlined, and the
details of when/when not are compiler-dependent. On the other hand, any function that is defined within the class body will be treated
implicitly as an inline function with or without the explicit inline keyword. Inline code is faster than a function call for two reasons. First,
a CALL instruction takes time to execute. Second, if there are arguments to pass, these have to be placed on the stack, which also
takes time
============================
What are Mutable and Const in C++ ?
Class member functions may be declared as const, which causes them to be treated as a const pointer. Thus, that function cannot
modify the object that invokes it. Also, a const object may not invoke a non-const member function. However, a const member
function can be called by either const or non-const objects. Sometimes there will be one or more members of a class that you want a
const function to be able to modify even though you don't want the function to be able to modify any of its other members. You can
accomplish this through the use of mutable. It overrides constness. That is, a mutable member can be modified by a const member
function. E.g. class MyClass{ int i; mutable int j; Public: void setValues const () { i = 10; //wrong j = 15; //correct }};
===========================
What is ‘this’ Pointer (object) in C++
When a member function is called, it is automatically passed an implicit argument that is a pointer to the invoking object (that is, the
object on which the function is called).This pointer is called this.Within a member function, the members of a class can be accessed
directly, withoutany object or class qualification. The this pointer points to the object that invoked the member function. Also the this
pointer is automatically passed to all member functions. Another thing to note is that the friend functions are not members of a class
and, therefore, are not passed a this pointer. Second, static member functions do not have a this pointer. e.g. class Stack { int top; int
size; Stack (int top, int size) { this.top = top; this.size = size; }};
========================
What is Scope Resolution Operator in C++?
There are two used of the scope resolution operator in C++. The first use being that a scope resolution operator is used to unhide the
global variable that might have got hidden by the local variables. Hence in order to access the hidden global variable one needs to
prefix the variable name with the scope resolution operator (::). e.g. int i = 10; int main () { int i = 20; Cout << i; // this prints the value
20 Cout << ::i; // in order to use the global i one needs to prefix it with the scope //resolution operator. } The second use of the
operator is used to access the members declared in class scope. Whenever a scope resolution operator is used the name of the
member that follows the operator is looked up in the scope of the class with the name that appears before the operator.
==================================
What is Scope Resolution Operator in C++?
There are two used of the scope resolution operator in C++. The first use being that a scope resolution operator is used to unhide the
global variable that might have got hidden by the local variables. Hence in order to access the hidden global variable one needs to
prefix the variable name with the scope resolution operator (::). e.g. int i = 10; int main () { int i = 20; Cout << i; // this prints the value
20 Cout << ::i; // in order to use the global i one needs to prefix it with the scope //resolution operator. } The second use of the
operator is used to access the members declared in class scope. Whenever a scope resolution operator is used the name of the
member that follows the operator is looked up in the scope of the class with the name that appears before the operator.
===================
What are Const Member Functions in C++ ?
There can be two cases in which a member function can be declared as a const function: whenever the member function wants to
guarantee that it won't make any changes to its this object or whenever a caller needs to invoke the member function via a referenceto-
const or pointer-to-const. The compiler wont allow a const member function to change *this or to invoke a non-const member
function for this object. E.g. int getCount() const;int getCount () const{ //function definition}
===========================
Explain Composition in C++ with an example
Composition allows software to be developed by assembling existing components rather than creating new ones. Composition is also
sometimes called as aggregation and defines the process of putting an object inside another object. It models the has-a relationship.
E.g. a class employee can contain an object of type salary which itself is another type of object. e.g.
class Salary{ private: double DA; double HRA; double travelAllowance; double basic salary; public: //member functions};Class
Employee{ private: int empno; Salary salary; //composition: salary object is contained inside employee public: //member functions};
==================
What do you mean by ‘Return by Reference’ in C++ ?
A function can be declared to return a pointer or a reference. When the function is returning a reference, the calling function receives
the lvalue for the variable. The calling function can then modify the variable or take its address.
If the return value is a large class object, using a reference (or pointer) return type is more efficient than returning the class object by
value. In some cases, the compiler can automatically transform a return by value to a return by reference.
E.g.
Complex& compute (Complex c)
{
Complex *tmp = new Complex ();
// …
return tmp;
}However care should be exercised when returning a reference to a local object. The lifetime of the local object terminates with the
termination of the function. The reference is left aliasing undefined memory after the function terminates.
====================
What are static Data and Static Member Functions in C++ ?
Static data members are data and functions that are associated with the class itself, rather than with the objects of the class. For
example a count is needed of how many objects of a particular class type have been created at any one point in the program. A static
data member acts as a global object that belongs to its class type. Unlike other data members where each class object has its own
copy, there is only one copy of a static data member per class type. A static data member is a single, shared object accessible to all
objects of its class type. A data member is made static by prefixing the data member declaration within the class body with the
keyword static or prefixing the function declaration with the keyword static. A static function cannot access any other member
variables of the object. One does not need to create a class object for accessing a static member or a static function; a static function
can be invoked using the class name as class_name::static_member_function. e.g. class ShoppingCart{ private: static int totalItems;
//static data member public: static int getTotalItems (); //static member function};
===========================
What is a Pure Virtual Member Function ?
Whenever a virtual function in a base class is not redefined by the derived class then the version defined in the base class will be
used. However in many cases it may so happen that there can be no meaningful definition of a virtual function within the base class.
Or you may want to ensure that all derived classes override a virtual function. To handle both these cases the solution is a pure virtual
function.
A pure virtual function is a function that has no definition in the base class. The definition of such a function is equal to 0.E.g. void
draw () = 0; // this is a pure virtual function
If a class contains at least one virtual function then that class is called an abstract class and one cannot create an instance of an
abstract class. Also if a class inherits from a class that contains a pure virtual function then the derived class has to provide a
definition for the pure virtual function. Failure to do so will result in an abstract derived class.
==============================
What are Preprocessor Directives ?
The preprocessor directives are instructions to the compiler. All these preprocessor lines begin with a pound (#). They are executed
before the compilation of the code begins. These directives can only span a single line and does not need to end in a semicolon.
The preprocessor contains the following directives:
- #define: this defines an identifier and some value to this identifier. This value can be any character sequence and will be substituted
in the code file for each instance of the corresponding identifier.
e.g. #define MIN 0
- #include: it tells the compiler to link to another source file. The name of the source file can be in angle brackets or double quotes.
e.g. #include
- #error: tells the compiler to stop compilation. Used primarily for debugging purposes.
- #if:
- #elif
- #endif
- #else: The above four directives are conditional directives. They allow you to conditionally include portions of code based on
outcome of a constant expression.
E.g. #if OPTION == 1
//do something
#else
//do something else
#endif
- #ifndef
- #undef: the above indicates conditional compilation dependinf upon if a variable is defined or not defined.
======================================
