Pointer to Structure Casts

Discussion in 'C Programming' started by caleb.vandyke@gmail.com, Sep 21, 2005.

  1. Guest

    I am working with some code that is doing some pointer to structure
    casts and I can't figure out how the cast is being done. Here is
    basically the code.

    #include <stdio.h>
    #include <stdlib.h>

    typedef struct diffRecord
    {
    struct record *next[1];
    } DiffRecord;

    typedef struct record
    {
    struct record *next;
    int value;
    } Record;

    int main(int argc, char* argv[])
    {
    Record *rec1 = malloc(sizeof(Record));
    rec1->value = 5;

    Record *rec2 = malloc(sizeof(Record));
    rec2->value = 6;

    rec1->next = rec2;
    rec2->next = NULL;

    DiffRecord *diffRec = ((DiffRecord*)rec1)->next[0];
    Record *testRec = (Record*)diffRec;

    printf("The value is: %i\n", testRec->value); //prints 6

    free(rec1);
    free(rec2);

    return 0;
    }

    How is the pointer contained in record being coerced into the array in
    the diffRecord structure?

    Caleb Van Dyke
     
    , Sep 21, 2005
    #1
    1. Advertising

  2. <> wrote in message
    news:...
    > I am working with some code that is doing some pointer to structure
    > casts and I can't figure out how the cast is being done. Here is
    > basically the code.

    ....
    > typedef struct diffRecord
    > {
    > struct record *next[1];
    > } DiffRecord;
    >
    > typedef struct record
    > {
    > struct record *next;
    > int value;
    > } Record;
    >
    > int main(int argc, char* argv[])
    > {
    > Record *rec1 = malloc(sizeof(Record));
    > rec1->value = 5;
    >
    > Record *rec2 = malloc(sizeof(Record));
    > rec2->value = 6;
    >
    > rec1->next = rec2;
    > rec2->next = NULL;
    >
    > DiffRecord *diffRec = ((DiffRecord*)rec1)->next[0];
    > Record *testRec = (Record*)diffRec;
    >
    > printf("The value is: %i\n", testRec->value); //prints 6

    ....
    > How is the pointer contained in record being coerced into the array in
    > the diffRecord structure?


    Here:
    struct record *next[1];
    struct record *next;
    One struct contains array of 1 pointer.
    The other contains 1 pointer, w/o being part of any array.
    But, they both contain a pointer anyway, so there's no problem here. It's
    not much different from the case when you have an array of 1 int and just 1
    int, simply the type is different.
    So, both structs contain in their beginning a pointer (or array of one
    pointer -- doesn't matter how you think of it, in this particular case it's
    essentially the same thing and from the memory's standpoint the two things
    are equivalent)...
    I can only say that this is a bit odd code... I'd expect this way of casting
    Record *testRec = (Record*)diffRec;
    rather than this
    DiffRecord *diffRec = ((DiffRecord*)rec1)->next[0];
    But you have both. What for?

    Alex
     
    Alexei A. Frounze, Sep 21, 2005
    #2
    1. Advertising

  3. On 20 Sep 2005 17:11:02 -0700, ""
    <> wrote:

    >I am working with some code that is doing some pointer to structure
    >casts and I can't figure out how the cast is being done. Here is
    >basically the code.


    The cast is being done by the statements that contain the casts. What
    can't you figure out?
    >
    >#include <stdio.h>
    >#include <stdlib.h>
    >
    >typedef struct diffRecord
    >{
    > struct record *next[1];
    >} DiffRecord;
    >
    >typedef struct record
    >{
    > struct record *next;
    > int value;
    >} Record;
    >
    >int main(int argc, char* argv[])
    >{
    > Record *rec1 = malloc(sizeof(Record));
    > rec1->value = 5;
    >
    > Record *rec2 = malloc(sizeof(Record));


    Many C compilers do not allow definitions to follow executable
    statements within a block. (It did not become a standard feature
    until C99 and there aren't many C99 compilers in use.) By not putting
    all your definitions at the start of the block you reduce the number
    of people in the group who can help you.

    > rec2->value = 6;
    >
    > rec1->next = rec2;
    > rec2->next = NULL;


    You now have a linked list with two elements.

    >
    > DiffRecord *diffRec = ((DiffRecord*)rec1)->next[0];


    Take the value in rec1 which has the type pointer to Record and
    convert it by whatever means is appropriate for your system to point
    to the same address but with type pointer to DiffRecord. Since next
    and next[] are the first members of their respective structs, you are
    guaranteed there is no padding before them so this code will pick up
    the pointer that has offset 0 into the struct.

    This is a bad idea. It is probable that Record and DiffRecord have
    the same alignment but why run the risk. If the value in rec1 is not
    suitably aligned for a DiffRecord, this would invoke undefined
    behavior.

    > Record *testRec = (Record*)diffRec;


    Do the same thing in the opposite direction.

    Since the standard requires all pointers to struct to have the same
    size and representation, the value will always be the same address but
    the type is changing.

    >
    > printf("The value is: %i\n", testRec->value); //prints 6
    >
    > free(rec1);
    > free(rec2);
    >
    > return 0;
    >}
    >
    >How is the pointer contained in record being coerced into the array in
    >the diffRecord structure?


    It isn't. rec1 is being treated as if it points to a DiffRecord.
    next[0] is a pointer which occupies the beginning of the struct. rec1
    actually points to a Record. "It just so happens" that the beginning
    of this struct is also occupied by a pointer of the same type.

    It's still a lousy idea. If you change value from an int to a double
    you would invoke undefined behavior on my system.

    >
    >Caleb Van Dyke



    <<Remove the del for email>>
     
    Barry Schwarz, Sep 21, 2005
    #3
  4. Guest

    Alexei A. Frounze wrote:
    > <> wrote in message
    > news:...
    > > I am working with some code that is doing some pointer to structure
    > > casts and I can't figure out how the cast is being done. Here is
    > > basically the code.

    > ...
    > > typedef struct diffRecord
    > > {
    > > struct record *next[1];
    > > } DiffRecord;
    > >
    > > typedef struct record
    > > {
    > > struct record *next;
    > > int value;
    > > } Record;
    > >
    > > int main(int argc, char* argv[])
    > > {
    > > Record *rec1 = malloc(sizeof(Record));
    > > rec1->value = 5;
    > >
    > > Record *rec2 = malloc(sizeof(Record));
    > > rec2->value = 6;
    > >
    > > rec1->next = rec2;
    > > rec2->next = NULL;
    > >
    > > DiffRecord *diffRec = ((DiffRecord*)rec1)->next[0];
    > > Record *testRec = (Record*)diffRec;
    > >
    > > printf("The value is: %i\n", testRec->value); //prints 6

    > ...
    > > How is the pointer contained in record being coerced into the array in
    > > the diffRecord structure?

    >
    > Here:
    > struct record *next[1];
    > struct record *next;
    > One struct contains array of 1 pointer.
    > The other contains 1 pointer, w/o being part of any array.
    > But, they both contain a pointer anyway, so there's no problem here. It's
    > not much different from the case when you have an array of 1 int and just 1
    > int, simply the type is different.
    > So, both structs contain in their beginning a pointer (or array of one
    > pointer -- doesn't matter how you think of it, in this particular case it's
    > essentially the same thing and from the memory's standpoint the two things
    > are equivalent)...
    > I can only say that this is a bit odd code... I'd expect this way of casting
    > Record *testRec = (Record*)diffRec;
    > rather than this
    > DiffRecord *diffRec = ((DiffRecord*)rec1)->next[0];
    > But you have both. What for?
    >
    > Alex


    This code actually is from another author. Their code looks something
    like this:

    #include <stdio.h>
    #include <stdlib.h>

    typedef struct diffRecord
    {
    struct diffRecord *next[2];
    } DiffRecord;

    typedef struct record
    {
    struct record *next;
    struct record *previous;
    int value;
    } Record;

    static void printValue(int index, Record *rec)
    {
    DiffRecord *diffRec = (DiffRecord*)rec;
    Record *testRec = (Record*)diffRec->next[index];
    printf("Value: %i\n", testRec->value);
    }

    int main(int argc, char* argv[])
    {
    Record *rec1 = malloc(sizeof(Record));
    Record *rec2 = malloc(sizeof(Record));
    Record *rec3 = malloc(sizeof(Record));

    rec1->value = 5;
    rec2->value = 6;
    rec3->value = 7;

    rec1->next = rec2;
    rec1->previous = NULL;

    rec2->previous = rec1;
    rec2->next = rec3;

    rec3->previous = rec2;
    rec3->next = NULL;

    printValue(0, rec2);
    printValue(1, rec2);

    free(rec3);
    free(rec2);
    free(rec1);

    return 0;
    }

    Output:
    Value: 7
    Value: 5

    I think their intention was for the parameter index in printValue() to
    be some sort of selector for the pointers in the rec parameter. The
    haven't seen a cast like this before but I am assuming that this works
    becuase the first two parameters of Record are pointers?

    If say Record looks like this:

    typedef struct record
    {
    struct record *next;
    int value;
    struct record *previous;
    } Record;

    and I cast struct record to a struct diffRecord would I get some
    undefined behaviour trying to access next[1] field of diffRecord?

    Thanks for the help,
    Caleb Van Dyke
     
    , Sep 22, 2005
    #4
  5. On 21 Sep 2005 17:27:45 -0700, ""
    <> wrote:

    snip ~60 lines of code you now tell us is irrelevant. Please trim
    your posts.

    >
    >This code actually is from another author. Their code looks something
    >like this:
    >
    >#include <stdio.h>
    >#include <stdlib.h>
    >
    >typedef struct diffRecord
    >{
    > struct diffRecord *next[2];


    next[0] will be followed immediately by next[1].

    >} DiffRecord;
    >
    >typedef struct record
    >{
    > struct record *next;
    > struct record *previous;


    But there is no guarantee that previous immediately follows next in
    the memory occupied buy such a structure.

    > int value;
    >} Record;
    >
    >static void printValue(int index, Record *rec)
    >{
    > DiffRecord *diffRec = (DiffRecord*)rec;
    > Record *testRec = (Record*)diffRec->next[index];
    > printf("Value: %i\n", testRec->value);


    This is still crappy code that could be solved without risk of
    undefined behavior by code like
    testRec = index ? rec->previous : rec->next;

    >}
    >
    >int main(int argc, char* argv[])
    >{
    > Record *rec1 = malloc(sizeof(Record));
    > Record *rec2 = malloc(sizeof(Record));
    > Record *rec3 = malloc(sizeof(Record));
    >
    > rec1->value = 5;
    > rec2->value = 6;
    > rec3->value = 7;
    >
    > rec1->next = rec2;
    > rec1->previous = NULL;
    >
    > rec2->previous = rec1;
    > rec2->next = rec3;
    >
    > rec3->previous = rec2;
    > rec3->next = NULL;
    >
    > printValue(0, rec2);
    > printValue(1, rec2);
    >
    > free(rec3);
    > free(rec2);
    > free(rec1);
    >
    > return 0;
    >}
    >
    >Output:
    >Value: 7
    >Value: 5
    >
    >I think their intention was for the parameter index in printValue() to
    >be some sort of selector for the pointers in the rec parameter. The
    >haven't seen a cast like this before but I am assuming that this works
    >becuase the first two parameters of Record are pointers?
    >
    >If say Record looks like this:
    >
    >typedef struct record
    >{
    > struct record *next;
    > int value;
    > struct record *previous;
    >} Record;
    >
    >and I cast struct record to a struct diffRecord would I get some
    >undefined behaviour trying to access next[1] field of diffRecord?


    Absolutely.


    <<Remove the del for email>>
     
    Barry Schwarz, Sep 22, 2005
    #5
  6. Guest

    Barry Schwarz wrote:
    > On 21 Sep 2005 17:27:45 -0700, ""
    > <> wrote:
    >
    > snip ~60 lines of code you now tell us is irrelevant. Please trim
    > your posts.
    >


    Sorry it's so long. I was trying to be concise. Thanks for answering my
    question, but why do you think I am saying this is irrelevant? I was
    trying to figure out the behavior of structure members when they are
    cast to another structure. I only posted the revised code to show why
    this weird cast was being done.

    Caleb Van Dyke
     
    , Sep 22, 2005
    #6
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Wolfgang Jeltsch

    pointer casts and the heap

    Wolfgang Jeltsch, Aug 30, 2003, in forum: C++
    Replies:
    7
    Views:
    378
    Kevin Goodsell
    Aug 31, 2003
  2. Replies:
    8
    Views:
    348
    Kai-Uwe Bux
    Feb 10, 2009
  3. SG
    Replies:
    8
    Views:
    355
  4. Jef Driesen

    Union and pointer casts?

    Jef Driesen, Feb 24, 2011, in forum: C Programming
    Replies:
    13
    Views:
    712
    Ben Bacarisse
    Apr 8, 2011
  5. Sean Hamilton

    Pointer casts for OOP

    Sean Hamilton, Aug 18, 2011, in forum: C Programming
    Replies:
    2
    Views:
    284
    James Kuyper
    Aug 18, 2011
Loading...

Share This Page