What are the rules for casting pointers in C

Question

K amp R doesn t go over it  but they use it  I tried seeing how it d work by writing an example program  but it didn t go so well     include  lt stdio h gt   int bleh  int       int main        char c    5        char  d    amp c       bleh  int   d        return 0       int bleh int  n       printf   d bleh n    n        return  n       It compiles  but my print statement spits out garbage variables  they re different every time I call the program   Any ideas

User · Answer

Casting pointers is usually invalid in C. There are several reasons:

Alignment. It's possible that, due to alignment considerations, the destination pointer type is not able to represent the value of the source pointer type. For example, if int * were inherently 4-byte aligned, casting char * to int * would lose the lower bits.
Aliasing. In general it's forbidden to access an object except via an lvalue of the correct type for the object. There are some exceptions, but unless you understand them very well you don't want to do it. Note that aliasing is only a problem if you actually dereference the pointer (apply the * or -> operators to it, or pass it to a function that will dereference it).

The main notable cases where casting pointers is okay are:

When the destination pointer type points to character type. Pointers to character types are guaranteed to be able to represent any pointer to any type, and successfully round-trip it back to the original type if desired. Pointer to void (void *) is exactly the same as a pointer to a character type except that you're not allowed to dereference it or do arithmetic on it, and it automatically converts to and from other pointer types without needing a cast, so pointers to void are usually preferable over pointers to character types for this purpose.
When the destination pointer type is a pointer to structure type whose members exactly match the initial members of the originally-pointed-to structure type. This is useful for various object-oriented programming techniques in C.

Some other obscure cases are technically okay in terms of the language requirements, but problematic and best avoided.

User · Answer

You have a pointer to a char  So as your system knows  on that memory address there is a char value on sizeof char  space  When you cast it up to int   you will work with data of sizeof int   so you will print your char and some memory-garbage after it as an integer

User · Answer

char c    5    A char  1 byte  is allocated on stack at address 0x12345678   char  d    amp c    You obtain the address of c and store it in d  so d   0x12345678   int  e    int  d    You force the compiler to assume that 0x12345678 points to an int  but an int is not just one byte  sizeof char     sizeof int    It may be 4 or 8 bytes according to the architecture or even other values   So when you print the value of the pointer  the integer is considered by taking the first byte  that was c  and other consecutive bytes which are on stack and that are just garbage for your intent

User · Answer

I suspect you need a more general answer   There are no rules on casting pointers in C  The language lets you cast any pointer to any other pointer without comment   But the thing is  There is no data conversion or whatever done  Its solely your own responsibilty that the system does not misinterpret the data after the cast - which would generally be the case  leading to runtime error   So when casting its totally up to you to take care that if data is used from a casted pointer the data is compatible   C is optimized for performance  so it lacks runtime reflexivity of pointers references  But that has a price - you as a programmer have to take better care of what you are doing  You have to know on your self if what you want to do is  legal

User · Answer

When thinking about pointers  it helps to draw diagrams  A pointer is an arrow that points to an address in memory  with a label indicating the type of the value  The address indicates where to look and the type indicates what to take  Casting the pointer changes the label on the arrow but not where the arrow points   d in main is a pointer to c which is of type char  A char is one byte of memory  so when d is dereferenced  you get the value in that one byte of memory  In the diagram below  each cell represents one byte   - ---- ---- ---- ---- ---- ---- -         c                         - ---- ---- ---- ---- ---- ---- -                      char        d   When you cast d to int   you re saying that d really points to an int value  On most systems today  an int occupies 4 bytes   - ---- ---- ---- ---- ---- ---- -         c     1    2    3         - ---- ---- ---- ---- ---- ---- -                                     int         int  d   When you dereference  int  d  you get a value that is determined from these four bytes of memory  The value you get depends on what is in these cells marked    and on how an int is represented in memory   A PC is little-endian  which means that the value of an int is calculated this way  assuming that it spans 4 bytes       int  d     c    1   28    2   2  6    3   2  4  So you ll see that while the value is garbage  if you print in in hexadecimal  printf   x n    n    the last two digits will always be 35  that s the value of the character  5     Some other systems are big-endian and arrange the bytes in the other direction      int  d     c   2  4    1   2  6    2   28    3  On these systems  you d find that the value always starts with 35 when printed in hexadecimal  Some systems have a size of int that s different from 4 bytes  A rare few systems arrange int in different ways but you re extremely unlikely to encounter them   Depending on your compiler and operating system  you may find that the value is different every time you run the program  or that it s always the same but changes when you make even minor tweaks to the source code   On some systems  an int value must be stored in an address that s a multiple of 4  or 2  or 8   This is called an alignment requirement  Depending on whether the address of c happens to be properly aligned or not  the program may crash   In contrast with your program  here s what happens when you have an int value and take a pointer to it   int x   42  int  p    amp x      - ---- ---- ---- ---- ---- ---- -                 x                 - ---- ---- ---- ---- ---- ---- -                                     int        p   The pointer p points to an int value  The label on the arrow correctly describes what s in the memory cell  so there are no surprises when dereferencing it

[c] What are the rules for casting pointers in C?

Examples related to c

Examples related to pointers

Examples related to casting