What is output of following program when we compile and run it?

void main()
{
int const * p=5;
printf("%d",++(*p));
}

1. nonportablepointer conversion
2. can not modify constant object[ANS]
3. 6
4. a & b


void main()
{
char ch;
for(ch=0;ch<=127;ch )
printf("%c %d \n", ch, ch);
}

1. 0
2. constant out of range[ANS]
3. irreducible expression
4. a & c

Void main()
{
char s[ ]="man";
int i;
for(i=0;s[ i ];i++)
printf("%c%c%c%c",s[ i ],*(s+i),*(i+s),i[s]);
}

1. man
2. null pointerassignment
3. mmm aaa nnn[ANS]
4. non of these

void main()
{
float me = 1.1;
double you = 1.1;
if(me==you)
printf("condition is true");
else
printf("condition is false");
}

1. condition is true
2. condition is false[ANS]
3. no output
4. misplaced else

Void main() {
struct emp {
char name[20];
int empno;
};
struct emp e1 = {"helloworld", 1311};
struct emp e2 = e1;
if (e1==e2)
printf ("e1 and e2 are same");
else
printf ("e1 and e2 are different");
}

1. illegal structure operation error[ANS]
2. e1 and e2 are same
3. e1 and e2 are different
4. nonofthese

Void main() {
printf ("VOLDEMORT");
}

1. he_who_must_not_be_named
2. VOLDMORT[ANS]
3. compile error
4. voldmort

Void main() {
unsigned int x = 0xffff;
~x;
printf ("%x", x);
}

1. ffff
2. no effect
3. 0xffff
4. a& b [ANS]

Void main()
{
int a = -3, b = 2, c= 0, d;
d = ++a && ++b || ++c;
printf ("a = %d, b = %d, c = %d, d = %d", a, b, c, d);
}

1. -4 3 0 0
2. -2 3 0 0
3. -2 3 0 1 [ANS]
4. -5 3 0 1

void main()
{
int a=10,b=20;
char x=1,y=0;
if(a,b,x,y)
{
printf("EXAM");
}
}

1. XAM is printed
2. exam is printed
3. Compiler Error
4. Nothing is printed[ANS]

1. Address of the array
2. Values of the first elements of the array
3. Address of the first element of the array[ANS]
4. Number of element of the array

Void main()
{
char thought[2][30]={"Don`t walk in front of me..","I am not follow"};
printf("%c%c",*(thought[0]+9),*(*(thought+0)+5));
}

