Typecasting variable with another typedef

typedef struct {
  unsigned char a,
  unsigned char b, 
  unsigned char c
}type_a;

typedef struct {
 unsigned char e,
 unsigned char 开发者_高级运维f[2]
}type_b;

type_a sample;
sample.a = 1;
sample.b = 2;
sample.c = 3;

How do I typecast it and assign new value like:

sample = (type_b)sample; // syntax error
sample.f[1] = 'a';

You should really try it out yourself.

sample = (type_b)sample; /* Can't cast a structure to
                            another structure. */

sample.f[1] = 'a'; /* sample is still of type type_a,
                      and doesn't have an `f` field. */

No - C types are static, which means that sample will always remain of type type_a. However, you can achieve what you want using unions:

union {
    type_a as_a;
    type_b as_b;
} sample;

sample.as_a.a = 1;
sample.as_a.b = 2;
sample.as_a.c = 3;

sample.as_b.f[1] = 'a';

Note that it is not usual to create an object that is a bare union type like this; normally you would include the union within a struct, that includes a tag so that you know what type the object is at the present time:

struct {
    enum { TYPE_A, TYPE_B } type;
    union {
        type_a as_a;
        type_b as_b;
    } data;
} sample;

/* sample is a TYPE_A right now */
sample.type = TYPE_A;
sample.data.as_a.a = 1;
sample.data.as_a.b = 2;
sample.data.as_a.c = 3;

/* sample is now a TYPE_B */
sample.type = TYPE_B;
sample.data.as_b.f[1] = 'a';

You can't cast one data type to another incompatible data type. However, the memory is open for you. You can access it as follows:

typedef struct
{
  unsigned char a;
  unsigned char b; 
  unsigned char c;
}type_a;

typedef struct
{
 unsigned char e;
 unsigned char f[2];
}type_b;

type_a sample;
sample.a = 1;
sample.b = 2;
sample.c = 3;

type_b *sample_b = (type_b *) ((void*) &sample);

Try out yourself accessing sample_b->e and sample_b->f and see what happens.

No. You can do it by casting pointers: value_b = *((value_b*)&value_a) or by creating union of those two types.

However you do it, be careful. Structures can have different data alignment and you may get unexpected results.

yes you can copy the value of the type_a into type_b by trying something like

type_b sample_b =*((type_b*)&sample);

or

memcpy(&sample_b,&sample,sizeof(type_a));

Typecasting is nothing but converting an expression of one type to another one. But you seem to be trying to convert the type itself, which is fixed at compile time(variable declaration)

Its not clear the idea behind trying something like this. If you can make it more clear, people would be able to give more insights