point to low byte address of variable in c

Question

I want to learn if this is possible:

for ex:

we have long Lvalue = 0xFF00f41a;

and also have int *p;

Can we point to last 2 byte of Lvalue

like p=&Lvalue <<16;

p pointed frist 16 bit value is it possible?

*p --> f41a;
*(p+1) --->0xFF00;

then if

p = 0xa011;

long Lvalue ---> 0xFF00a011

actually I need bit operations. I have 32 bit value but I can send only 16 bits and if I change 16 bit have to change first 16 bit last 16 bit of 32 bit value.

Your question is very confused. What do you want and how is that related to pointers? See [ask] and provide a [mcve] — too honest for this site, Apr 27 '16 at 12:42
If I understood it correctly, you want to change the lower `int` part of a `long` through pointers; no, this is not possible. It breaks the strict-aliasing rule. — edmz, Apr 27 '16 at 12:49

fluter · Answer 1 · 2016-04-27T12:49:22.317

3

If you just want 16bits of the larger 32bits type, use bit mask for the task, for example, to get the lower 16 bits of value:

long value = 0xFF00f41a;
long lower = value & 0xFFFF;

To change the lower 16 bits of value, use bit operation:

lower = <some thing new>;
value = (value & 0xFFFF0000) | lower;

Don't use pointer to access part of the 32bit value, it crates undefined bahavior when you dereference it.

edited Apr 27 '16 at 12:49

answered Apr 27 '16 at 12:43

fluter

13,238
8
62
100

yeah but I need change lower and change value of lower – dev.burak Apr 27 '16 at 12:47
@dev.burak to change the lower part again use bitwise and and or. – fluter Apr 27 '16 at 12:49

score 1 · Accepted Answer · edited May 23 '17 at 11:59

Following short example will work, if int is aligned on 4-bytes (which seems to be guaranteed by gcc, see Casting an int pointer to a char ptr and vice versa):

#include <stdio.h>                                                                                                                                                                                             

int main() {                                                                                                                                                                                                   
    int v = 0xcafe;                                                                                                                                                              
    int *ip = &v;                                                                                                                                                                                              
    char *cp = (char*) ip;                                                                                                                                                                                     

    printf("%hhX\n", *cp); // FE on little-endian box                                                                                                                                                                                    
    printf("%hhX\n", *(cp + 1));                                                                                                                                                                               

    *cp = 0xbe;                                                                                                                                                                                                
    *(cp + 1) = 0xba;                                                                                                                                                                                          
    printf("%X\n", *ip);                                                                                                                                                                                       

    return 0;                                                                                                                                                                                                  
}

You can guarantee alignment of int thus:

int main() {                                                                                                                                                                                                   
    __attribute__ ((aligned (4))) int v = 0xcafe;

You are changing part of the integer via a char pointer. This is the bad C habit. — fluter, Apr 27 '16 at 13:15
@fluter according to linked answer, this is well-known to work if int is aligned. — Victor Sorokin, Apr 27 '16 at 13:18

point to low byte address of variable in c

2 Answers2