Recommended style

[Kelvin Moss]

Hi all,

Which is the recommended style in production code for the following -

....
fp = fopen("xyz.txt" , "r");
if (fp == NULL) {
....
}

OR
fp = fopen("xyz.txt" , "r");
if (!fp) {
....
}

Thanks.

[Mike Wahler]

"Bonj" <[e-mail]> wrote in message news:33******** *****@individua l.net...

Neither:
fp = fopen("xyz.txt" , "r");
if (fp == NULL) {
...
}
is nearly right, but that's java style. Since your question is titled
'Recommended style', the correct style is
fp = fopen("xyz.txt" , "r");
if (fp == NULL)
{
...
}

is correct, but if ... is only one line, then I prefer just
fp = fopen("xyz.txt" , "r")
if(fp == NULL)
...

or better still
if(fopen("xyz.t xt", "r") == NULL) ...
And now how will you refer to the stream?



They both will work, but if(!fp) is less explicit,
IMO it's quite explicit. A test for true/false (zero/nonzero).
as it's not actually a
boolean value you're testing, it's a returned handle, and you're testing
whether it's NULL or not.

You're testing whether 'fp', after being converted to 'int',
is zero or not.

-Mike

[Keith Thompson]

"Mike Wahler" <mk******@mkwah ler.net> writes:

"Bonj" <[e-mail]> wrote in message news:33******** *****@individua l.net...

[...]

or better still
if(fopen("xyz.t xt", "r") == NULL) ...

And now how will you refer to the stream?

They both will work, but if(!fp) is less explicit,

IMO it's quite explicit. A test for true/false (zero/nonzero).

as it's not actually a
boolean value you're testing, it's a returned handle, and you're testing
whether it's NULL or not.

You're testing whether 'fp', after being converted to 'int',
is zero or not.

There's no conversion to int. The unary '!' operator tests whether
its operand compares equal to 0. For a pointer, comparison to 0 is
comparison to a null pointer constant.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Mike Wahler]

"Keith Thompson" <ks***@mib.or g> wrote in message
news:ln******** ****@nuthaus.mi b.org...

"Mike Wahler" <mk******@mkwah ler.net> writes:

"Bonj" <[e-mail]> wrote in message news:33******** *****@individua l.net...

[...]

or better still
if(fopen("xyz.t xt", "r") == NULL) ...

And now how will you refer to the stream?

They both will work, but if(!fp) is less explicit,

IMO it's quite explicit. A test for true/false (zero/nonzero).

as it's not actually a
boolean value you're testing, it's a returned handle, and you're testing whether it's NULL or not.

You're testing whether 'fp', after being converted to 'int',
is zero or not.

There's no conversion to int. The unary '!' operator tests whether
its operand compares equal to 0. For a pointer, comparison to 0 is
comparison to a null pointer constant.

But what is the type of the expression !fp?

I was thinking in the wider context of 'if's (full)
conditional expression itself, and not the not :-) operator. If
it's not already type 'int', is there a conversion or not?

e.g.

FILE *f = 0;

if(f) /* does this compare a 'FILE*' or 'int' object with zero? */
;

-Mike

[Herbert Rosenau]

On Sat, 1 Jan 2005 22:51:05 UTC, "Mike Wahler" <mk******@mkwah ler.net>
wrote:

"Keith Thompson" <ks***@mib.or g> wrote in message
news:ln******** ****@nuthaus.mi b.org...

"Mike Wahler" <mk******@mkwah ler.net> writes:

"Bonj" <[e-mail]> wrote in message news:33******** *****@individua l.net... [...]

> or better still
> if(fopen("xyz.t xt", "r") == NULL) ...

And now how will you refer to the stream?
>
>
> They both will work, but if(!fp) is less explicit,

IMO it's quite explicit. A test for true/false (zero/nonzero).

>as it's not actually a
> boolean value you're testing, it's a returned handle, and you're testing> whether it's NULL or not.

You're testing whether 'fp', after being converted to 'int',
is zero or not.

