85. main(){
char p[ ]="%d\n";
p[1] = 'c';
printf(p,65);
}
Answer:
A
Explanation:
Due to the assignment p[1] = ‘c’ the string becomes, “%c\n”. Since this string becomes the format string for printf and ASCII value of 65 is ‘A’, the same gets printed.
86.void ( * abc( int, void ( *def) () ) ) ();
Answer:
abc is a ptr to a function which takes 2 parameters .(. an integer variable.(b). a ptrto a funtion which returns void. the return type of the function is void.
Explanation:
Apply the clock-wise rule to find the result.
87. main(){
while (strcmp(“some”,”some\0”))
printf(“Strings are not equal\n”);
}
Answer:
No output
Explanation:
Ending the string constant with \0 explicitly makes no difference. So “some” and “some\0” are equivalent. So, strcmp returns 0 (false) hence breaking out of the while loop.
88. main(){
char str1[] = {‘s’,’o’,’m’,’e’};
char str2[] = {‘s’,’o’,’m’,’e’,’\0’};
while (strcmp(str1,str2))
printf(“Strings are not equal\n”);
}
Answer:
“Strings are not equal”
“Strings are not equal”
….
Explanation:
If a string constant is initialized explicitly with characters, ‘\0’ is not appended automatically to the string. Since str1 doesn’t have null termination, it treats whatever the values that are in the following positions as part of the string until it randomly reaches a ‘\0’. So str1 and str2 are not the same, hence the result.
89. main(){
int i = 3;
for (;i++=0;) printf(“%d”,i);
}
Answer:
Compiler Error: Lvalue required.
Explanation:
As we know that increment operators return rvalues and hence it cannot appear on the left hand side of an assignment operation.
90. void main(){
int *mptr, *cptr;
mptr = (int*)malloc(sizeof(int));
printf(“%d”,*mptr);
int *cptr = (int*)calloc(sizeof(int),1);
printf(“%d”,*cptr);
}
Answer:
garbage-value 0
Explanation:
The memory space allocated by malloc is uninitialized, whereas calloc returns the allocated memory space initialized to zeros.
91. void main(){
static int i;
while(i<=10)
(i>2)?i++:i--;
printf(“%d”, i);
}
Answer:
32767
Explanation:
Since i is static it is initialized to 0. Inside the while loop the conditional operator evaluates to false, executing i--. This continues till the integer value rotates to positive value (32767). The while condition becomes false and hence, comes out of the while loop, printing the i value.
92. main(){
int i=10,j=20;
j = i, j?(i,j)?i:j:j;
printf("%d %d",i,j);
}
Answer:
10 10
Explanation:
The Ternary operator ( ? : ) is equivalent for if-then-else statement. So the question can be written as:
if(i,j){
if(i,j)
j = i;
else
j = j;
}
else
j = j;
93.1. const char *a;
2. char* const a;
3. char const *a;
-Differentiate the above declarations.
Answer:
1. 'const' applies to char * rather than 'a' ( pointer to a constant char )
*a='F' : illegal
a="Hi" : legal
2. 'const' applies to 'a' rather than to the value of a (constant pointer to char )
*a='F' : legal
a="Hi" : illegal
3. Same as 1.
94. main(){
int i=5,j=10;
i=i&=j&&10;
printf("%d %d",i,j);
}
Answer:
1 10
Explanation:
The expression can be written as i=(i&=(j&&10)); The inner expression (j&&10) evaluates to 1 because j==10. i is 5. i = 5&1 is 1. Hence the result.
95. main(){
int i=4,j=7;
j = j || i++ && printf("YOU CAN");
printf("%d %d", i, j);
}
Answer:
4 1
Explanation:
The boolean expression needs to be evaluated only till the truth value of the expression is not known. j is not equal to zero itself means that the expression’s truth value is 1. Because it is followed by || and true || (anything) => true where (anything) will not be evaluated. So the remaining expression is not evaluated and so the value of i remains the same.
Similarly when && operator is involved in an expression, when any of the operands become false, the whole expression’s truth value becomes false and hence the remaining expression will not be evaluated.
false && (anything) => false where (anything) will not be evaluated.
96. main(){
register int a=2;
printf("Address of a = %d",&;
printf("Value of a = %d",;
}
Answer:
Compier Error: '&' on register variable
Rule to Remember:
& (address of ) operator cannot be applied on register variables.
97. main(){
float i=1.5;
switch(i){
case 1: printf("1");
case 2: printf("2");
default : printf("0");
}
}
Answer:
Compiler Error: switch expression not integral
Explanation:
Switch statements can be applied only to integral types.
98. main(){
extern i;
printf("%d\n",i);{
int i=20;
printf("%d\n",i);
}
}
Answer:
Linker Error : Unresolved external symbol i
Explanation:
The identifier i is available in the inner block and so using extern has no use in resolving it.
99. main(){
int a=2,*f1,*f2;
f1=f2=&a;
*f2+=*f2+=a+=2.5;
printf("\n%d %d %d",a,*f1,*f2);
}
Answer:
16 16 16
Explanation:
f1 and f2 both refer to the same memory location a. So changes through f1 and f2 ultimately affects only the value of a.
100. main(){
char *p="GOOD";
char a[ ]="GOOD";
printf("\n sizeof(p) = %d, sizeof(*p) = %d, strlen(p) = %d", sizeof(p), sizeof(*p), strlen(p));
printf("\n sizeof( = %d, strlen( = %d", sizeof(, strlen();
}
Answer:
sizeof(p) = 2, sizeof(*p) = 1, strlen(p) = 4
sizeof( = 5, strlen( = 4
Explanation:
sizeof(p) => sizeof(char*) => 2
sizeof(*p) => sizeof(char) => 1
Similarly,
sizeof( => size of the character array => 5
When sizeof operator is applied to an array it returns the sizeof the array and it is not the same as the sizeof the pointer variable. Here the sizeof( where a is the character array and the size of the array is 5 because the space necessary for the terminating NULL character should also be taken into account.
101. #define DIM( array, type) sizeof(array)/sizeof(type)
main(){
int arr[10];
printf(“The dimension of the array is %d”, DIM(arr, int));
}
Answer:
10
Explanation:
The size of integer array of 10 elements is 10 * sizeof(int). The macro expands to sizeof(arr)/sizeof(int) => 10 * sizeof(int) / sizeof(int) => 10.
102. int DIM(int array[]) {
return sizeof(array)/sizeof(int );
}
main(){
int arr[10];
printf(“The dimension of the array is %d”, DIM(arr));
}
Answer:
1
Explanation:
Arrays cannot be passed to functions as arguments and only the pointers can be passed. So the argument is equivalent to int * array (this is one of the very few places where [] and * usage are equivalent). The return statement becomes, sizeof(int *)/ sizeof(int) that happens to be equal in this case.
103. main(){
static int a[3][3]={1,2,3,4,5,6,7,8,9};
int i,j;
static *p[]={a,a+1,a+2};
for(i=0;i<3;i++){
for(j=0;j<3;j++)
printf("%d\t%d\t%d\t%d\n",*(*(p+i)+j),
*(*(j+p)+i),*(*(i+p)+j),*(*(p+j)+i));
}
}
Answer:
1 1 1 1
2 4 2 4
3 7 3 7
4 2 4 2
5 5 5 5
6 8 6 8
7 3 7 3
8 6 8 6
9 9 9 9
Explanation:
*(*(p+i)+j) is equivalent to p[i][j].
104. main(){
void swap();
int x=10,y=8;
swap(&x,&y);
printf("x=%d y=%d",x,y);
}
void swap(int *a, int *b){
*a ^= *b, *b ^= *a, *a ^= *b;
}
Answer:
x=10 y=8
Explanation:
Using ^ like this is a way to swap two variables without using a temporary variable and that too in a single statement.
Inside main(), void swap(); means that swap is a function that may take any number of arguments (not no arguments) and returns nothing. So this doesn’t issue a compiler error by the call swap(&x,&y); that has two arguments.
This convention is historically due to pre-ANSI style (referred to as Kernighan and Ritchie style) style of function declaration. In that style, the swap function will be defined as follows,
void swap()
int *a, int *b{
*a ^= *b, *b ^= *a, *a ^= *b;
}
where the arguments follow the (). So naturally the declaration for swap will look like, void swap() which means the swap can take any number of arguments.
105. main(){
int i = 257;
int *iPtr = &i;
printf("%d %d", *((char*)iPtr), *((char*)iPtr+1) );
}
Answer:
1 1
Explanation:
The integer value 257 is stored in the memory as, 00000001 00000001, so the individual bytes are taken by casting it to char * and get printed.
106. main(){
int i = 258;
int *iPtr = &i;
printf("%d %d", *((char*)iPtr), *((char*)iPtr+1) );
}
Answer:
2 1
Explanation:
The integer value 257 can be represented in binary as, 00000001 00000001. Remember that the INTEL machines are ‘small-endian’ machines. Small-endian means that the lower order bytes are stored in the higher memory addresses and the higher order bytes are stored in lower addresses. The integer value 258 is stored in memory as: 00000001 00000010.
107. main(){
int i=300;
char *ptr = &i;
*++ptr=2;
printf("%d",i);
}
Answer:
556
Explanation:
The integer value 300 in binary notation is: 00000001 00101100. It is stored in memory (small-endian) as: 00101100 00000001. Result of the expression *++ptr = 2 makes the memory representation as: 00101100 00000010. So the integer corresponding to it is 00000010 00101100 => 556.
108. main()
{
char * str = "hello";
char * ptr = str;
char least = 127;
while (*ptr++)
least = (*ptr<least ) ?*ptr :least;
printf("%d",least);
}
Answer:
0
Explanation:
After ‘ptr’ reaches the end of the string the value pointed by ‘str’ is ‘\0’. So the value of ‘str’ is less than that of ‘least’. So the value of ‘least’ finally is 0.
109.
Declare an array of N pointers to functions returning pointers to functions returning pointers to characters?
Answer:
(char*(*)( )) (*ptr[N])( );
110. main(){
struct student {
char name[30];
struct date dob;
}stud;
struct date{
int day,month,year;
};
scanf("%s%d%d%d", stud.rollno, &student.dob.day, &student.dob.month, &student.dob.year);
}
Answer:
Compiler Error: Undefined structure date
Explanation:
Inside the struct definition of ‘student’ the member of type struct date is given. The compiler doesn’t have the definition of date structure (forward reference is not allowed in C in this case) so it issues an error.
111. main(){
struct date;
struct student{
char name[30];
struct date dob;
}stud;
struct date{
int day,month,year;
};
scanf("%s%d%d%d", stud.rollno, &student.dob.day, &student.dob.month, &student.dob.year);
}
Answer:
Compiler Error: Undefined structure date
Explanation:
Only declaration of struct date is available inside the structure definition of ‘student’ but to have a variable of type struct date the definition of the structure is required.
112.
There were 10 records stored in “somefile.dat” but the following program printed 11 names. What went wrong?
void main(){
struct student{
char name[30], rollno[6];
}stud;
FILE *fp = fopen(“somefile.dat”,”r”);
while(!feof(fp)) {
fread(&stud, sizeof(stud), 1 , fp);
puts(stud.name);
}
}
Explanation:
fread reads 10 records and prints the names successfully. It will return EOF only when fread tries to read another record and fails reading EOF (and returning EOF). So it prints the last record again. After this only the condition feof(fp) becomes false, hence comes out of the while loop.
113. Is there any difference between the two declarations,
1. int foo(int *arr[]) and
2. int foo(int *arr[2])
Answer:
No
Explanation:
Functions can only pass pointers and not arrays. The numbers that are allowed inside the [] is just for more readability. So there is no difference between the two declarations.
114. What is the subtle error in the following code segment?
void fun(int n, int arr[]){
int *p=0;
int i=0;
while(i++<n)
p = &arr[i];
*p = 0;
}
Answer & Explanation:
If the body of the loop never executes p is assigned no address. So p remains NULL where *p =0 may result in problem (may rise to runtime error “NULL pointer assignment” and terminate the program).
115. What is wrong with the following code?
int *foo(){
int *s = malloc(sizeof(int)100);
assert(s != NULL);
return s;
}
Answer & Explanation:
assert macro should be used for debugging and finding out bugs. The check s != NULL is for error/exception handling and for that assert shouldn’t be used. A plain if and the corresponding remedy statement has to be given.
116. What is the hidden bug with the following statement?
assert(val++ != 0);
Answer & Explanation:
Assert macro is used for debugging and removed in release version. In assert, the experssion involves side-effects. So the behavior of the code becomes different in case of debug version and the release version thus leading to a subtle bug.
Rule to Remember:
Don’t use expressions that have side-effects in assert statements.
117. void main(){
int *i = 0x400; // i points to the address 400
*i = 0; // set the value of memory location pointed by i;
}
Answer:
Undefined behavior
Explanation:
The second statement results in undefined behavior because it points to some location whose value may not be available for modification. This type of pointer in which the non-availability of the implementation of the referenced location is known as 'incomplete type'.
118. #define assert(cond) if(!(cond)) \
(fprintf(stderr, "assertion failed: %s, file %s, line %d \n",#cond,\
__FILE__,__LINE__), abort())
void main(){
int i = 10;
if(i==0)
assert(i < 100);
else
printf("This statement becomes else for if in assert macro");
}
Answer:
No output
Explanation:
The else part in which the printf is there becomes the else for if in the assert macro. Hence nothing is printed. The solution is to use conditional operator instead of if statement
#define assert(cond) ((cond)?(0): (fprintf (stderr, "assertion failed: \ %s, file %s, line %d \n",#cond, __FILE__,__LINE__), abort()))
Note:
However this problem of “matching with nearest else” cannot be solved by the usual method of placing the if statement inside a block like this,
#define assert(cond) { \
if(!(cond)) \
(fprintf(stderr, "assertion failed: %s, file %s, line %d \n",#cond,\
__FILE__,__LINE__), abort()) \
}
119. Is the following code legal?
struct a {
int x;
struct a b;
}
Answer:
No
Explanation:
Is it not legal for a structure to contain a member that is of the same type as in this case. Because this will cause the structure declaration to be recursive without end.
120. Is the following code legal?
struct a {
int x;
struct a *b;
}
Answer:
Yes.
Explanation:
*b is a pointer to type struct a and so is legal. The compiler knows, the size of the pointer to a structure even before the size of the structure is determined(as you know the pointer to any type is of same size). This type of structures is known as ‘self-referencing’ structure.
121. Is the following code legal?
typedef struct a {
int x;
aType *b;
}aType;
Answer:
No
Explanation:
The typename aType is not known at the point of declaring the structure (forward references are not made for typedefs).
122. Is the following code legal?
typedef struct a aType;
struct a{
int x;
aType *b;
};
Answer:
Yes
Explanation:
The typename aType is known at the point of declaring the structure, because it is already typedefined.
123. Is the following code legal?
void main(){
typedef struct a aType;
aType someVariable;
struct a {
int x;
aType *b;
};
}
Answer:
No
Explanation:
When the declaration,typedef struct a aType; is encountered body of struct a is not known. This is known as ‘incomplete types’.
124. void main(){
printf(“sizeof (void *) = %d \n“, sizeof( void *));
printf(“sizeof (int *) = %d \n”, sizeof(int *));
printf(“sizeof (double *) = %d \n”, sizeof(double *));
printf(“sizeof(struct unknown *) = %d \n”, sizeof(struct unknown *));
}
Answer:
sizeof (void *) = 2
sizeof (int *) = 2
sizeof (double *) = 2
sizeof(struct unknown *) = 2
Explanation:
The pointer to any type is of same size.
125. char inputString[100] = {0};
To get string input from the keyboard which one of the following is better?
1) gets(inputString)
2) fgets(inputString, sizeof(inputString), fp)
Answer & Explanation:
The second one is better because gets(inputString) doesn't know the size of the string passed and so, if a very big input (here, more than 100 chars) the charactes will be written past the input string. When fgets is used with stdin performs the same operation as gets but is safe.
126. Which version do you prefer of the following two,
1) printf(“%s”,str); // or the more curt one
2) printf(str);
Answer & Explanation:
Prefer the first one. If the str contains any format characters like %d then it will result in a subtle bug.
127. void main(){
int i=10, j=2;
int *ip= &i, *jp = &j;
int k = *ip/*jp;
printf(“%d”,k);
}
Answer:
Compiler Error: “Unexpected end of file in comment started in line 5”.
Explanation:
The programmer intended to divide two integers, but by the “maximum munch” rule, the compiler treats the operator sequence / and * as /* which happens to be the starting of comment. To force what is intended by the programmer,
int k = *ip/ *jp;
// give space explicity separating / and *
//or
int k = *ip/(*jp);
// put braces to force the intention
will solve the problem.
128. void main(){
char ch;
for(ch=0;ch<=127;ch++)
printf(“%c %d \n“, ch, ch);
}
Answer:
Implementaion dependent
Explanation:
The char type may be signed or unsigned by default. If it is signed then ch++ is executed after ch reaches 127 and rotates back to -128. Thus ch is always smaller than 127.
129. Is this code legal?
int *ptr;
ptr = (int *) 0x400;Answer:
Yes
Explanation:
The pointer ptr will point at the integer in the memory location 0x400.
130. main(){
char a[4]="HELLO";
printf("%s",;
}
Answer:
Compiler error: Too many initializers
Explanation:
The array a is of size 4 but the string constant requires 6 bytes to get stored.
131. main(){
char a[4]="HELL";
printf("%s",;
}
Answer:
HELL%@!~@!@???@~~!
Explanation:
The character array has the memory just enough to hold the string “HELL” and doesnt have enough space to store the terminating null character. So it prints the HELL correctly and continues to print garbage values till it accidentally comes across a NULL character.
132. main(){
int a=10,*j;
void *k;
j=k=&a;
j++;
k++;
printf("\n %u %u ",j,k);
}
Answer:
Compiler error: Cannot increment a void pointer
Explanation:
Void pointers are generic pointers and they can be used only when the type is not known and as an intermediate address storage type. No pointer arithmetic can be done on it and you cannot apply indirection operator (*) on void pointers.
133. Printf can be implemented by using __________ list.
Answer:
Variable length argument lists
134. char *someFun(){
char *temp = “string constant";
return temp;
}
int main(){
puts(someFun());
}
Answer:
string constant
Explanation:
The program suffers no problem and gives the output correctly because the character constants are stored in code/data area and not allocated in stack, so this doesn’t lead to dangling pointers.
135. char *someFun1(){
char temp[ ] = “string";
return temp;
}
char *someFun2(){
char temp[ ] = {‘s’, ‘t’,’r’,’i’,’n’,’g’};
return temp;
}
int main(){
puts(someFun1());
puts(someFun2());
}
Answer:
Garbage values.
Explanation:
Both the functions suffer from the problem of dangling pointers. In someFun1() temp is a character array and so the space for it is allocated in heap and is initialized with character string “string”. This is created dynamically as the function is called, so is also deleted dynamically on exiting the function so the string data is not available in the calling function main() leading to print some garbage values. The function someFun2() also suffers from the same problem but the problem can be easily identified in this case.
136. Explain Internal linkage.
Internal linkage means that all declarations of the identifier within one source file refer to a single entity but declarations of the same identifier in other source files refer to different entities.
137. Can the formal parameter to a function be declared static?
No, because arguments are always passed on the stack to support recursion.
138. What is an lvalue?
Something that can appear on the left side of the "=" sign, it identifies a place where the result can be stored. For example, in the equation a=b+25, a is an lvalue.
In the equation b+25=a, b+25 cannot be used as an lvalue, because it does not identify a specific place. Hence the above assignment is illegal.
139. Every expression that is an lvalue, is also an rvalue. Is the reverse true?
No, lvalue denotes a place in the computer's memory. An rvalue denotes a value, so it can only be used on the right hand side of an assignment.
140. What happens if indirection is performed on a NULL pointer?
On some machines the indirection accesses the memory location zero. On other machines indirection on a NULL pointer cause a fault that terminate the program. Hence the result is implementation dependent.
141. Is the statement legal? d=10-*d.
Illegal because it specifies that an integer quantity (10-*d) be stored in a pointer variable
142. What does the below indicate?
int *func(void)
a. void indicates that there aren't any arguments.
b. there is one argument of type void.
Answer: a
143. What are data type modifiers?
To extend the data handling power, C adds 4 modifiers which may only be applied to char and int. They are namely signed, unsigned, long and short. Although long may also be applied to double.
144. Interpret the meaning of the following.
a. “ab”,”a+b”
b. “w+t”
Answer:
"ab","a+b"->open a binary file for appending
"w+t" ->create a text file for reading and writing.
145. What is NULL in the context of files?
In using files, if any error occurs, a NULL pointer is returned.
146. What is Register storage class?
It concerns itself with storing data in the registers of the microprocessor and not in memory. The value of the variable doesn't have to be loaded freshly from memory every time. It's important to realize that this a request to the compiler and not a directive. The compiler may not be able to do it. Since the registers are normally of 16 bits long, we can use the register storage class for ints and char's.
147. What is an assertion statement?
They are actually macros. They test statements you pass to them and if the statement is false, they halt the program and inform you that the assertion failed. It is defined in the header file <assert.h>.
148. Parse int *(*(*(*abc)())[6])();
abc is a pointer to a function returning a pointer to array of pointer to functions returning pointer to integer.
 | |||
 | |||
Section I – C++
Note: All the programs are tested under Turbo C++ 3.0/4.5 and Microsoft VC++ 6.0 compilers.
It is assumed that,
Ø Programs run under DOS/Windows environment,
Ø Proper and required header files are inlcuded,
Ø The underlying machine is an x86 based system,
The program output may depend on the information based on this assumptions.
1. What is the output of the following program?
void main(){
char str[] = "String continued"
" at the next line";
cout << str;
}
Answer:
String continued at the next line.
Explanation:
C++ concatenates these strings. When a new-line or white spaces separate two adjacent strings, they are concatenated to a single string. This operation is called as “stringization” operation. So str could have initialized by the single string “String continued at the next line.”.
2. void main(){
int a, *pa, &ra;
pa = &a;
ra = a;
cout <<"a="<<a <<"*pa="<<*pa <<"ra"<<ra ;
}
Answer :
Compiler Error: 'ra', reference must be initialized
Explanation :
Pointers are different from references. One of the main differences is that the pointers can be both initialized and assigned, whereas references can only be initialized. So this code issues an error.
3. ANSI C++ introduces new style of casts (const_cast, dynamic_cast, static_cast and reinterpret_cast). For the following C style cast which of the new cast syntax should be applied?
pDerived = (Cderived *) pBase;
Answer:
dynamic_cast.
Explanation:
dynamic_cast is used for traversing up and down in inheritance hierarchy. So it can be applied here to cast pointer type from the base class to derived class. The cast in the new syntax will look like this:
pDerived = dynamic_cast <Cderived*> (pBase);
4. const int size = 5;
void print(int *ptr){
cout<<ptr[0];
}
void print(int ptr[size]){
cout<<ptr[0];
}
void main(){
int a[size] = {1,2,3,4,5};
int *b = new int(size);
print(;
print(b);
}
Answer:
Compiler Error : function 'void print(int *)' already has a body
Explanation:
Arrays cannot be passed to functions, only pointers (for arrays, base addresses) can be passed. So the arguments int *ptr and int prt[size] have no difference as function arguments. In other words, both the functoins have the same signature and so cannot be overloaded.
5. In which of the following cases will the copy constructor of the class X be called?
A) X x1,Y Y!:
foo(&x1,&y2); //function foo already defined
B) X x1,x2, Y y1;
x2 = bar(x1,y1); // function bar already defined
C) X x1(0.2) ,x2;x2 =x1;
D) X x1; X x2 =x1;
Answer:
B, C and D
Explanation:
In the function call foo, the address of the x1 is passed. So there is no need for the copy constructor. But in the other cases there is an assignment of X, which calls for a copy constructor.
6. class Sample{
public:
int *ptr;
Sample(int i){
ptr = new int(i);
}
~Sample(){
delete ptr;
}
void PrintVal(){
cout << "The value is " << *ptr;
}
};
void SomeFunc(Sample x){
cout << "Say i am in someFunc " << endl;
}
int main(){
Sample s1= 10;
SomeFunc(s1);
s1.PrintVal();
}
Answer:
Say i am in someFunc.
Null pointer assignment(Run-time error)
Explanation:
As the object is passed by value to ‘SomeFunc’ the destructor of the object is called when the control returns from the function. So when PrintVal is called, it meets up with ptr that has been freed.The solution is to pass the Sample object by reference to SomeFunc:
void SomeFunc(Sample &x){
cout << "Say i am in someFunc " << endl;
}
because when we pass objects by refernece that object is not destroyed. while returning from the function.
7. What is the output of the following program?
void Sample(int x=6,int y,int z=34){
cout << "Say i am in sample with the values " <<x<<y<<z;
}
void main(){
int a,b,c;
cin >>a>>b>>c;
Sample(a,b,c);
}
Answer:
Compile Time error: Missing default parameter for parameter 2.
Explanation:
The program wouldn’t compile because, as far as default arguments are concerned, the right-most argument must be supplied with a default value before a default argument to a parameter to it’s left can be supplied.
3. class base{
public:
int bval;
base(){ bval=0;}
};
class deri:public base{
public:
int dval;
deri(){ dval=1;}
};
void SomeFunc(base *arr,int size){
for(int i=0; i<size; i++,arr++)
cout<<arr->bval;
cout<<endl;
}
int main(){
base BaseArr[5];
SomeFunc(BaseArr,5);
deri DeriArr[5];
SomeFunc(DeriArr,5);
}
Answer:
00000
01010
Explanation:
The function SomeFunc expects two arguments.The first one is a pointer to an array of base class objects and the second one is the sizeof the array.The first call of someFunc calls it with an array of base objects, so it works correctly and prints the bval of all the objects. When SomeFunc is called the second time the argument passed is a pointer to an array of derived class objects and not the array of base class objects. But that is what the function expects to be sent. So the derived class pointer is promoted to base class pointer and the address is sent to the function. SomeFunc() knows nothing about this and just treats the pointer as an array of base class objects. So when arr++ is met, the size of base class object is taken into consideration and is incremented by sizeof(int) bytes for bval (the deri class objects have bval and dval as members and so is of size >= sizeof(int)+sizeof(int) ).
9. class some{
public:
~some(){
cout<<"some's destructor"<<endl;
}
};
void main(){
some s;
s.~some();
}
Answer:
some's destructor
some's destructor
Explanation:
Destructors can be called explicitly (constructors can not be). Here 's.~some()' explicitly calls the destructor of 's'. When main() returns, destructor of s is called again, hence the result.
10. class base{
public:
void baseFun(){ cout<<"from base"<<endl;}
};
class deri:public base{
public:
void baseFun(){ cout<< "from derived"<<endl;}
};
void SomeFunc(base *baseObj){
baseObj->baseFun();
}
int main(){
base baseObject;
SomeFunc(&baseObject);
deri deriObject;
SomeFunc(&deriObject);
}
Answer:
from base
from base
Explanation:
As we have seen in the previous case, SomeFunc expects a pointer to a base class. Since a pointer to a derived class object is passed, it treats the argument only as a base class pointer and the corresponding base function is called.
11. class base{
public:
virtual void baseFun(){ cout<<"from base"<<endl;}
};
class deri:public base{
public:
void baseFun(){ cout<< "from derived"<<endl;}
};
void SomeFunc(base *baseObj){
baseObj->baseFun();
}
int main(){
base baseObject;
SomeFunc(&baseObject);
deri deriObject;
SomeFunc(&deriObject);
}
Answer:
from base
from derived
Explanation:
Remember that baseFunc is a virtual function. That means that it supports run-time polymorphism. So the function corresponding to the derived class object is called.
12. What is the output of the following code?
class base
{
public:
int n;
virtual void foo(){n=1;}
void print(){cout <<n<<endl;}
};
class derived: base
{
public:
void foo(){n=2;}
void print(){cout <<n<<endl;}
};
void main()
{
derived y;
base *bp =dynamic_cast<base *>(&y);
bp->foo();
bp->print();
}
Answer:
Undefined behavior : dynamic_cast used to convert to inaccessible or ambiguous base;
Explanation:
In this program private inheritance is used (by default the inheritance is private). There is no implicit conversion from the derived to base due to this. An explicit dynamic cast is used to overcome this. But at runtime environment may impose the restrictions on access to the code, resulting in an undefined behavior.
13. class fig2d{
int dim1, dim2;
public:
fig2d() { dim1=5; dim2=6;}
virtual void operator<<(ostream & rhs);
};
void fig2d::operator<<(ostream &rhs){
rhs <<this->dim1<<" "<<this->dim2<<" ";
}
class fig3d : public fig2d{
int dim3;
public:
fig3d() { dim3=7;}
virtual void operator<<(ostream &rhs);
};
void fig3d::operator<<(ostream &rhs){
fig2d::operator <<(rhs);
rhs<<this->dim3;
}
void main(){
fig2d obj1;
fig3d obj2;
obj1 << cout;
obj2 << cout;
}
Answer :
5 6
Explanation:
In this program, the << operator is overloaded with ostream as argument. This enables the 'cout' to be present at the right-hand-side. Normally, operator << is implemented as global function, but it doesn't mean that it is not possible to be overloaded as member function. Overloading << as virtual member function becomes handy when the class in which it is overloaded is inherited, and this becomes available to be overrided. This is as opposed to global friend functions, where friend's are not inherited.
14. class opOverload{
public:
bool operator==(opOverload temp);
};
bool opOverload::operator==(opOverload temp){
if(*this == temp ){
cout<<"The both are same objects\n";
return true;
}
cout<<"The both are different\n";
return false;
}
void main(){
opOverload a1, a2;
a1== a2;
}
Answer :
Runtime Error: Stack Overflow
Explanation :
Just like normal functions, operator functions can be called recursively. This program just illustrates that point, by calling the operator == function recursively, leading to an infinite loop.
15. class complex{
double re;
double im;
public:
complex() : re(1),im(0.5) {}
operator int(){}
};
int main(){
complex c1;
cout<< c1;
}
Answer :
Garbage value
Explanation:
The programmer wishes to print the complex object using output re-direction operator,which he has not defined for his class.But the compiler instead of giving an error sees the conversion function and converts the user defined object to standard object and prints some garbage value.
16. class complex{
double re;
double im;
public:
complex() : re(0),im(0) {}
complex(double n) { re=n,im=n;};
complex(int m,int n) { re=m,im=n;}
void print() { cout<<re; cout<<im;}
};
void main(){
complex c3;
double i=5;
c3 = i;
c3.print();
}
Answer:
5,5
Explanation:
There is no operator= function taking double as an argument is defined. So the compiler creates a ‘complex’ object using the single argument constructor that takes double as an argument. This temporary object is assigned to c3.
17. Consider the following piece of code.
String s(“hello!”);
String s2 = s1+ “how are You”;
Will this code compile for this class declaration:
class String {
public:
String(char *);
String & operator=(String &);
String operator+(String);
friend operator+(String,String);
};
Answer:
No, this code will not compile.
Explanation:
Because there is an ambiguity between the overloading of the + operator as a member function and friend function. Given the statement:
String s2 = s1+ “how are You”;
the compiler doesn’t know to which function should it resolve to and call.
18. What is the output of the following code?
class base {/*....*/};
class derived :public base{/*....*/};
void foo()
{ try
{
throw derived();
}
catch (base b)
{
cout<<"Received exception, but can't handle\n";
throw;
}
};
void main()
{
try
{
foo();
}
catch (derived d)
{
cout<<"In derived handler";
}
catch (base b)
{
cout << "In Base handler";
}
}
Answer:
Received exception, but can't handle
In derived handler
Explanation:
When the function foo is called, the exception object of type derived is thrown. Now the catch block for that ‘derived’ exception object is searched but it is found that there is a catch block for ‘base’ is available. Since exception objects of type ‘base’ can handle all such exceptions in its hierarchy, this exception is caught.
A plain ‘throw’ inside a catch indicates a re-throw of the exception caught. So the ‘derived’ exception object is again thrown and is caught by the catch block in main(). Although both the catch blocks are eligible to handle the exception, this time the derived which is defined first will catch the exception.
No comments:
Post a Comment