Can anyone explain why '>>2' shift means 'divided by 4' in C codes?

I think you are confused by the "2" in:

7 >> 2

and are thinking it should divide by 2.

The "2" here means shift the number ("7" in this case) "2" bit positions to the right.

Shifting a number "1"bit position to the right will have the effect of dividing by 2:

8 >> 1 = 4    // In binary: (00001000) >> 1 = (00000100)

and shifting a number "2"bit positions to the right will have the effect of dividing by 4:

8 >> 2 = 2    // In binary: (00001000) >> 2 = (00000010)

Elaborating on Aniket Inge's answer:

Number: 307₁₀ = 100110011₂

How multiply by 10 works in decimal system

10 * (307₁₀)

= 10 * (3*10² + 7*10⁰)

= 3*10²⁺¹ + 7*10⁰⁺¹

= 3*10³ + 7*10¹

= 3070₁₀

= 307₁₀ << 1

Similarly multiply by 2 in binary,

2 * (100110011₂)

= 2 * (1*2⁸ + 1*2⁵ + 1*2⁴ + 1*2¹ 1*2⁰)

= 1*2⁸⁺¹ + 1*2⁵⁺¹ + 1*2⁴⁺¹ + 1*2¹⁺¹ 1*2⁰⁺¹

= 1*2⁹ + 1*2⁶ + 1*2⁵ + 1*2² + 1*2¹

= 1001100110₂

= 100110011₂ << 1

It didn't "pop-up" in a genius' head. Right shifting binary numbers would divide a number by 2 and left shifting the numbers would multiply it by 2. This is because 10 is 2 in binary. Multiplying a number by 10(be it binary or decimal or hexadecimal) appends a 0 to the number(which is effectively left shifting). Similarly, dividing by 10(or 2) removes a binary digit from the number(effectively right shifting). This is how the logic really works.

There are plenty of such bit-twiddlery(a word I invented a minute ago) in computer world.

http://graphics.stanford.edu/~seander/bithacks.html Here is for the starters.

This is my favorite book: http://www.amazon.com/Hackers-Delight-Edition-Henry-Warren/dp/0321842685/ref=dp_ob_image_bk on bit-twiddlery.

It is actually defined that way in the C standard.

From section 6.5.7:

The result of E1 >> E2 is E1 right-shifted E2 bit positions. [...] the value of the result is the integral part of the quotient of E1 / 2^E2

On most architectures, x >> 2 is only equal to x / 4 for non-negative numbers. For negative numbers, it usually rounds the opposite direction.

Compilers have always been able to optimize x / 4 into x >> 2. This technique is called "strength reduction", and even the oldest compilers can do this. So there is no benefit to writing x / 4 as x >> 2.