Help with understanding this please

[mdh]

I am trying to define a struct called temp, using this code. Please be
kind in explaining with this is not working :-)

#include <stdio.h>
#include <stdlib.h>
struct t_node_n{
char *word;
int match;
struct t_node_n *left;
struct t_node_n *right;
};
struct t_node_n *temp = (struct t_node_n *) malloc(sizeof(struct
t_node_n)); /* error: initializer element is not constant */

int main {};

So, this is what I **thought** I was doing.
Create a pointer of type struct t_node_n called "temp".
Define the pointer "temp" by calling malloc....which I **thought**
gives the pointer "memory" to point to, thus defines it?
Clearly these thoughts are way off base!!
Thanks :-)

[Richard Heathfield]

mdh said:

I am trying to define a struct called temp, using this code. Please be
kind in explaining with this is not working :-)

#include <stdio.h>
#include <stdlib.h>
struct t_node_n{
char *word;
int match;
struct t_node_n *left;
struct t_node_n *right;
};
struct t_node_n *temp = (struct t_node_n *) malloc(sizeof(struct
t_node_n));

Better: struct t_node_n *temp = malloc(sizeof *temp);

Cleaner, tighter, less maintenance hassle.

/* error: initializer element is not constant */

Yes. You can't call a function except from within a function.

int main {};

Hmmm. I think you've been awake far too long. Get some rest. :-)

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[mdh]

>
Hmmm. I think you've been awake far too long. Get some rest. :-)

:-) I think you are correct

[mdh]

On Aug 30, 7:11*am, Richard Heathfield <[e-mail]:

mdh said:

>

struct t_node_n{
char *word;
int match;
struct t_node_n *left;
struct t_node_n *right;
};

struct t_node_n *temp = (struct t_node_n *) malloc(sizeof(struct
t_node_n));

Better: struct t_node_n *temp = malloc(sizeof *temp);

Cleaner, tighter, less maintenance hassle.

Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type "struct t_node n *). K&R
devote quite a discussion to this on page 142.

Thanks as always.

[mdh]

On Aug 30, 7:11 am, Richard Heathfield <[e-mail]:

mdh said:

struct t_node_n{
char *word;
int match;
struct t_node_n *left;
struct t_node_n *right;
};
struct t_node_n *temp = (struct t_node_n *) malloc(sizeof(struct
t_node_n));

Better: struct t_node_n *temp = malloc(sizeof *temp);
Cleaner, tighter, less maintenance hassle.

Richard...before I rest so that sleep can be calm!!, may I ask why
you
have not cast the return from malloc to type (struct t_node n *). K&R
devote quite a discussion to this on page 142.
Thanks as always.

[Richard Heathfield]

mdh said:

On Aug 30, 7:11 am, Richard Heathfield <[e-mail]:

>mdh said:

>>

struct t_node_n{
char *word;
int match;
struct t_node_n *left;
struct t_node_n *right;
};

struct t_node_n *temp = (struct t_node_n *) malloc(sizeof(struct
t_node_n));

Better: struct t_node_n *temp = malloc(sizeof *temp);

Cleaner, tighter, less maintenance hassle.

Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type "struct t_node n *).

Why on earth would I do that? What good could it possibly do?

K&R devote quite a discussion to this on page 142.

That *was* the proper method, before void * was introduced to the language.
This is one of those very few parts of this excellent book that should
have been written more carefully. It is true that the malloc function used
to return char *, way back in the Cretaceous Period, but for about twenty
years it has returned void *. The language automagically provides an
implicit conversion from void * to struct t_node_n *, so there is no need
for a cast. Given that it does no good, and stops nothing bad happening,
and can in fact obscure the accidental omission of <stdlib.hfor the
malloc prototype, I see no reason to include a cast and every reason not
to include one.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[mdh]

On Aug 30, 7:36*am, Richard Heathfield <[e-mail]:

>

Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type "struct t_node n *).

Why on earth would I do that? What good could it possibly do?

K&R devote quite a discussion to this on page 142.

That *was* the proper method, before void * was introduced to the language.
This is one of those very few parts of this excellent book that should
have been written more carefully. It is true that the malloc function used
to return char *, way back in the Cretaceous Period, but for about twenty
years it has returned void *. The language automagically provides an
implicit conversion from void * to struct t_node_n *, so there is no need
for a cast.

Thanks as always...and thanks for the humor or humour...which I know
is lost on some, but is immensely appreciated by myself.

