type casting

[Roman Mashak]

Hello, All!

I met this code recently on some open source sites. What may be the point of
using such construction:

typedef struct cmd
{
unsigned int cmdack;
unsigned int code;
unsigned int data[1];
} CMD;

....

int proc_cmd()
{
char msg[]={"CMD"};
int lenth = strlen(msg);
CMD *t, *r;
int st[100];
int sr[100];

t = (CMD *)st;
r = (CMD *)sr;
...
/* process msg */
if(strncmp((char *)&r->cmdack, msg, len) == 0
{
....
}
}

Why to define structure's member as 'unsigned int' and then implicitly do
type casting?

With best regards, Roman Mashak. E-mail: (e-mail address removed)

 

[Tomás]

Roman Mashak posted:

Hello, All!

I met this code recently on some open source sites. What may be the
point of using such construction:

typedef struct cmd
{
unsigned int cmdack;
unsigned int code;
unsigned int data[1];
} CMD;

You can define more memory pass the end of the structure and then use the
last array member to access them:

#include <...

typedef struct Monkey {
unsigned a;
unsigned b;
unsigned vars[1];
};

int main(void)
{
Monkey * const pmonkey = malloc( sizeof(Monkey) + 10 );

pmonkey->vars[7] = 53;
}

Why to define structure's member as 'unsigned int' and then implicitly
do type casting?

No reason, it's stupid code. It also depends on the fact that there's no
padding between the structure's members.


-Tomás

 

[Tomás]

malloc( sizeof(Monkey) + 10 );


Opps.

malloc( sizeof(Monkey) + sizeof( int[10] ) );


-Tomás

 

[pete]

Hello, All!

I met this code recently on some open source sites. What may be the point of
using such construction:

typedef struct cmd
{
unsigned int cmdack;
unsigned int code;
unsigned int data[1];
} CMD;

...

int proc_cmd()
{
char msg[]={"CMD"};
int lenth = strlen(msg);
CMD *t, *r;
int st[100];
int sr[100];

t = (CMD *)st;
r = (CMD *)sr;
...
/* process msg */
if(strncmp((char *)&r->cmdack, msg, len) == 0
{
....
}
}

Why to define structure's member as
'unsigned int' and then

implicitly do type casting?

"cast" is the right way to say "implicitly do type casting".

The shown code,
suggests that r should be defined with type pointer to char.
As the code is,
((char *)&r->cmdack) is equal to (char *)r.

 

[Richard Heathfield]

pete said:

"cast" is the right way to say "implicitly do type casting".

No, it isn't. An implicit conversion is not a cast. A cast is an explicit
conversion, so if it's implicit, it's not casting.

 

[pete]

pete said:


No, it isn't.

Yes, it is.

An implicit conversion is not a cast.
A cast is an explicit conversion,
so if it's implicit, it's not casting.

The right way to say that,
is the way which applies to the code that you snipped:

"A cast is an explicit conversion,
so if it's a cast, it's not implicit."

 

[Richard Heathfield]

pete said:

The right way to say that,
is the way which applies to the code that you snipped:

"A cast is an explicit conversion,
so if it's a cast, it's not implicit."

Yes. I apologise for my incorrect "correction".

 

[Roman Mashak]

Hello, pete!
You wrote on Mon, 22 May 2006 12:11:54 GMT:

p> The shown code,
p> suggests that r should be defined with type pointer to char.
p> As the code is,
p> ((char *)&r->cmdack) is equal to (char *)r.
Yes, but what not to use 'char' members? Is the only reason - to eliminate
padding within structure?

With best regards, Roman Mashak. E-mail: (e-mail address removed)

 

[Roman Mashak]

Hello, Tomás!
You wrote on Mon, 22 May 2006 11:54:10 GMT:

T> You can define more memory pass the end of the structure and then use
T> the last array member to access them:
Is it legal and valid in standard C (if speaking about C89) ?

T> #include <...

T> typedef struct Monkey {
T> unsigned a;
T> unsigned b;
T> unsigned vars[1];
T> };

T> int main(void)
T> {
T> Monkey * const pmonkey = malloc( sizeof(Monkey) + 10 );

T> pmonkey->vars[7] = 53;
T> }

T> <snip code>

With best regards, Roman Mashak. E-mail: (e-mail address removed)

 

[pete]

Hello, pete!
You wrote on Mon, 22 May 2006 12:11:54 GMT:

p> The shown code,
p> suggests that r should be defined with type pointer to char.
p> As the code is,
p> ((char *)&r->cmdack) is equal to (char *)r.
Yes, but what not to use 'char' members?
Is the only reason - to eliminate
padding within structure?

I don't really understand why the code is written
exactly the way that it is.