Explore topic-wise InterviewSolutions in .

Deep copy involves using the contents of one object to create ANOTHER INSTANCE of the same class. In a deep copy, the two objects may contain ht same information but the target object will have its own buffers and resources. the destruction of either object will not affect the remaining object. The overloaded assignment operator would create a deep copy of objects.

Shallow copy involves copying the contents of one object into another instance of the same class thus creating a mirror image. Owing to straight copying of references and pointers, the two objects will share the same externally contained contents of the other object to be unpredictable.

Using a copy constructor we simply copy the data values member by member. This method of copying is called shallow copy. If the object is a simple class, comprised of built in types and no pointers this would be acceptable. This function would USE the values and the objects and its behavior would not be altered with a shallow copy, only the ADDRESSES of pointers that are members are copied and not the value the address is pointing to. The data values of the object would then be inadvertently altered by the function. When the function goes out of scope, the copy of the object with all its data is popped off the stack.

If the object has any pointers a deep copy needs to be executed. With the deep copy of an object, memory is allocated for the object in FREE store and the elements pointed to are copied. A deep copy is used for objects that are returned from a function.

Stack Unwinding happens during exception handling. During an exception occurrence, the destructor is called to destroy all local objects for the place where the exception was thrown and where it was caught. An exception causes the control to pass on from a try block to the RESPECTIVE exception handler.  The destructors for all constructed automatic objects are called at run time which where created since the beginning of the try block. The automatic objects are destroyed in REVERSE order of their construction.

Note: The corresponding objects must be created before destruction of the same which takes place during Stack Unwinding.

The terminate() function is invoked during Stack Unwinding on a destructor for a unhandled exception.

The following EXAMPLE demonstrates this:

The output of this example:

In the try block, two automatic objects are created: a and b. The try block throws an exception of type const char*. The handler catch (const char* e) catches this exception. The C++ run time unwinds the stack, calling the destructors for a and b in reverse order of their construction. The destructor for a throws an exception. Since there is no handler in the program that can handle this exception, the C++ run time calls terminate(). (The function terminate() calls the function specified as the argument to set_terminate(). In this example, terminate() has been specified to call my_terminate().)

Though both of them PERFORM similar tasks, the differences between a Copy Constructor and an assignment operator is as follows:

• While the former is an overloaded Constructor the LATTER is a Bitwise Operator.
• The Copy Constructor can be used to initialize a new object with an existing object which is an overloaded Constructor while an assignment operator is INVOKED only when an object is being assigned to ANOTHER object.
• An assignment operator returns a value by default unlike a Copy Constructor. Both of them perform shallow copying by default. An overloaded assignment operator can be used to do DEEP copying.

One of the LATEST FEATURES of C++11 are a Move CONSTRUCTOR and a Move Assignment operator. We KNOW that a Copy Constructor and a Copy Assignment is used to make a copy of one object to another, the Move Constructor and Move Assignment is to shift the ownership of the resources from one object to other. This is less expensive that object to object copy. A Move Constructor and Move Assignment operator is not provided by the COMPILER by default and one needs to implement the same.

The above can be demonstrated using the below program:        

Output:

Below is the logic for the implementation of the above logic

In the en-QUEUE operation, the new element is entered at the top of Stack1. In de-queue operation, if Stack2 is empty then all the elements are moved to Stack2 and top of Stack2 is returned.

enQueue(q, k):

Push the element ‘k’ to Stack1

deQueue(q):

While Stack1 is not empty and Stack2 is empty, pop the elements from Stack1 and push to Stack2.

The top of the Stack2 popped out is returned.

Program to perform the above:

Output:

A Sparse Matrix is an array of elements in which many elements have a value of zero.

Output:

We cant make a class constructor virtual in C++ to create polymorphic objects. C++ being static typed (the purpose of RTTI is different) language, it is meaningless to the C++ compiler to create an object polymorphically. The compiler must be aware of the class type to create the object. In other words, what type of object to be created is a compile time decision from C++ compiler perspective. If we make constructor virtual, compiler flags an error. In fact except INLINE, no other keyword is allowed in the declaration of constructor.

Deleting a derived class object using a pointer to a base class that has a non-virtual destructor results in undefined behavior. To correct this situation, the base class should be defined with a virtual destructor. For example, following program results in undefined behavior.

Using pthread_create we create a THREAD. We can USE the reference of a structure to pass multiple arguments to the 4th parameter as below:

In C++, RTTI (Run-time type information) is a mechanism that exposes information about an object’s data type at runtime and is available only for the classes which have at least ONE virtual function. It allows the type of an object to be determined during program runtime execution

