Printable View
Say I have
I can initialize it with some addressCode:void *var_ptr;
and use the address as a value in math expressionsCode:var_ptr = (int *) 100;
Right? Is it gonna cause a problem in the program?Code:int val1, val2 = 5;
val1 = val2 + (int)var_ptr ;
What are you really trying to do?
You can mash your way through anything with sufficient amounts of casting.
I 'm very short on space.Quote:
Originally Posted by Salem
So instead allocating
I can allocate onlyCode:typedef struct
{
void *ptr;
int val;
}
And use a pointer address as a value.Code:typedef struct
{
void *ptr;
}
Are ints and pointers the same size on your machine?
If you want to make sure your ints can hold a pointer, then use an intptr_t.
Fixed width integer types (since C99) - cppreference.com
Perhaps a union, if you're just trying to economise on space.
You can store either an int or a pointer.Code:typedef union
{
void *ptr;
int val;
} int_or_ptr_t;
Depends on your architecture.
Suppose, for your processor, the int type is 32 bits long. And suppose that an memory address is 64 bits long (for example, on x86-64 mode on Intel/AMD processors).
That expression in your example will strip the upper 32 bits of var_ptr (because of the int casting) and add the resulting value to val2, assigning to val1.
Take a look in this example:
Compiling and linking:Code:/* test.c */
#include <stdio.h>
int main( void )
{
int val1, val2, val3;
void *p, *q;
val3 = -1; // all bits 1
p = main; // p is the address of main.
val1 = val3 + (int)p; // strip upper bits from p.
val2 = val3 + p; // promote val3 to (long),
// but strip upper bits on assignment.
q = p + val3; // promote val3 to (long).
// no stripping.
// using "%lx" because I know a ptr and a long are the same size
// on x86-64.
printf( "%x, %x, %lx\n", val1, val2, (long)q );
}
Notice the 0x563f00000000 difference and the warnings?Quote:
$ cc -o test test.c
test.c: In function ‘main’:
test.c:11:17: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
val1 = val3 + (int)p; // strip upper bits from p.
^
test.c:13:8: warning: assignment makes integer from pointer without a cast [-Wint-conversion]
val2 = val3 + p; // promote val3 to (long),
^
$ ./test
74b40649, 74b40649, 563f74b40649
In x86-64 the pointer types have 64 bits. But other architectures can use different sizes for pointers and int.
If you want to deal with integers and pointers this way you can use the intptr_t (or uintptr_t) defined in stdint.h. You won't get rid of the warnings, but it is garanteed not to have these side effects on the results (the size of intptr_t and a pointer are the same).
But, be warned: the size of a pointer can be smaller then of an int as well... depends on the processor!
This variant will do. I always work with 32-bit platform. int will cover all values I ever need. Thank you.Quote:
Originally Posted by Salem
or even better
this way I need no field holding data type information. I can cast to exact pointer I need.Code:typedef union
{
uint8_t *ptr;
int16_t *ptr;
int32_t *ptr;
int val;
} int_or_ptr_t;
You'll find that that union code won't even compile. Each field in a union or struct must have a unique name, such as ptr8, ptr16, and ptr32. Then if you know what type is pointed to, you won't need a cast. Just use the correct pointer (or val if it's an integer rather than a pointer to data).Quote:
Originally Posted by john7
It is exactly what a union is designed to do, to save space by having 2 different ways that the memory can be used.Quote:
I 'm very short on space.