[Richard]

Richard Heathfield <rj*@see.sig.invalidwrites:

mdh said:

>On Aug 30, 7:11 am, Richard Heathfield <[e-mail]:

>>mdh said:

>>>
struct t_node_n{
char *word;
int match;
struct t_node_n *left;
struct t_node_n *right;
};

struct t_node_n *temp = (struct t_node_n *) malloc(sizeof(struct
t_node_n));

Better: struct t_node_n *temp = malloc(sizeof *temp);

Cleaner, tighter, less maintenance hassle.

Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type "struct t_node n *).

Why on earth would I do that? What good could it possibly do?

Yeah because C++ is wrong and so was pre Ansi C.

Streuth.

[Malcolm McLean]

"Richard" <rg****@gmail.comwrote in message news:

Richard Heathfield <rj*@see.sig.invalidwrites:

>mdh said:

>>Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type "struct t_node n *).

Why on earth would I do that? What good could it possibly do?

Yeah because C++ is wrong and so was pre Ansi C.

It's an emphasis problem.
You want to warn about potentially unsafe operations, such as converting
from one type to another.
However only rarely will you want to assign the result of malloc() to a void
*. In this case, the warnings are gratuitous. Too many warnings are as bad
as too few, because people start ignoring them, and the genuinely
exceptional casts get lost in the noise.
--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[Richard]

"Malcolm McLean" <re*******@btinternet.comwrites:

"Richard" <rg****@gmail.comwrote in message news:

>Richard Heathfield <rj*@see.sig.invalidwrites:

>>mdh said:

Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type "struct t_node n *).

Why on earth would I do that? What good could it possibly do?

Yeah because C++ is wrong and so was pre Ansi C.

It's an emphasis problem.
You want to warn about potentially unsafe operations, such as
converting from one type to another.
However only rarely will you want to assign the result of malloc() to
a void *. In this case, the warnings are gratuitous. Too many warnings
are as bad as too few, because people start ignoring them, and the
genuinely exceptional casts get lost in the noise.

You miss the point. Heathfield's typically smarmy reply seemed to indicate
that the cast was something only an idiot would do.

[Keith Thompson]

mdh <md**@comcast.netwrites:
[...]

Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type "struct t_node n *). K&R
devote quite a discussion to this on page 142.

[...]

It's also discussed on the K&R2 errata page,
<http://plan9.bell-labs.com/cm/cs/cbook/2ediffs.html>.
Now that the server is back up, I can quote it:

142(6.5, toward the end): The remark about casting the return
value of malloc ("the proper method is to declare ... then
explicitly coerce") needs to be rewritten. The example is correct
and works, but the advice is debatable in the context of the
1988-1989 ANSI/ISO standards. It's not necessary (given that
coercion of void * to ALMOSTANYTYPE * is automatic), and possibly
harmful if malloc, or a proxy for it, fails to be declared as
returning void *. The explicit cast can cover up an unintended
error. On the other hand, pre-ANSI, the cast was necessary, and it
is in C++ also.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[lawrence.jones]

mdh <md**@comcast.netwrote:

>
Richard...before I rest so that sleep can be calm!!, may I ask why you
have not cast the return from malloc to type (struct t_node n *). K&R
devote quite a discussion to this on page 142.

See the errata for that page:

<http://cm.bell-labs.com/cm/cs/cbook/2ediffs.html>
--
Larry Jones

Shut up and go get me some antiseptic. -- Calvin

[lawrence.jones]

Richard <rg****@gmail.comwrote [re. casting the return value of malloc]:

Richard Heathfield <rj*@see.sig.invalidwrites:

Why on earth would I do that? What good could it possibly do?

Yeah because C++ is wrong and so was pre Ansi C.

C++ isn't wrong, it's different (C++ programs should use new rather than
malloc). Pre-ANSI C *was* wrong, that's why ANSI changed it.
--
Larry Jones

Everything's gotta have rules, rules, rules! -- Calvin

[Richard]

la************@siemens.com writes:

Richard <rg****@gmail.comwrote [re. casting the return value of malloc]:

>Richard Heathfield <rj*@see.sig.invalidwrites:

>
Why on earth would I do that? What good could it possibly do?

Yeah because C++ is wrong and so was pre Ansi C.

C++ isn't wrong, it's different (C++ programs should use new rather than
malloc). Pre-ANSI C *was* wrong, that's why ANSI changed it.

