John Smith said:
Hi Matt.
I am writting an OCX control, and a vb app for a computer telephony
application. I need to map the hardware return values which are defined in
the c++ header file, to constants in my VB app. I managed to cover most of
them but this one got me puzzled.
Here are a few lines from my .H file:
#define DE_RINGS 1 /* Rings received */
#define DE_SILON 2 /* Silence on */
#define DE_SILOF 3 /* Silenec off */
.
.
.
#define DM_RINGS ( 1 << (DE_RINGS - 1) )
#define DM_SILON ( 1 << (DE_SILON - 1) )
#define DM_SILOF ( 1 << (DE_SILOF - 1) )
In this ( << ) shift operation I do not see how it could rais any number by
any power. However, I setup some logging and this is what I got:
DE_SILOF=3, DM_SILOF=4
DE_LCOF=5, DM_LCOF=16
DE_WINK=6, DM_WINK=32
DE_DIGOFF=9, DM_DIGOFF=256
You are right it is raising 2 by the power of DE_XXXX values, but I just
don't see how.
Ok, I guess I'll explain how to compute binary to you.
When numbers are represented in a computer, they are stored in binary
(zeroes and ones, you've prob heard this in some intro to computers
course/book/site or something). Binary is only different from decimal in
the base that it represents numbers. Decimal is base-10, binary is base-2
(bi = 2). Each "digit" (bit to be exact) in binary represents a power of 2.
Just like each digit in decimal represents a power of 10. For example:
decimal = 32 = (3 * 10^1) + (2 * 10^0)
binary = 100000 = (1 * 2^5) + (0 * 2^4) + (0 * 2^3) + (0 * 2^2) + (0 * 2^1)
+ (0 * 2^0)
Both are equivalent to 32 in decimal.
Soooo, in binary, starting from the rightmost bit, each bit represents a
certain power of the base (starting w/ 0 which anything to the 0 power is
1). With binary this might be more help:
2^5 2^4 2^3 2^2 2^1 2^0
1 0 0 0 0 0
This is why 100000 is 32.
Now to apply this to your bitshift ( << ), what this operator does is take
whatever number is on the left side and shifts all the bits in that number
the number of places denoted by the number on the right side (filling in
empty spaces to the right with 0's). Example:
#define DE_RINGS 1
#define DE_SILON 2
#define DE_SILOF 3
this is the way that the values are represented in the computer
DE_RINGS = 1 = (1 * 2^0) = 1 in decimal
DE_SILON = 10 = (1 * 2^1) + (0 * 2^0) = 2
DE_SILOF = 11 = (1 * 2^1) + (1 * 2^0) = 3
So if you say
(1 << (DE_SILOF - 1))
(DE_SILOF - 1) == (3 - 1) == 2
(1 << 2) == 1 << 2 == take the binary representation of 1 and shift all the
bits two places to the left and fill in new places w/ 0's.
ie: 0001 (leading 0's just so that we know it's binary)
becomes 0100 or
(0 * 2^3) + (1 * 2^2) + (0 * 2^1) + (0 * 2^0)
that's why things are "raising 2 by the power of DE_XXXX values", because
the shift operation is just moving a 1 to a certain power of 2 in binary.
Hope that further clarifies all of our answers.
If you still have questions, you can do a google search for more detailed
info on these topics
I really appreciate your time.
Your Welcome,
Matt