For example, dynamic_cast uses RTTI and following program fails with error “cannot dynamic_cast `b’ (of type `class B*’) to type `class D*’ (source type is not polymorphic) ” because there is no virtual function in the base class B.

UPCASTING is converting a derived class reference or pointer to a base class. In other WORDS, upcasting allows us to treat a derived type as though it were its base type. It is always allowed for public inheritance, WITHOUT an explicit type cast. This is a result of the is-a relationship between the base and derived classes. Upcasting allows us to treat a derived type as though it were its base type.

When a derived class object is passed by value as a base class object, the specific behaviors of a derived class object are sliced off. We're left with a base class object. In other words, if we UPCAST (Upcasting and Down Casting) to an object instead of a pointer or reference, the object is sliced. As a result, all that remains is the sub object that corresponds to the destination type of our cast and which is only a part of the actual derived class.

Converting a base-class pointer (reference) to a derived-class pointer (reference) is called downcasting. Downcasting is not allowed without an explicit TYPECAST. The reason for this restriction is that the is-a relationship is not, in most of the cases, symmetric. A derived class could add new data members, and the class member functions that used these data members wouldn't apply to the base class.

//Example of upcasting and downcasting:

#INCLUDE <string> #include <stdexcept> #include <iostream> using NAMESPACE std; class Palindrome { public:    static bool isPalindrome(const std::string&AMP; word)    {        static int i,j;        static int count;        while(word[count]!='\0')            count++;        cout<<"count is"<<count<<endl;        i=0;        j=count-1;        while(i<j)        {            cout<<endl<<"word[i]"<<word[i]<<endl<<"word[j]"<<word[j]<<endl;            if(tolower(word[i++])!=tolower(word[j--]))            {                cout<<endl<<word<<" is not a Palindrome"<<endl;                return 0;            }        }        cout<<endl<<word<<" is a palindrome"<<endl;        count = i = i= 0;        return 1;    } }; #ifndef RunTests int main() {     std::cout << Palindrome::isPalindrome("Deleveled");     std::cout << Palindrome::isPalindrome("Malayalam");     std::cout << Palindrome::isPalindrome("Bab");     std::cout << Palindrome::isPalindrome("Balam"); } #ENDIF

#include <iostream> // M x N matrix #DEFINE M 4 #define N 5 // DYNAMICALLY Allocate Memory for 2D ARRAY in C++ int main() { // dynamically allocate memory of size M*N int* A = new int[M * N]; // assign VALUES to allocated memory for (int i = 0; i < M; i++) for (int j = 0; j < N; j++) *(A + i*N + j) = rand() % 100; // print the 2D array for (int i = 0; i < M; i++) { for (int j = 0; j < N; j++) std::cout << *(A + i*N + j) << " ";    // or (A + i*N)[j]) std::cout << std::endl; } // deallocate memory delete[] A; RETURN 0; }

#include <stdexcept> #include <iostream> #include <vector> #include <utility> #include <unordered_map> using NAMESPACE std; class TwoSum { public:   static pair<INT, int> findTwoSum(const std::vector<int>& list, int sum)   {      unordered_map<int,int> s;      for (size_t i = 0; i < list.size(); ++i)      {         auto j = s.find(sum - list[i]);         if (j != s.end())           return make_pair(i,j->second);         s[list[i]] = i;      }      return make_pair(-1, -1);   } }; #ifndef RunTests int main(int ARGC, const CHAR* argv[]) {   std::vector<int> list;   list.push_back(3);   list.push_back(1);   list.push_back(5);   list.push_back(7);   list.push_back(5);   list.push_back(9);   pair<int, int> INDICES = TwoSum::findTwoSum(list, 12);   cout << indices.first << '\n' << indices.second;   return 0; } #endif

Output is:

An abstract class is a class which has atleast one pure virtual function. An abstract class cant be instantiated be can be overridden in a derived class as below:

//Example below:

You can make a class VIRTUAL if it is a base class that has been

PASSED to more than one derived class, as might happen with multiple

inheritance.

A base class can't be specified more than once in a derived class:

However, a base class can be indirectly passed to the derived class more than once:

In this case, each object of class Z will have two sub-objects of class B.

If this causes problems, you can add the keyword "virtual" to a base class

specifier. For example,

B is now a virtual base class, and class Z has only one sub-object of class

B.

Constructors for Virtual Base Classes:

Constructors for virtual base classes are INVOKED before any non-virtual base classes. If the hierarchy CONTAINS multiple virtual base classes, the virtual base class constructors are invoked in the order in which they were declared. Any non-virtual bases are then constructed before the derived class

constructor is CALLED. If a virtual class is derived from a non-virtual base, that non-virtual base will be first, so that the virtual base class can be properly constructed. For example, this code

Vectors and Lists are defined under C++ Standard Template Library (STL). These data structures are basically sequential containers implemented using STLs.

The differences between them are as follows:

• A Vector is a contiguous BLOCK of memory locations similar to Arrays in “C” programming while a List stores non-contiguous blocks and uses a double LINKED list.
• Inserting and DELETING elements in a List is easier compared to Vector as in the latter, shifting of elements is required and it is a tedious process.
• However sorting and searching are much faster in Vector compared to List and in former no TRAVERSAL is required unlike List.
• Lists support no numeric index LIKE Array while Vector supports the same.
  • Insertion and Deletion of elements in List has no iterator validation unlike Vector where the same is possible.

Smart Pointers are used for better garbage collection so that there are no memory leaks. Using Smart Pointers, there is no NEED to call delete for any memory allocated dynamically and it gets automatically deallocated.

Smart Pointers Implementations can be found in C++11 and higher versions. C++11 libraries provide four kinds of Smart pointers namely: auto_ptr, unique_ptr, shared_ptr and weak_ptr.

The below example implements a generic smart pointer which can used for all datatypes:

Design Patterns are reusable SOLUTIONS that can be applied to recurring Object Oriented Design problems. Singleton is one such design PATTERN that comes under the category of Creational Design Pattern. It can be used to design such a class which can at most have only single instance at any point of time and cant be instantiated further. This concept can applied for creation of a logger or hardware interface class which can have only one instance running at all times.

Example of Singleton class that is thread safe:

In order to make the class thread safe, one needs to only create an instance when no other instance exists as below:

The FOLLOWING program demonstrates this.   

While building an object of a derived class first the constructor of the base class and then the constructor of the derived class gets called. The object is said an immature object at the stage when the constructor of base class is called. This object will be called a matured object after the execution of the constructor of the derived class. Thus, if we call a virtual function when an object is still immature, obviously, the virtual function of the base class WOULD get called. This is illustrated in the following example.

The output of this program would be:                         

#include<iostream>                              class date                              {                              private :                              int DAY ;                              int month ;                              int year ;                              public :                              date ( int d = 0, int m = 0, int y = 0 )                              {                              day = d ;                              month = m ;                              year = y ;                              }                              // COPY constructor                              date ( date &d )                              {                              day = d.day ;                              month = d.month ;                              year = d.year ;                                }                              // an overloaded assignment operator                              date operator = ( date d )                              {                              day = d.day ;                              month = d.month ;                              year = d.year ;                              RETURN d ;                                }                              void display( )                              {                              cout << day << "/" << month << "/" << year ;                              }                              } ;                              void main( )                              {                              date d1 ( 25, 9, 1979 ) ;                              date d2 = d1 ;                              date D3 ;                              d3 = d2 ;                              d3.display( ) ;                              }

This concept is used to create a Singleton Class. Below is CODE snippet demonstrating the same: 

Here, the class sample contains a static data member ptr, which is a pointer to the object of same class. The constructor is private which avoids us from creating objects outside the class.  

A static member function CALLED create( ) is used to create an object of the class. In this function the condition is checked WHETHER or not ptr is NULL, if it is then an object is created dynamically and its address collected in ptr is returned. If ptr is not NULL, then the same address is returned. Thus, in main( ) on execution of the first statement one object of sample gets created whereas on execution of second statement, b holds the address of the first object. Thus, whatever number of times you call create( ) function, only one object of sample class will be available. 

No!. This is because even if we provide the DEFAULT arguments to the PARAMETERS of the overloaded operator function we would end up using the binary operator incorrectly. This is explained in the following example:

There are two ways in which we can refer to a name of class or function that is defined within a namespace: Using scope resolution OPERATOR ‘::’ through the using keyword. This is shown in following example:

On the other hand we can directly refer to class sample2 because of the statement using namespace name2 ; the using keyword declares all the NAMES in the namespace to be in the current scope. So we can USE the names without any qualifiers.

Here, class sample1 is referred using the scope resolution operator. On the other hand we can directly refer to class sample2 because of the statement using namespace name2 ; the using keyword declares all the names in the namespace to be in the current scope. So we can use the names without any qualifiers.

#include &LT;iostream> ostream& myhex ( ostream &o ) { o.setf ( ios::hex) ; return o ; } INT MAIN( ) { cout << endl << myhex << 2000 ; return 0; }

Output:

The scope resolution operator ‘::’ can be USED to refer to members of the global NAMESPACE. Because the global namespace doesn’t have a name, the notation :: member-name refers to a member of the global namespace. This can be useful for REFERRING to members of global namespace whose NAMES have been hidden by names declared in nested local scope. Unless we SPECIFY to the compiler in which namespace to search for a declaration, the compiler simple searches the current scope, and any scopes in which the current scope is nested, to find the declaration for the name.

An inline function is a request and not a COMMAND. Hence it won't be compiled as an inline function always.

Inline-expansion could fail if the inline function CONTAINS loops, the address of an inline function is used, or an inline function is CALLED in a COMPLEX expression. The rules for in-lining are compiler dependent.

The main characteristics of static functions are as follows:

• It is without the a “this” POINTER. This is because it has no object address and HENCE “this” pointer is not passed as an internal parameter to the same. Also it can can be invoked even before creation of OBJECTS USING scope resolution operator.
• It can't directly access the non-static members of its class.
• It can't be declared const, volatile or virtual.
• It doesn't need to be invoked through an object of its class, although for convenience, it may.

Name mangling is the process through which the C++ compilers give each FUNCTION a in program a unique name. In C++, all programs have at-least a few functions with the same name. Name mangling is a concession to the FACT that LINKER always INSISTS on all function names being unique. In C++, generally programs have at-least a few functions with the same name.

Example:

In general, member names are made unique by concatenating the name of the member with that of the class given the declaration:

class Bar

ival becomes something like:

Consider this derivation:

The internal representation of a Foo object is the concatenation of its base and derived class members.

Unambiguous ACCESS of either ival members is achieved through name mangling. Member functions, because they can be overloaded, require an extensive mangling to provide each with a unique name. Here the compiler generates the same name for the two overloaded instances(Their argument lists make their instances unique).   

Deep copy involves using the contents of one object to create another instance of the same class. In a deep copy, the two objects may CONTAIN ht same INFORMATION but the target object will have its own buffers and resources. the destruction of either object will not affect the remaining object. The overloaded assignment operator would create a deep copy of objects.

SHALLOW copy involves copying the contents of one object into another instance of the same class thus creating a mirror image. Owing to straight copying of references and pointers, the two objects will share the same externally contained contents of the other object to be unpredictable.

Using a copy constructor we simply copy the data values member by member. This method of copying is called shallow copy. If the object is a simple class, comprised of built in types and no pointers this would be acceptable. This function would use the values and the objects and its behavior would not be altered with a shallow copy, only the addresses of pointers that are members are copied and not the value the address is pointing to. The data values of the object would then be inadvertently altered by the function. When the function goes out of scope, the copy of the object with all its data is popped off the stack.

If the object has any pointers a deep copy needs to be executed. With the deep copy of an object, memory is allocated for the object in free store and the elements pointed to are copied. A deep copy is USED for objects that are returned from a function.

Stack Unwinding happens during exception handling. During an exception occurrence, the destructor is called to DESTROY all local objects for the place where the exception was thrown and where it was caught. An exception causes the CONTROL to pass on from a try block to the respective exception handler.  The destructors for all constructed automatic objects are called at run time which where created since the beginning of the try block. The automatic objects are destroyed in reverse order of their construction.

Note: The corresponding objects must be created before destruction of the same which takes place during Stack Unwinding.

The terminate() function is invoked during Stack Unwinding on a destructor for a UNHANDLED exception.

The following example demonstrates this:

The output of this example:

In the try block, two automatic objects are created: a and b. The try block throws an exception of type const char*. The handler catch (const char* e) CATCHES this exception. The C++ run time unwinds the stack, calling the destructors for a and b in reverse order of their construction. The destructor for a throws an exception. Since there is no handler in the program that can handle this exception, the C++ run time calls terminate(). (The function terminate() calls the function specified as the argument to set_terminate(). In this example, terminate() has been specified to call my_terminate().)

Though both of them perform similar tasks, the DIFFERENCES between a COPY Constructor and an assignment operator is as follows:

• While the former is an overloaded Constructor the latter is a Bitwise Operator.
• The Copy Constructor can be used to initialize a new object with an EXISTING object which is an overloaded Constructor while an assignment operator is invoked only when an object is being assigned to another object.
• An assignment operator RETURNS a VALUE by default unlike a Copy Constructor. Both of them perform shallow copying by default. An overloaded assignment operator can be used to do deep copying.

One of the latest FEATURES of C++11 are a Move Constructor and a Move Assignment operator. We know that a Copy Constructor and a Copy Assignment is USED to make a copy of one object to another, the Move Constructor and Move Assignment is to shift the ownership of the resources from one object to other. This is less EXPENSIVE that object to object copy. A Move Constructor and Move Assignment operator is not provided by the compiler by default and one needs to IMPLEMENT the same.