Amadeus IT Group C++ Interview Questions Answers

Amadeus IT Group Most Frequently Asked Latest C++ Interview Questions Answers

Explain The Term Memory Alignment?

The primary meaning of the term alignment is to maintain the appropriate positioning of different components in the memory with respect to each other. In C++, there is a requirement of setting of various objects and variables in a particular way in the system's memory.Therefore, many data variables are aligned automatically by the compiler according to their processor and type.

Can A New Be Used In Place Of Old Mallocq? If Yes, Why?

The new operator should be used in place of old malloc because the new operator ensures the calling of an appropriate destructor at the time of execution and also it is more type-safe than mallocQ.

Is It Possible To Use A New For The Reallocation Of Pointers ?

The reallocation of pointers cannot be done by using new. It can be done by using the reallocQ operator.

On Throwing An Exception By The Animal Constructor In P = New Animalq, Can Memory Leak Occur?

Memory of an animal class cannot leak by throwing an exception in p = new Animal(). In case of occurrence of an exception during the Animal constructor of p = new Animal(),there is a surety of the automatic releasing of the allocated memory back to the heap.

What Would Happen On Forgetting [], While Deallocating An Array Through New?

If you forget to use [] while deallocating an array through new, it throws a run time or compile time exception and results in the corruption of the heap.Therefore, it is the responsibility of the programmer to establish the connection between T[n] and delete[]p correctly.
Amadeus IT Group Most Frequently Asked Latest C++ Interview Questions Answers
Amadeus IT Group Most Frequently Asked Latest C++ Interview Questions Answers

What Is Meant By Forward Referencing And When Should It Be Used?

Forward referencing is generally required when we make a class or a function as a friend.Consider following program

class test
{
    public
        friend void fun ( sample, test ) ;
} ;

class sample
{
    public
        friend void fun ( sample, test ) ;
} ;

void fun ( sample s, test t )
{
    // code
}

void main( )
{
    sample s ;
    test t ;
    fun ( s, t ) ;
}
On compiling this program it gives error on the following statement of test class. It gives an error that sample is undeclared identifier. friend void fun ( sample, test ) ; This is so because the class sample is defined below the class test and we are using it before its definition. To overcome this error we need to give forward reference of the class sample before the definition of class test. The following statement is the forward reference of class sample.

class sample;

Write My Own Zero-argument Manipulator That Should Work Same As Hex?

This is shown in following program.

#include
ostream& myhex ( ostream &o )
{
  o.setf ( ios::hex) ;
  return o ;
}
void main( )
{
  cout << endl << myhex << 2000 ;
}
   
We All Know That A Const Variable Needs To Be Initialized At The Time Of Declaration. Then How Come The Program Given Below Runs Properly Even When We Have Not Initialized P?

#include<iostream>
Void Main( )
{
      Const Char *p ;
      P = "a Const Pointer" ;
      Cout << P ;
}

The output of the above program is 'A const pointer'. This is because in this program p is declared as 'const char*' which means that value stored at p will be constant and not p and so the program works properly.

Write About The Retrieval Of N Number Of Objects During The Process Of Delete[]p?

The n number of objects can be retrieved with the help of the pointer p (it stores the n number of objects) at the run time.

This can be achieved by the application of two techniques, which are

An array which can be associated with p in the form of key and a value such as n.
Over-allocation of the array can be done. The preceding techniques are used by the compilers of commercial grade.

Is It Possible For A Member Function To Use Delete This?

It is possible for a member function to use delete this but on certain conditions which are as follows

 Ensure that the allocation of this object is done through new[] operator.
Ensure that the invocation of a member function done on this (current) object will be the last member function.
Ensure that calling of other member functions and data members should not be done after the line of code which includes delete this.
Examination or comparison of this pointer with other pointers and NULL, printing or casting it, must be avoided after using the delete this.
The preceding points are applied in the cases where the this pointer belongs to the base class in the absence of the virtual destructor.

Discuss The Effects Occur, After An Exception Thrown By A Member Function Is Unspecified By An Exception Specification?