There's no conversion to int. The unary '!' operator tests whether
its operand compares equal to 0. For a pointer, comparison to 0 is
comparison to a null pointer constant.

But what is the type of the expression !fp?

The comparion is tone with the type of the variable (here a pointer to
FILE whatever that may be. The result is an int.
I was thinking in the wider context of 'if's (full)
conditional expression itself, and not the not :-) operator. If
it's not already type 'int', is there a conversion or not?
There is no conversion other than the implicit 0 gets converted to be
a null pointer constant. The result is generated as of type int.
e.g.

FILE *f = 0;

if(f) /* does this compare a 'FILE*' or 'int' object with zero? */
;

Comparion is in type of the variable. Result is generated in type of
int.

if (x) or in long if (x == 0)
is falling into 3 steps
1. x == (type of x)0; /* compare given variable with (type of x)0 */
2. if x is equal to (type of x)0 then (int)1 is generated, else (int)0
is generated.
3. conditional branch checks the result of the comparsion.

if (!x) or in long if (x != 0)
exchanges only the generated value.

It is on the implementation to suppress the explicite generation of
(int)0/1 and use processor flags of the comparsion or simply use a
test instruction. Depending on the instruction set it may even do
another optimision step and use an test/branch instruction. In no case
a conversation is needed or even done.

The same is with the ?: operator - except that the explicite 0/1 must
be generated when the result is needed for more than only to
distinguish the both possible results.

--
Tschau/Bye
Herbert

Visit http://www.ecomstation.de the home of german eComStation
eComStation 1.2 Deutsch ist da!

[Keith Thompson]

"Mike Wahler" <mk******@mkwah ler.net> writes:

"Keith Thompson" <ks***@mib.or g> wrote in message
news:ln******** ****@nuthaus.mi b.org...

"Mike Wahler" <mk******@mkwah ler.net> writes: [...]

> You're testing whether 'fp', after being converted to 'int',
> is zero or not.
There's no conversion to int. The unary '!' operator tests whether
its operand compares equal to 0. For a pointer, comparison to 0 is
comparison to a null pointer constant.

But what is the type of the expression !fp?

It's of type int.

C99 6.5.3.3p5:

The result of the logical negation operator ! is 0 if the value of
its operand compares unequal to 0, 1 if the value of its operand
compares equal to 0. The result has type int. The expression !E
is equivalent to (0==E).
I was thinking in the wider context of 'if's (full)
conditional expression itself, and not the not :-) operator. If
it's not already type 'int', is there a conversion or not?

e.g.

FILE *f = 0;

if(f) /* does this compare a 'FILE*' or 'int' object with zero? */
;

C99 6.8.4.1 p1-2:

Constraints

The controlling expression of an if statement shall have scalar type.

Semantics

In both forms, the first substatement is executed if the
expression compares unequal to 0. In the else form, the second
substatement is executed if the expression compares equal to 0.

Scalar types include arithmetic and pointer types.

So in

if (f) ...

the controlling expression has type FILE*. In

if (!f) ...

the operand of the "!" has type FILE*, and the controlling expression
has type int.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Michael Mair]

Herbert Rosenau wrote:

On Sat, 1 Jan 2005 22:51:05 UTC, "Mike Wahler" <mk******@mkwah ler.net>
wrote:

"Keith Thompson" <ks***@mib.or g> wrote in message
news:ln****** ******@nuthaus. mib.org...

"Mike Wahler" <mk******@mkwah ler.net> writes:

"Bonj" <[e-mail]> wrote in message news:33******** *****@individua l.net...

[...]

>or better still
>if(fopen(" xyz.txt", "r") == NULL) ...

And now how will you refer to the stream?

>
>They both will work, but if(!fp) is less explicit,

IMO it's quite explicit. A test for true/false (zero/nonzero).
>as it's not actually a
>boolean value you're testing, it's a returned handle, and you're
testing

>whether it's NULL or not.

You're testing whether 'fp', after being converted to 'int',
is zero or not.

There's no conversion to int. The unary '!' operator tests whether
its operand compares equal to 0. For a pointer, comparison to 0 is
comparison to a null pointer constant.

