Explore topic-wise InterviewSolutions in .

Right option is (b) Because inheritance follows is-a relationship

For explanation: The downcasting is POSSIBLE because the CLASSES in inheritance follow is-a relationship. HENCE the DERIVED class is a base class. Which in turn make the downcasting possible.

Right choice is (c) To compare two objects

Easiest explanation - The downcasting can be used WHENEVER there is a need to compare ONE object to another. Equals() function can be used to compare whether the objects were of same age. We can USE GETCLASS() function too.

Correct choice is (a) Compile time error

The best explanation: The IMPLICIT DOWNCASTING is not possible. If tried, the COMPILER PRODUCES an error. Since the compiler doesn’t allow coasting to a type that is not compatible.

Right choice is (b) DOWNWARD the inheritance order

Best explanation: The downcasting is always downward the inheritance order. Since the BASE class object have to be casted into derived class TYPE. This is a BASIC DEFINITION of downcasting.

Correct option is (b) False

The BEST explanation: The downcasting is not possible in java directly. This has to be done explicitly. The downcasting is not SAFE but can be checked for safe casting USING instanceof FUNCTION.

Right CHOICE is (a) By using INSTANCEOF

For explanation: The instanceof operator can be USED to CHECK the compatibility of the conversion. This has to be done to check WHETHER the casting would be safe or not.

The correct CHOICE is (c) dynamic_cast(object)

For explanation: The dynamic_cast is the name of the operator, which is FOLLOWED by the NEW type in which the object have to be converted. Then the object name is GIVEN. This object name is then USED after the type conversion.

Right answer is (d) null pointer

Easy EXPLANATION - The null pointer is RETURNED by the dynamic_cast, if it fails. The conversion sometimes fails because of too complex type conversion. The conversion MAY also fail DUE to memory or some RELATED issues.

The correct answer is (a) Address of OBJECT which is CONVERTED

For EXPLANATION: The address of the object which is converted is RETURNED by the dynamic_cast operator. This is done to safely convert the subtype to supertype. This ensures the proper assignment and conversion from ONE type to another.

Correct option is (b) Dynamic cast

The best I can explain: The dynamic cast can be done USING the operator dynamic_cast. This converts one TYPE to another type in a SAFE way.

Right choice is (b) Never safe

For explanation: The downcasting concept is made for exception cases. When there is a NEED to represent an entity in the FORM which is not suitable for it. Representing a base TYPE in DERIVED type is not right but can be done for special cases.

Right OPTION is (c) It must be DONE explicitly

Best EXPLANATION: The downcasting of any object must be done explicitly. This is because the compilers don’t support the implicit CONVERSION of a supertype to subtype.

Right OPTION is (b) Casting supertype to subtype

Explanation: The downcasting concept INCLUDES only the casting of supertypes to the sub types. This casting is generally done EXPLICITLY. Larger SIZE types are made to fit into SMALL size types explicitly.

The correct option is (d) UPCASTING is possible for any TYPE of inheritance

The EXPLANATION: The type of inheritance doesn’t matter with the upcasting CONCEPT. Upcasting APPLIES to all types of inheritance. Any derived class object can be upcasted to any of its base class object.

The CORRECT option is (a) Compile time

Best explanation: The pointer or REFERENCE types are known at compile time for the upcasting of an object. This is because the ADDRESSES must be known for CASTING the derived CLASS to base class object.

Right option is (b) Dynamic binding

The best explanation: SINCE the implicit type casting ALLOWS casting of a base class pointer to refer to its derived class OBJECT or even base class object. We need dynamic type casting so that the references can be RESOLVED during execution of program.

Right ANSWER is (a) ALWAYS allowed for public inheritance

The best EXPLANATION: The public inheritance shows the most flexible is-a relationship. Hence explicit TYPE casting is not required. Implicit type casting is DONE by the compiler.

Right answer is (C) Upcast to any BASE CLASS

The BEST I can explain: The upcasting of derived class object is possible to any base class. This is because the base class object can represent any of its derived classes USING upcasting.

Right option is (b) False

Easy explanation - It is a bit confusing concept since both casting CONCEPTS are different. Primitive casting DEPENDS on the TYPE and size of DATA being typecast. Whereas in objects casting, the classes and inheritance order plays a big role.

Right option is (c) Complex code simple syntax

For explanation: The code WRITTEN USING upcasting mostly SHOWS complex code in simpler syntax FEATURES. This is because the upcasting concept can be applied as polymorphism and to group the similar type of OBJECTS.

Right answer is (b) For general code DEALING with only supertype

