What does 'Conditional expressions can be only boolean, not integral.' mean? I do not know Java and I know C++ deffenetly not enought to understend what it means.. Please help (found in http://www.javacoffeebreak.com/articles/thinkinginjava/comparingc++andjava.html in Comparing C++ and Java item 7 sub item 1)
views:
206answers:
9In C++, you can say if (someInt)
which is basically equivalent to if (someInt != 0)
. In Java, only the second form is legal.
It means you need a boolean for a conditional, a conversion from an integral type won't be implicit. Instead of if (x)
you'd need if (x != 0)
, etc.
The former is an int
which will be implicitly converted to bool
in C++ (via != 0
), but the latter expression yields a boolean directly.
Integral expression:
int i = 5;
if(i) {
//...
}
//In C/C++, if(i) gets implicitly converted to if(i != 0), Java doesn't do this for you.
Boolean expression
int i = 5;
if(i==5) {
//...
}
//This will work in Java
In C/C++ you can do
int i = 5;
if( i ) { ...}
In Java you cannot as i has to be a boolean
It means that, in Java, the boolean value "true" is not interchangeable with the integer value "1" (or, more accurately, with any non-zero integer), and the boolean value "false" is not interchangeable with the integer value "0".
Take the statement:
if (a > b) {
// Do stuff
}
The "conditional expression" is a > b
. In C++ you can do things like
int i = foo();
if (i) {
// do stuff
}
This is because integral (integer values) are treated as false when 0 and true otherwise. Languages like Java do not allow you to treat integers as boolean values in this way.
An expression is code that computes a value. In both languages an expression has a static type that described the kind of values this expression yields. Integral means the the expression's type is int.
Simply put, the authors emphasize each of the following is legal C++ code, but not legal Java code, because the if
's expression yields an integer:
if (32) {
}
if (2 * 17 - 33) {
}
int c;
if (c = 12) {
}
To put it another way: C/C++ don't have a real boolean type, they just use integers. Java does have them - and furthermore, it's got more strict typing than C/C++.
Conditional expressions are used by the conditional and loop control structures to determine the control flow of a program.
// conditional control structure
if (conditionalExpression) {
codeThatRunsIfConditionalExpressionIsTrue();
} else {
codeThatRunsIfConditionalExpressionIsFalse();
}
// basic loop control structure
while (conditionalExpression) {
codeThatRunsUntilConditionalExpressionIsFalse();
}
// run-at-least-once loop control structure
do {
codeThatRunsAtLeastOnceUntilConditionalExpressionIsFalse();
} while (conditionalExpression);
From a logical point of view, conditional expressions are inherently boolean (true or false). However, some languages like C and C++ allow you to use numerical expressions or even pointers as conditional expressions. When a non-boolean expression is used as a conditional expression, they are implicitly converted into comparisions with zero. For example, you could write:
if (numericalExpression) {
// ...
}
And it would mean this:
if (numericalExpression != 0) {
// ...
}
This allows for concise code, especially in pointer languages like C and C++, where testing for null pointers is quite common. However, making your code concise doesn't necessarily make it clearer. In high-level languages like C# or Java, using numerical expressions as conditional expressions is not allowed. If you want to test whether a reference to an object has been initialized, you must write:
if (myObject != null) /* (myObject) alone not allowed */ {
// ...
}
Likewise, if you want to test whether a numeric expression is zero, you must write:
if (numericalExpression != 0) /* (numericalExpression) alone not allowed */ {
// ...
}