But what is the type of the expression !fp?

The comparion is tone with the type of the variable (here a pointer to
FILE whatever that may be. The result is an int.

I was thinking in the wider context of 'if's (full)
conditional expression itself, and not the not :-) operator. If
it's not already type 'int', is there a conversion or not?

There is no conversion other than the implicit 0 gets converted to be
a null pointer constant. The result is generated as of type int.

e.g.

FILE *f = 0;

if(f) /* does this compare a 'FILE*' or 'int' object with zero? */
;

Comparion is in type of the variable. Result is generated in type of
int.

if (x) or in long if (x == 0)

if (x) is equivalent to if (x != 0)
is falling into 3 steps
1. x == (type of x)0; /* compare given variable with (type of x)0 */
2. if x is equal to (type of x)0 then (int)1 is generated, else (int)0
is generated.
3. conditional branch checks the result of the comparsion.

if (!x) or in long if (x != 0)
if (!x) is equivalent to if (x == 0)
exchanges only the generated value.

It is on the implementation to suppress the explicite generation of
(int)0/1 and use processor flags of the comparsion or simply use a
test instruction. Depending on the instruction set it may even do
another optimision step and use an test/branch instruction. In no case
a conversation is needed or even done.

The same is with the ?: operator - except that the explicite 0/1 must
be generated when the result is needed for more than only to
distinguish the both possible results.

Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Herbert Rosenau]

On Sun, 2 Jan 2005 08:46:10 UTC, Michael Mair
<Mi**********@i nvalid.invalid> wrote:

if (!x) or in long if (x != 0)

if (!x) is equivalent to if (x == 0)

No, it's not, it is highly different.
--
Tschau/Bye
Herbert

Visit http://www.ecomstation.de the home of german eComStation
eComStation 1.2 Deutsch ist da!

[Michael Mair]

Herbert Rosenau wrote:

On Sun, 2 Jan 2005 08:46:10 UTC, Michael Mair
<Mi**********@i nvalid.invalid> wrote:

if (!x) or in long if (x != 0)

if (!x) is equivalent to if (x == 0)

No, it's not, it is highly different.

Don't be ridiculous.

-----------------------
#include <stdio.h>

int main (void)
{
double f = 0.0;
char *cp = 0;
int i = 0;

if (!i)
puts("!i");
if (i==0)
puts("i==0");
if (!cp)
puts("!cp");
if (cp==0)
puts("cp==0");
if (!f)
puts("!f");
if (f==0)
puts("f==0");

return 0;
}
-----------------------

gives me:
!i
i==0
!cp
cp==0
!f
f==0
Cheers
Michael
--
E-Mail: Mine is a gmx dot de address.

[Emmanuel Delahaye]

Herbert Rosenau wrote on 02/01/05 :

On Sun, 2 Jan 2005 08:46:10 UTC, Michael Mair
<Mi**********@i nvalid.invalid> wrote:

if (!x) or in long if (x != 0)

if (!x) is equivalent to if (x == 0)

No, it's not, it is highly different.

In what manner ? Can you be more specific ?

--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
The C-library: http://www.dinkumware.com/refxc.html

"C is a sharp tool"

[Stephen Sprunk]

"Herbert Rosenau" <os****@pc-rosenau.de> wrote in message
news:wm******** *************** ****@URANUS1.DV-ROSENAU.DE...

On Sun, 2 Jan 2005 08:46:10 UTC, Michael Mair
<Mi**********@i nvalid.invalid> wrote:

if (!x) or in long if (x != 0)

if (!x) is equivalent to if (x == 0)

No, it's not, it is highly different.

It is?

According to N869 6.5.3.3(5), they are equivalent:

"The result of the logical negation operator ! is 0 if the value of its
operand compares unequal to 0, 1 if the value of its operand compares equal
to 0. The result has type int. The expression !E is equivalent to (0==E). "

S

--
Stephen Sprunk "Stupid people surround themselves with smart
CCIE #3723 people. Smart people surround themselves with
K5SSS smart people who disagree with them." --Aaron Sorkin