Skip to Content, PHP, MySQL, Javascript, Ajax, Htacces

C Language Pointer Interview Questions and Answers For Freshers Part-4

Be First!

c-program-pointers7. Can you subtract pointers from each other? Why would you?

If you have two pointers into the same array, you can subtract them. The answer is the number of elements between the two elements.

Consider the street address analogy presented in the introduction of this chapter. Say that I live at 118 Fifth Avenue and that my neighbor lives at 124 Fifth Avenue. The “size of a house” is two (on my side of the street, sequential even numbers are used), so my neighbor is (124-118)/2 (or 3) houses up from me. (There are two houses between us, 120 and 122; my neighbor is the third.) You might do this subtraction if you’re going back and forth between indices and pointers.

You might also do it if you’re doing a binary search. If p points to an element that’s before what you’re looking for, and q points to an element that’s after it, then (q-p)/2+p points to an element between p and q. If that element is before what you want, look between it and q. If it’s after what you want, look between p and it.

(If it’s what you’re looking for, stop looking.)

C won’t stop you from subtracting pointers inappropriately. It won’t cut you any slack, though, if you use the meaningless answer in a way that might get you into trouble.

When you subtract pointers, you get a value of some integer type. The ANSI C standard defines a typedef,ptrdiff_t, for this type. (It’s in <stddef.h>.) Different compilers might use different types (int or long or whatever), but they all define ptrdiff_t appropriately.

#include <stdio.h>

#include <stddef.h>

struct stuff {

char    name[16];

/* other stuff could go here, too */


struct stuff array[] = {

{ “The” },

{ “quick” },

{ “brown” },

{ “fox” },

{ “jumped” },

{ “over” },

{ “the” },

{ “lazy” },

{ “dog.” },

{ “” }


int main()


struct stuff    *p0 = & array[0];

struct stuff    *p8 = & array[8];

ptrdiff_t       diff = p8 – p0;

ptrdiff_t       addr_diff = (char*) p8 – (char*) p0;

/* cast the struct stuff pointers to void* */

printf(“& array[0] = p0 = %P\n”, (void*) p0);

printf(“& array[8] = p8 = %P\n”, (void*) p8);

/* cast the ptrdiff_t’s to long’s

(which we know printf() can handle) */

printf(“The difference of pointers is %ld\n”,

(long) diff);

printf(“The difference of addresses is %ld\n”,

(long) addr_diff);

printf(“p8 – 8 = %P\n”, (void*) (p8 – 8));

printf(“p0 + 8 = %P (same as p8)\n”, (void*) (p0 + 8));

return 0;


8. Is NULL always defined as 0(zero)?

NULL is defined as either 0 or (void*)0. These values are almost identical; either a literal zero or a voidpointer is converted automatically to any kind of pointer, as necessary, whenever a pointer is needed (although the compiler can’t always tell when a pointer is needed).



Leave a Reply