uint32_t pointer to the same location as uint8_t pointer

Question

#include <iostream>

int main(){
    uint8_t memory[1024];
    memory[0] = 1;
    memory[1] = 1;
    uint32_t *test = memory;
    //is it possible to get a value for *test that would be in this example 257?
}

I want to create a uin32_t pointer to the same adress as the uint8_t pointer. Is this possible without using new(adress)? I don't want to lose the information at the adress. I know pointers are just adresses and therefor I should be able to just set the uint32_t pointer to the same adress.
This code produces an error:

invalid conversion from 'uint8_t*' to 'uint32_t*' in initialization

do you mean you want something like `uint_t test=memory[0]`; but for an array? — UKMonkey, Jun 06 '18 at 14:06
I would be afraid of breaking the strict aliasing rule, but I should mention that I never fully understood that rule — 463035818_is_not_an_ai, Jun 06 '18 at 14:08
@JoshDetwiler [That won't work.](https://godbolt.org/g/N7PKUJ) — Max Langhof, Jun 06 '18 at 14:08
@user463035818 `uint8_t` is most probably an alias to `unsigned char` so aliasing rule should be fine — Slava, Jun 06 '18 at 14:09
@Slava even if it was `unsigned char` instead of `std::uint8_t`, this would still violate the strict aliasing rule. Only if memory was being accessed via a `char` / `unsigned char` pointer would this be okay (other way round to what's happening in this question). — Candy Gumdrop, Jun 06 '18 at 14:14
@Slava, nope, since it is a char* which can alias everything, not the other way around. — SergeyA, Jun 06 '18 at 14:14

score 5 · Answer 1 · edited Jun 06 '18 at 14:22

5

This would be a violation of so-called Strict Aliasing Rule, so it can not be done. Sad, but true.

Use memcpy to copy data and in many cases compilers will optimize memory copy and generate the same code as they would with cast, but in Standard-conforming way.

edited Jun 06 '18 at 14:22

acraig5075

10,588
3
31
50

answered Jun 06 '18 at 14:13

SergeyA

61,605
5
78
137

Some compilers offer options to disable the strict aliasing rule, like -fno_strict_aliasing. (But in most cases it does not make sense to use them IMHO). – alain Jun 06 '18 at 14:26
@alain disabling this is often a terrible pessimization – SergeyA Jun 06 '18 at 14:28
Yes, I agree. The only use case I see is if you have a very large legacy code base that you're unwilling to change at the moment. – alain Jun 06 '18 at 14:30

Slava · Answer 2 · 2018-06-06T14:37:11.197

4

As already mentioned you cannot convert uint8_t * to uint32_t * due to strict aliasing rule, you can convert uint32_t * to unsigned char * though:

#include <iostream>

int main(){
    uint32_t test[1024/4] = {}; // initialize it!
    auto memory = reinterpret_cast<unsigned char *>( test );
    memory[0] = 1;
    memory[1] = 1;
    std::cout << test[0] << std::endl;
}

this is not portable code due to Endianness, but at least it does not have UB.

edited Jun 06 '18 at 14:37

answered Jun 06 '18 at 14:31

Slava

43,454
1
47
90

You might as well explain why it is not portable (not evident for everyone, I suppose) – SergeyA Jun 06 '18 at 14:34
It could be noted that `uintxx_t` types *when they exist* are required to have exactly xx bits and **no padding bits**. So if that code is compiled, the result is implementation defined because of endianness, but no UB is involved and no trap representation is possible. Simply, an implementation is free to not define the `uintxx_t` types... – Serge Ballesta Jun 06 '18 at 15:19

score 0 · Answer 3 · answered Jun 06 '18 at 14:18

0

This question completely ignores the concept of endian-ness; while your example has the lower and upper byte the same value, if the byte order is swapped it makes no difference; but in the case where it is; your number will be wrong unexpectedly.

As such, there's no portable way to use the resulting number.

answered Jun 06 '18 at 14:18

UKMonkey

6,941
3
21
30

Aside endianness `uint32_t` is 4 bytes, OP assigns only 2. I would see that as bigger problem here. – Slava Jun 06 '18 at 14:19
1

@Slava well, if you're going to dance with UB, in for a penny in for a pound. Next step, assign threads to play with it – UKMonkey Jun 06 '18 at 14:20
You started it first – Slava Jun 06 '18 at 14:21

Krzysiek · Answer 4 · 2021-04-06T12:26:12.043

You can do that with union. As mentioned above, you have to be aware of endianness of target device, but in most cases it will be little-endian. And there is also a bit of controversy about using unions in such way, but fwiw it's getting a job done and for some uses it's good enough.

#include <iostream>

int main(){
    union {
        uint8_t memory[1024] = {};
        uint32_t test[1024/4];
    };
    
    memory[0] = 1;
    memory[1] = 1;
    std::cout << test[0]; // 257
}

score -3 · Answer 5 · answered Jun 06 '18 at 14:23

-3

uint32_t *test =(uint32_t*) memory;

uint32_t shows that the memory pointed by test should contain uint32_t .

answered Jun 06 '18 at 14:23

Vishnu R

94
5

This is even worse than `reinterpret_cast` which already explained why it is wrong to do it. – Slava Jun 06 '18 at 14:24

uint32_t pointer to the same location as uint8_t pointer

5 Answers5