Best explanation: When a general code has to be written where we USE only the supertype object or the data of bigger size, then upcasting would be the best OPTION. Since the WHOLE code will require only the supertype name references.

Right option is (a) UPCASTING

The explanation: The upcasting is always safe since the derived TYPE or the SMALLER type is converted into the base type or the larger size. This results in ALLOCATING a smaller size data into bigger type data. No data is lost in casting, hence safe.

Right answer is (b) UPWARD to the INHERITANCE tree

For explanation: The upcasting concept in inheritance is ALWAYS APPLIED upward the inheritance tree. The derived class objects can be type casted to any of its parent class type. Since is a relationship APPLIES in general inheritance.

Right option is (a) CASTING subtype to supertype

To explain I WOULD say: The UPCASTING concept INCLUDES only the casting of subtypes to the super types. This casting is GENERALLY done implicitly. Smaller size types can fit into larger size types implicitly.

Correct ANSWER is (B) One default VALUE constructor

For explanation: The constructor with one default ARGUMENT can be the best alternative. This is because the constructor with one default value will do the WORK for both the default constructor and one argument constructor.

Correct answer is (c) className(INT x=0,char c);

To EXPLAIN: The default ARGUMENTS, just like with member functions, must be listed at last in the ARGUMENT list. Hence this will produce a COMPILE time error. The compiler doesn’t allow the definition to be executed.

Correct answer is (a) className(int x=5,CHAR c=’a’);

Best explanation: The SYNTAX given is passing two PARAMETERS to the constructor CALL. One value is of integer type and another of character type. Hence the constructor with arguments of int and char type should be called. There is only one option that first accepts integer value and then a character value. Hence that constructor will be called.

Right option is (d) No, never

Best explanation: A single class can never have more than once CONSTRUCTOR with all the default arguments. This is because it will MAKE all those CONSTRUCTORS as a default constructor. And when an object is CREATED with zero arguments then it will CREATE ambiguity.

The CORRECT answer is (B) CONSTRUCTORNAME(int x=0, int y=0)

Easiest explanation - For a parameterized constructor to be used as a default constructor, it must have all the default arguments. This MAKES the constructor to have optional arguments which are not mandatory to be passed.

Correct option is (d) The constructors MUST have the same name as that of class

To EXPLAIN I would say: The constructors must have the same name as that of the class name. This is mandatory because only the constructor FUNCTIONS doesn’t have any return TYPE. ALSO, for overloading all the functions must have the same name.

Correct OPTION is (C) Use constructor with all default arguments

The best I can explain: The constructor should use all the default arguments. This will ALLOW the constructor to be called even if no arguments are passed. And if arguments are passed, those will be accepted INSTEAD of the default values.

Right option is (B) Constructors can be overloaded USING different SIGNATURES

The BEST explanation: The constructors can be overloaded only if the DEFINITIONS have different signatures. Constructors doesn’t have any return type so can’t be overloaded using return type. If constructors have same signature then it will produce a compile time error.

Right option is (a) Do not acquire base class declaration of default arguments

For explanation: The virtual FUNCTION overrides do not acquire the base class declaration of default arguments. Even if a call to the virtual function is MADE, static TYPE of the object DECIDES the default arguments to be USED.

The correct choice is (d) But are executed during FUNCTION call

For EXPLANATION: The default ARGUMENT are BOUND at the time of declaration. That is an IMPLICIT functioning. But those are executed only when the function is called. Otherwise, those will never get executed.

Right choice is (B) Carries over the known DEFAULT arguments

The EXPLANATION is: The using-declaration carries over all the known default arguments. This is a common FEATURE as the usage doesn’t gets affected even if the default arguments are added. This comes under FLEXIBLE programming.

Right answer is (a) If and only if the function is declared again in the same scope

To EXPLAIN I WOULD say: The non-template functions can also be added with default arguments. This can be done even if the functions were defined earlier. This is because the call to the function won’t be affected. The function can still be USED in the same way as it was used earlier.

Correct choice is (d) Those are allowed with pointer and reference to function declaration

Easy EXPLANATION - The statements GIVEN are true because that is a feature given to MAKE the PROGRAMMING more flexible and have some security with accidental changes at same time. The last option is false because it is not a rule defined. It is an opposite statement to the rules defined for DEFAULT arguments.

The CORRECT option is (a) Only allowed in the parameter list of the FUNCTION declaration

Explanation: The default arguments are only allowed in the parameter list of the function arguments. This rule was not applicable in the BEGINNING versions of c++ but LATER from c++ 14th version it has been implemented. This is the only way to USE default arguments.