When a function throws an exception, not given in the specification, the exception is passed to a system function named unexpected. The unexpected function calls the latest function named as an argument in a call to the set_unexpected function, which returns its current settings. A function with no exception specification, by default, calls the terminate function, which finally calls the abort (function to terminate the program).

How Can I Be Thrown Polymorphically?

The following code can be used to throw i polymorphically

classExceptionParent { );
classE,cceptionChild : public ExceptionParent ( );
void f(ExceptionParent8 e)
/1
throw e;
void go
ExceptionChild e;
try(
fCc);
catch (ExceptionChild& e) (
//...code to handle ExceptlonChild...
catch C...) (
//...code to handle other exceptions...
)
)
In the preceding code, you can enter the catch (...) clause in the absence of throwing i polymorphically. The throw e in the function f () throws the same type of an object as an expression of static type.

What Is The Role Of Copy Constructor In Copying Of Thrown Objects?

A copy constructor with a public access specifier must be applied to the objects which are thrown.With the help of a compiler, the code is generated through which copying of thrown objects can be done. The thrown objects must have a copy constructor with the public access specifier.

How Can An Improvement In The Quality Of Software Be Done By Try/catch/throw?

Error-handling is necessity while developing applications to account for unexpected situations, such as insufficient memory, resource allocation errors, inability to find/open files, division by zero, an arithmetic or array overflow, and the exhaustion of free heap space, which occur at runtime.

Programmers have various styles of dealing with such exceptions, such as try/catch /throw methods, which cause diversity in coding practice. This diversity increases with the use of user-defined classes, as each class brings with it potential class-specific errors. These methods provide a standard facility to deal with runtime exceptions. Moreover, try/catch/throw result in the code with fewer errors. It is low in cost in relation to development. With error-handling, your program can detect unexpected events and recover from them.

What Is A Dangling Pointer?

When the location of the deallocated memory is pointed by the pointer even after the deletion or allocation of objects is done, without the modification in the value of the pointer, then this type of pointer is called a dangling pointer.

Explain The Concept Of Memory Leak.

When a variable does not exist longer in the memory, and deletion or reuse of that variable cannot be done, then its destruction occurs automatically. This concept is called memory leak.
For example, consider the following code snippet

{
parent*p=new parent();
}
In the preceding code snippet, the p variable does not exist in the memory, but the variable is not deleted. Therefore, it becomes out of scope and its destruction occurs, which results in memory leak.

List The Issue That The Auto_ptr Object Handles?

The auto_ptr object is used to deallocate memory, which is allocated to a variable, when the variable goes out of scope.

What Are Smart Pointers?

Smart pointers are almost similar to pointers with additional features, such as automatic destruction of a variable when it becomes out of scope and the throwing of exceptions that ensures the proper destruction of the dynamically allocated objects. They are useful in keeping tracks of dynamically allocated objects. Due to these additional capabilities, they reduce the possibilities of occurrence of exceptions and errors in a program and ensure that the written code is safe and efficient.

How A Pointer Differs From A Reference?

A pointer differs from a reference in the following ways

 In the case of reference, an object must always be referred while initializing. On the contrary, such restrictions are not meant for pointers.
The different types of objects can be pointed by the pointers by reassigning the pointers with different objects. On the contrary, in a reference, the same object which was initialized earlier can only be referred by a reference.
You can use a null address in a pointer parameter to indicate that a variable does not exist; whereas, there is no existence of a null reference in C++.
 A reference usually appears outside an object; whereas, a pointer generally appears inside an object.

How Const Int *ourpointer Differs From Int Const *ourpointer?

As a rule, pointer declarations should be read from right to left. In the pointer declaration, const int *ourPointer, ourPointer is a pointer to a const int object, which cannot be changed by using a pointer. Whereas in case of the int const *ourPointer pointer declaration, ourPointer is a const pointer to an int object, in which an int object can be changed by using a pointer but the pointer itself cannot be changed because it is constant.

Explain How Overloading Takes Place In C++?

C++ supports two types of overloading namely, function overloading and operator overloading. Function overloading helps in defining more than one function with the same name, but with different signatures. An error is raised if two overloaded functions are provided with the same function signature. Operator overloading helps in giving special meanings to operators, when they are used with user-defined classes.

Post a Comment

Previous Post Next Post