Am I an idiot?

[Kevin Grigorenko]

That's a rethorical question. But shouldn't this statement store the value
of three in the variable a:

#include <iostream>

int main()
{
int a = 1 & 2;
if(a & 1)
{
std::cout << "One " << std::endl;
}
if(a & 2)
{
std::cout << "Two " << std::endl;
}
return 0;
}

I'm trying to use bit-masking to pass around flags with an integer, and then
check them with if( integer & flagX )

What is going on?

Thanks a lot for your time,
Kevin Grigorenko

[Karl Heinz Buchegger]

Kevin Grigorenko wrote:

That's a rethorical question. But shouldn't this statement store the value
of three in the variable a:
No. It should store the value 0.

#include <iostream>

int main()
{
int a = 1 & 2;

You want

int a = 1 | 2;
Use | to set bits, use & to clear bits or to check if
a bit is set.
--
Karl Heinz Buchegger
kb******@gascad .at

[Rob Williscroft]

Kevin Grigorenko wrote in news:br******** **@f04n12.cac.p su.edu:

That's a rethorical question. But shouldn't this statement store the
value of three in the variable a:

#include <iostream>

int main()
{
int a = 1 & 2;
int a = 1 | 2;
if(a & 1)
{
std::cout << "One " << std::endl;
}
if(a & 2)
{
std::cout << "Two " << std::endl;
}
return 0;
}

I'm trying to use bit-masking to pass around flags with an integer,
and then check them with if( integer & flagX )

What is going on?

& (aka bitwise and aka bitand) both things must be true (or set in a
bitwise sense).

| (aka bitwise or aka bitor ) one (or both) must be true (or ...)

HTH.

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Kevin Grigorenko]

"Karl Heinz Buchegger" <kb******@gasca d.at> wrote in message
news:3F******** *******@gascad. at...

Kevin Grigorenko wrote:

That's a rethorical question. But shouldn't this statement store the value of three in the variable a:
No. It should store the value 0.

#include <iostream>

int main()
{
int a = 1 & 2;

You want

int a = 1 | 2;

Ahhh, so I am an idiot. I knew that. Haha, wow, what is wrong with me
today.


Use | to set bits, use & to clear bits or to check if
a bit is set.
--
Karl Heinz Buchegger
kb******@gascad .at

Appreciate it,
Kevin Grigorenko

[E. Robert Tisdale]

Kevin Grigorenko wrote:

Shouldn't this statement store the value
of three in the variable a:

#include <iostream>

int main()
{
int a = 1 & 2;
You probably meant to write

int a = 1 | 2;
if(a & 1)
{
std::cout << "One " << std::endl;
}
if(a & 2)
{
std::cout << "Two " << std::endl;
}
return 0;
}

I'm trying to use bit-masking to pass around flags with an integer
and then check them with if( integer & flagX )

What is going on?

Nothing. You're just an idiot. ;-)

[Kevin Grigorenko]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote in message
news:3F******** ******@jpl.nasa .gov...

Kevin Grigorenko wrote:

Shouldn't this statement store the value
of three in the variable a:

#include <iostream>

int main()
{
int a = 1 & 2;

You probably meant to write

int a = 1 | 2;

if(a & 1)
{
std::cout << "One " << std::endl;
}
if(a & 2)
{
std::cout << "Two " << std::endl;
}
return 0;
}

I'm trying to use bit-masking to pass around flags with an integer
and then check them with if( integer & flagX )

What is going on?

Nothing. You're just an idiot. ;-)

I agree :). Thanks for the quick help to all who responded. It is now
confirmed that I am an idiot.

Kevin Grigorenko

[jeffc]

"Kevin Grigorenko" <kz****@psu.edu > wrote in message
news:br******** **@f04n12.cac.p su.edu...

I'm trying to use bit-masking to pass around flags with an integer, and then check them with if( integer & flagX )

But the bits for 1 are 01, and for 2 are 10. When you AND them together,
there aren't any ones. Did you mean OR?

[David Fisher]

"jeffc" <no****@nowhere .com> wrote:

But the bits for 1 are 01, and for 2 are 10. When you AND them together,
there aren't any ones. Did you mean OR?

The bit patterns for 1 and 2 are not absolutely guaranteed to be "000...01"
and "000...10" - the "two's complement" format represents them this way,
but theoretically they could be anything they like (I'm not sure if any
computers actually represent them a different way, but I've heard of "one's
complement" where negative numbers are stored differently).

0x1 and 0x2 ought to be pretty safe, though ...

David F

PS. Pretty sure about this, but correct me if I'm wrong - it's kind of
unintuitive for the expression (0x0F == 15) to not always be true, since 0F
_is_ 15 in hexadecimal ...

[Ron Natalie]

"David Fisher" <no****@nospam. nospam.nospam> wrote in message
news:do******** **********@nasa l.pacific.net.a u...

"jeffc" <no****@nowhere .com> wrote:

But the bits for 1 are 01, and for 2 are 10. When you AND them together, there aren't any ones. Did you mean OR?
The bit patterns for 1 and 2 are not absolutely guaranteed to be

"000...01" and "000...10" - the "two's complement" format represents them this way,

..
Actually, it has nothing to do with two's complement. The C standard
REQUIRES
the positive numbers to be simply straight forward binary. The rules (for
C++ and
C89) say that unsigned values are pretty much straight forward binary and
that the
positive signed variables have the same representation as their unsigned
counterparts.
The C99 standard goes even further and says that there is only three legal
integer
encodings: 2's complement, 1's complement, and signed-magnitude. All of
which
obey the earlier constraint.

-> 0x1 and 0x2 ought to be pretty safe, though ...

This is a pretty bizarre statement give your earlier statement. 1 and 0x1
are
exactly the same value as var as the language is concerned (the hex
specified
numbers only differ in that they will have type unsigned int if int can't
represent them).

[Andrey Tarasevich]

David Fisher wrote:

...

But the bits for 1 are 01, and for 2 are 10. When you AND them together,
there aren't any ones. Did you mean OR?

The bit patterns for 1 and 2 are not absolutely guaranteed to be "000...01"
and "000...10" - the "two's complement" format represents them this way,
but theoretically they could be anything they like (I'm not sure if any
computers actually represent them a different way, but I've heard of "one's
complement" where negative numbers are stored differently).
...

Positive integral values are represented in the same way in all binary
formats supported by C/C++ specifications. In other words, 1 is
guaranteed to be '0..001' and 2 is guaranteed to be '0..010'.

Note, that "bits" that are mentioned in the language specification are
language-level abstractions. The actual underlying hardware might even
be non-binary (ternary, for example) and have nothing that can be
regarded as physical "bits".

--
Best regards,
Andrey Tarasevich