Note : All the programs are tested under Turbo C/C++
compilers.
All the programs
are tested on DOS environment, machine is an x86 system and compiled using
Turbo C/C++ compiler
The program
output may depend on the information based on this assumptions (for example
sizeof(int) == 2 may be assumed).
Predict the output or error(s)
for the following:
1. void main()
{
int const * p=5;
printf("%d",++(*p));
}
Answer:
Compiler
error: Cannot modify a constant value.
Explanation:
p
is a pointer to a "constant integer". But we tried to change the
value of the "constant integer".
2. void main()
{
char far *farther,*farthest;
printf("%d..%d",sizeof(farther),sizeof(farthest));
}
Answer:
4..2
Explanation:
the
second pointer is of char type and not a far pointer
3. void main()
{
char *p;
p="Hello";
printf("%c\n",*&*p);
}
Answer:
H
Explanation:
*
is a dereference operator & is a reference
operator. They can be applied
any number of times provided it is meaningful. Here p points to
the first character in the string "Hello". *p dereferences it
and so its value is H. Again & references
it to an address and * dereferences it to the value H.
4. void main()
{
static int
a[ ] = {0,1,2,3,4};
int *p[
] = {a,a+1,a+2,a+3,a+4};
int
**ptr = p;
ptr++;
printf(“\n %d
%d %d”, ptr-p, *ptr-a, **ptr);
*ptr++;
printf(“\n %d
%d %d”, ptr-p, *ptr-a, **ptr);
*++ptr;
printf(“\n %d %d
%d”, ptr-p, *ptr-a, **ptr);
++*ptr;
printf(“\n %d
%d %d”, ptr-p, *ptr-a, **ptr);
}
Answer:
111
222
333
344
Explanation:
Let us consider the
array and the two pointers with some address
a
|
0
|
1
|
2
|
3
|
4
|
100 102
104 106 108
p
|
100
|
102
|
104
|
106
|
108
|
1000
1002 1004 1006
1008
ptr
|
1000
|
2000
After execution of the instruction ptr++
value in ptr becomes 1002, if scaling factor for integer is 2 bytes. Now ptr –
p is value in ptr – starting location of array p, (1002 – 1000) / (scaling
factor) = 1, *ptr – a = value at address
pointed by ptr – starting value of array a, 1002 has a value 102 so the value is (102 – 100)/(scaling factor)
= 1, **ptr is the value stored in the
location pointed by the pointer of ptr =
value pointed by value pointed by 1002 = value pointed by 102 = 1. Hence the
output of the firs printf is 1, 1, 1.
After execution of *ptr++ increments value of
the value in ptr by scaling factor, so it becomes1004. Hence, the outputs for
the second printf are ptr – p = 2, *ptr – a = 2, **ptr = 2.
After execution of *++ptr increments value of
the value in ptr by scaling factor, so it becomes1004. Hence, the outputs for
the third printf are ptr – p = 3, *ptr – a = 3, **ptr = 3.
After execution of ++*ptr value in ptr
remains the same, the value pointed by the value is incremented by the scaling
factor. So the value in array p at location 1006 changes from 106 10 108,.
Hence, the outputs for the fourth printf are ptr – p = 1006 – 1000 = 3, *ptr –
a = 108 – 100 = 4, **ptr = 4.
5. void main()
{
char
*q;
int j;
for (j=0; j<3; j++) scanf(“%s” ,(q+j));
for (j=0; j<3; j++) printf(“%c” ,*(q+j));
for (j=0; j<3; j++) printf(“%s” ,(q+j));
}
Explanation:
Here we have
only one pointer to type char and since we take input in the same pointer thus
we keep writing over in the same location, each time shifting the pointer value
by 1. Suppose the inputs are MOUSE,
TRACK and VIRTUAL. Then for the first input suppose the pointer starts
at location 100 then the input one is stored as
M
|
O
|
U
|
S
|
E
|
\0
|
When the second
input is given the pointer is incremented as j value becomes 1, so the input is
filled in memory starting from 101.
M
|
T
|
R
|
A
|
C
|
K
|
\0
|
The
third input starts filling from the
location 102
M
|
T
|
V
|
I
|
R
|
T
|
U
|
A
|
L
|
\0
|
This is the final value stored .
The
first printf prints the values at the position q, q+1 and q+2 = M T V
The
second printf prints three strings starting from locations q, q+1, q+2
i.e MTVIRTUAL, TVIRTUAL and VIRTUAL.
6. void main()
{
void *vp;
char ch = ‘g’, *cp = “goofy”;
int j = 20;
vp = &ch;
printf(“%c”, *(char *)vp);
vp = &j;
printf(“%d”,*(int *)vp);
vp = cp;
printf(“%s”,(char *)vp + 3);
}
Answer:
g20fy
Explanation:
Since a void
pointer is used it can be type casted to any
other type pointer. vp = &ch
stores address of char ch and the next statement prints the value stored
in vp after type casting it to the proper data type pointer. the output is ‘g’.
Similarly the output from second printf
is ‘20’. The third printf statement type casts it to print the string from the
4th value hence the output is ‘fy’.
7. void main()
{
static char *s[ ] = {“black”, “white”, “yellow”, “violet”};
char **ptr[ ] = {s+3, s+2, s+1, s}, ***p;
p = ptr;
**++p;
printf(“%s”,*--*++p + 3);
}
Answer:
ck
Explanation:
In this problem we have an array of char
pointers pointing to start of 4 strings. Then we have ptr which is a pointer to
a pointer of type char and a variable p which is a pointer to a pointer to a
pointer of type char. p hold the initial value of ptr, i.e. p = s+3. The next
statement increment value in p by 1 , thus now value of p = s+2. In the printf statement the expression
is evaluated *++p causes gets value s+1 then the pre decrement is executed and
we get s+1 – 1 = s . the indirection operator now gets the value from the array
of s and adds 3 to the starting address. The string is printed starting from
this position. Thus, the output is ‘ck’.
8. void main()
{
int i,
n;
char *x = “girl”;
n = strlen(x);
*x = x[n];
for(i=0; i<n; ++i)
{
printf(“%s\n”,x);
x++;
}
}
Answer:
(blank
space)
irl
rl
l
Explanation:
Here a string (a pointer to char) is initialized
with a value “girl”. The strlen function
returns the length of the string, thus n has a value 4. The next statement
assigns value at the nth location (‘\0’) to the first location. Now the string
becomes “\0irl” . Now the printf statement prints the string after each
iteration it increments it starting position.
Loop starts from 0 to 4. The first time
x[0] = ‘\0’ hence it prints nothing and pointer value is incremented. The
second time it prints from x[1] i.e “irl” and the third time it prints “rl” and
the last time it prints “l” and the loop terminates.
9. void main()
{
char *cptr,c;
void *vptr,v;
c=10; v=0;
cptr=&c; vptr=&v;
printf("%c%v",c,v);
}
Answer:
Compiler
error (at line number 4): size of v is Unknown.
Explanation:
You
can create a variable of type void * but not of type void, since void is an
empty type. In the second line you are creating variable vptr of type void *
and v of type void hence an error.
10. void main()
{
char *str1="abcd";
char str2[]="abcd";
printf("%d %d
%d",sizeof(str1),sizeof(str2),sizeof("abcd"));
}
Answer:
2
5 5
Explanation:
In
first sizeof, str1 is a character pointer so it gives you the size of the
pointer variable. In second sizeof the name str2 indicates the name of the
array whose size is 5 (including the '\0' termination character). The third
sizeof is similar to the second one.
No comments:
Post a Comment