Thread: Confusing

Huh?

-Prelude

At it's very basic form it's sorta like this.

Code:

int num1, num2;

num1 = 5;

printf("Enter a number: ");
scanf("%d", &num2);

if((num2 > 1) && (num2 == num1))
    printf("You hit lotto");

else if((num2 > 1) && (num2 < num1))
    printf("you should have bought more tickets.");

else if((num2 > 10) || (num2 < 10) && (num2 != num1))
    printf("lotto made a fortune off of the losers."); 

else if(num2 != num1)
   printf("better luck next time.");

&& is a logical comparison of two or more events. If both or all are true then the expression is true or 1. If just one comparison in the expression is false, the entire expression is false. However, if are using or (the double pipe) and one expression is true, then the expression is true or 1. The not operator is just a way of testing for a condition that you don't want. Since you're purposely looking for a condition that is opposite of what you're after, it's quite useful.

Not a technical answer, but hope it helps.

The ! operator will simply change the boolean value to the opposite. So if a is true then !a will be false. The && operator is used for multiple tests in one expression, like so:

Code:

if ( a == 10 && b == 10 )
  printf ( "Something" );

The printf is only reached if both a and b are 10. If either is not 10 then this test will fail. If a is not 10 then b will not be tested because the expression is already false. The || operator is like the && operator except that if any of the parts is true the test returns true:

Code:

if ( a == 10 || b == 10 )
  printf ( "Something" );

If a is 10 then the printf will be reached, if b is 10 then the printf will be reached, if both are 10 then the printf will be reached. If neither are 10 then the test will fail.

-Prelude

Not exactly sure what you're asking, but I'll give it a go anyway...

A boolean value can be either true or false. As mentioned in the tutorial, a value of 0 is false, a positive non-zero number is considered true. The use of zero and a non-zero number to represent true and false is just implementation - a boolean value is really an 8-bit number. In C/C++, all you have to worry about is true or false - not the actual value. For example:

Code:

BOOL	MyBoolean;	// Create a boolean

MyBoolean = TRUE;	// Make MyBoolean true
MyBoolean = FALSE;	// Make MyBoolean false

'true' and 'false' are keywords. They let the compiler take care of whether or not MyBoolean is zero or non-zero. The not operator ! changes back and forth between true and false.

Code:

BOOL	MyBoolean;	// Create a boolean

MyBoolean = TRUE;	// Make MyBoolean true
MyBoolean = !MyBoolean;	// Make MyBoolean false (the opposite of true)
MyBoolean = !MyBoolean;	// Make MyBoolean true (the opposite of false)

EDIT: I start typing and the next thing I know there's been two more posts... But you can see from Ronin and Prelude's posts the typical use of boolean expressions in if...then statements.
EDIT: Fixed BOOL, TRUE, and FALSE - see Prelude's post below

bool, true, and false are not keywords in C, only in C++. C89 offers no such support but C99 declares all three as macros.

-Prelude

*sulks back to C++ Programming board*

Could we not do something like

Code:

typedef short BOOL;

#define TRUE 1
#define FALSE 0

int main(void)
{
     BOOL test;
     
     if(TRUE != FALSE)
     	test = TRUE;
     else
     	test = FALSE;
     
     printf("%d", test);
     

      return 0;
}

To fool C?

No matter what a value is, to the CPU it will _always_ be either POSITIVE, ZERO, or NEGATIVE. That gives you three categories.

Well, actually two, because the computer sees POSITIVE AND NEGATIVE as the same: both are NON-ZERO. The computer only knows of one number it can test against: ZERO. It has no other _guaranteed_ numbers to work with, so it performs _all_ of its tests against ZERO.

As such, whenever you use boolean logic on a computer, you are not dealing with positive, negative, and zero, you are only dealing with ZERO or NON-ZERO. You don't care about sign.

AND = is a filter for non-zero values
NOT = is a filter for zero values

1 AND 1 = 1
1 AND 0 = 1
0 AND 1 = 1
0 AND 0 = 0 <= both must be zero before test fails.

NOT or '!', is always used in the context of a test:

IF NOT <value> is a test-- is the value zero or not? If the value is zero, then the test passes. If the value is anything else (itself), the test fails, because this is a test for zero.