My point seems to have eluded you. And that is it is NOT obvious. And
Heathfield's reply was less than useless.

[Mark McIntyre]

mdh wrote:

may I ask why you
have not cast the return from malloc to type "struct t_node n *).

In C, you *never* have to cast the return from malloc.

K&R devote quite a discussion to this on page 142.

This is an error in K&R which the authors have acknowledged. The
discussion predates ANSI C.

[mdh]

On Aug 30, 4:21*pm, Mark McIntyre <[e-mail]>
wrote:

mdh wrote:

may I ask why you
have not cast the return from malloc to type "struct t_node n *).

In C, you *never* have to cast the return from malloc.

K&R devote quite a discussion to this on page 142.

This is an error in K&R which the authors have acknowledged. The
discussion predates ANSI C.

Thank you to all who have pointed this out...much appreciated.

[Keith Thompson]

Richard<rg****@gmail.comwrites:

la************@siemens.com writes:

>Richard <rg****@gmail.comwrote [re. casting the return value of malloc]:

>>Richard Heathfield <rj*@see.sig.invalidwrites:

Why on earth would I do that? What good could it possibly do?

Yeah because C++ is wrong and so was pre Ansi C.

C++ isn't wrong, it's different (C++ programs should use new rather than
malloc). Pre-ANSI C *was* wrong, that's why ANSI changed it.

My point seems to have eluded you. And that is it is NOT obvious. And
Heathfield's reply was less than useless.

Let me draw your attention to the original poster's response to
RH's "less than useless" reply:

Thanks as always...and thanks for the humor or humour...which I know
is lost on some, but is immensely appreciated by myself.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Richard Heathfield]

Mark McIntyre said:

mdh wrote:

>may I ask why you
have not cast the return from malloc to type "struct t_node n *).

In C, you *never* have to cast the return from malloc.

>K&R devote quite a discussion to this on page 142.

This is an error in K&R which the authors have acknowledged.

The discussion on p142 may be regarded as an error, yes. Note, however,
that the actual cast is not an error, merely poor style.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Richard]

Keith Thompson <ks***@mib.orgwrites:

Richard<rg****@gmail.comwrites:

>la************@siemens.com writes:

>>Richard <rg****@gmail.comwrote [re. casting the return value of malloc]:
Richard Heathfield <rj*@see.sig.invalidwrites:

Why on earth would I do that? What good could it possibly do?

Yeah because C++ is wrong and so was pre Ansi C.

C++ isn't wrong, it's different (C++ programs should use new rather than
malloc). Pre-ANSI C *was* wrong, that's why ANSI changed it.

My point seems to have eluded you. And that is it is NOT obvious. And
Heathfield's reply was less than useless.

Let me draw your attention to the original poster's response to
RH's "less than useless" reply:

Thanks as always...and thanks for the humor or humour...which I know
is lost on some, but is immensely appreciated by myself.

I'm not sure if you are trying to be amusing or typically pedantic and
elusive.

If you think

>>Why on earth would I do that? What good could it possibly do?

is a good answer to a newbies question then you need to take a break.

[Keith Thompson]

Richard<rg****@gmail.comwrites:

Keith Thompson <ks***@mib.orgwrites:

>Richard<rg****@gmail.comwrites:

>>la************@siemens.com writes:
Richard <rg****@gmail.comwrote [re. casting the return value of malloc]:
Richard Heathfield <rj*@see.sig.invalidwrites:
Why on earth would I do that? What good could it possibly do?
>
Yeah because C++ is wrong and so was pre Ansi C.

C++ isn't wrong, it's different (C++ programs should use new rather than
malloc). Pre-ANSI C *was* wrong, that's why ANSI changed it.

My point seems to have eluded you. And that is it is NOT obvious. And
Heathfield's reply was less than useless.

Let me draw your attention to the original poster's response to
RH's "less than useless" reply:

Thanks as always...and thanks for the humor or humour...which I know
is lost on some, but is immensely appreciated by myself.

I'm not sure if you are trying to be amusing or typically pedantic and
elusive.

Neither.

If you think

>>>Why on earth would I do that? What good could it possibly do?

is a good answer to a newbies question then you need to take a break.

I don't think it would have been a good answer by itself. It was, in
fact, a preamble to a longer answer (which you naturally snipped)
which explained why there is no good reason to cast the result of
malloc(). Since the person asking the question found the answer *as a
whole* useful, your opinion that it's "less than useless" would seem
to be nothing more than your usual trolling.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"