1. k k
2. Don`t walk in front of me
3. I may not follow
4. K[ANS]


#include
void main()
{
int I=3,*j,**k;
j=&I;
k=&j;
printf("%d%d%d",*j,**k,*(*k));
}

1. 444
2. 000
3. 333[ANS]
4. 433

Void main()
{
struct
{
int i;
}xyz;
(*xyz)->i=10;
printf("%d",xyz.i);
}

1. program will not compile[ANS]
2. 10
3. god only knows
4. address of I

1. 5
2. 6
3. 10 [Ans] Corrected by buddy by running the program
4. 11
5. 12

1. unalloc()
2. dropmem()
3. dealloc()
4. release()
5. free() [Ans]

1. ptr = ptr + sizeof(myStruct); [Ans]
2. ++(int*)ptr;
3. ptr = ptr + sizeof(myArray);
4. increment(ptr);
5. ptr = ptr + sizeof(ptr);

char* myFunc (char *ptr){
ptr += 3;
return (ptr);
}
void main()
{
char *x, *y;
x = "HELLO";
y = myFunc (x);
printf ("y = %s \n", y);
return 0;
}

1. y = HELLO
2. y = ELLO
3. y = LLO
4. y = LO [Ans]
5. x = O

struct node *nPtr, *sPtr; pointers for a linked list.
for (nPtr=sPtr; nPtr; nPtr=nPtr->next)
{
free(nPtr);
}

1. It will work correctly since the for loop covers the entire list.
2. It may fail since each node “nPtr” is freed before its next address can be accessed.
3. In the for loop, the assignment “nPtr=nPtr->next” should be changed to “nPtr=nPtr.next”.
4. This is invalid syntax for freeing memory.
5. The loop will never end.

1. fileread()
2. getline()
3. readfile()
4. fread()
5. gets()

1. printf(”\”My salary was increased by 15/%\!\”\n”);
2. printf(”My salary was increased by 15%!\n”);
3. printf(”My salary was increased by 15′%’!\n”);
4. printf(”\”My salary was increased by 15%%!\”\n”);[Ans]
5. printf(”\”My salary was increased by 15′%’!\”\n”);

1. Both can occur multiple times, but a declaration must occur first.
2. There is no difference between them.
3. A definition occurs once, but a declaration may occur many times.
4. A declaration occurs once, but a definition may occur many times. [Ans]
5. Both can occur multiple times, but a definition must occur first.

1. 3
2. 5
3. 7
4. 9
5. 11[Ans]

1. 12,10,11,13
2. 22,10,11,13
3. 22,11,11,11
4. 12,11,11,11
5. 22,13,13,13[Ans]

int x[] = { 1, 4, 8, 5, 1, 4 };
int *ptr, y;
ptr = x + 4;
y = ptr - x;

1. -3
2. 0
3. 4[Ans]
4. 4 + sizeof( int )
5. 4 * sizeof( int

void myFunc (int x)
{
if (x > 0)
myFunc(--x);
printf("%d, ", x);
}
int main()
{
myFunc(5);
return 0;
}

1. 1, 2, 3, 4, 5, 5,
2. 4, 3, 2, 1, 0, 0,
3. 5, 4, 3, 2, 1, 0,
4. 0, 0, 1, 2, 3, 4, [Ans]
5. 0, 1, 2, 3, 4, 5,

1. 1
2. 6
3. 8
4. 14 [Ans]
5. 15

1. MAX_NUM is an integer variable.
2. MAX_NUM is a linker constant.
3. MAX_NUM is a precompiler constant.
4. MAX_NUM is a preprocessor macro. [Ans]
5. MAX_NUM is an integer constant.

1. setbuf( stdout, FALSE );
2. setvbuf( stdout, NULL );
3. setbuf( stdout, NULL );
4. setvbuf( stdout, _IONBF );
5. setbuf( stdout, _IONBF );

1. FILE *f = fwrite( “test.bin”, “b” );
2. FILE *f = fopenb( “test.bin”, “w” );
3. FILE *f = fopen( “test.bin”, “wb” );
4. FILE *f = fwriteb( “test.bin” );
5. FILE *f = fopen( “test.bin”, “bw” );

1. memcpy()
2. memset()
3. strncpy()
4. strcpy()
5. memmove()[Ans]

1. 22
2. 26[Ans]
3. 46
4. 50
5. 70

void * array_dup (a, number, size)
const void * a;
size_t number;
size_t size;
{
void * clone;
size_t bytes;
assert(a != NULL);
bytes = number * size;
clone = alloca(bytes);
if (!clone)
return clone;
memcpy(clone, a, bytes);
return clone;
}

1. If the arguments to memcpy() refer to overlapping regions, the destination buffer will be subject to memory corruption.
2. array_dup() declares its first parameter to be a pointer, when the actual argument will be an array.
3. The memory obtained from alloca() is not valid in the context of the caller. Moreover, alloca() is nonstandard.
4. size_t is not a Standard C defined type, and may not be known to the compiler.
5. The definition of array_dup() is unusual. Functions cannot be defined using this syntax.

1. Yes; it can be referenced through the register specifier.
2. No; it would have to have been initially declared as a static variable.
3. No; it would need to have been initially declared using the global keyword.[Ans]
4. Yes; it can be referenced through the publish specifier.
5. Yes; it can be referenced through the extern specifier.

1. t = clock();[Ans]
2. time( &t );
3. t = ctime();
4. t = localtime();
5. None of the above

1. The system stack[Ans]
2. The data segment
3. The processor’s registers
4. The text segment
5. The heap

1. Machine
2. Procedural[Ans]
3. Assembly
4. Object-oriented
5. Strictly-typed

int i,j;
int ctr = 0;
int myArray[2][3];
for (i=0; i<3; i++)
for (j=0; j<2; j++)
{
myArray[j][i] = ctr;
++ctr;
}

1. 1
2. 2
3. 3
4. 4
5. 5 [Ans] 00,10,01,11,12

int x = 0;
for (x=1; x<4; x++);
printf("x=%d\n", x);

1. x=0
2. x=1
3. x=3
4. x=4[Ans]
5. x=5

int x = 3;
if( x == 2 );
x = 0;
if( x == 3 )
x++;
else x += 2;

1. 1
2. 2[Ans]
3. 3
4. 4
5. 5

char *ptr;
char myString[] = "abcdefg";
ptr = myString;
ptr += 5;

1. fg [Ans]because string
2. efg
3. defg
4. cdefg
5. None of the above