How is it possible to safely copy an int into a byte array unaligned?

Question

I created a byte array, uint8_t data[256], and I would like to read and write data to it at arbitrary positions. The position offset could be any number, so it could result in an unaligned access. For example if sizeof(int32_t) == 4 then position % sizeof(int32_t) != 0

It works now but, as far as I know, some platforms do not directly support unaligned access. I would like to make it work in that case as well.

#include <cstdint>
#include <iostream>

void write(uint8_t* data, uint32_t position, int32_t value) {
    int32_t* ptr = reinterpret_cast<int32_t*>(&data[position]);
    
    *ptr = value;
}

int32_t read(uint8_t* data, uint32_t position) {
    int32_t* ptr = reinterpret_cast<int32_t*>(&data[position]);
    
    return *ptr;
}

int main()
{
    uint8_t data[256];
    int32_t value = 123456789;
    uint32_t position = 1; // Example for unaligned access

    write(data, position, value);
    
    int32_t read_value = read(data, position);
    
    std::cout << read_value << std::endl;

    return 0;
}

I prefer to use the standard library, if there is a solution there for this problem.

Use std::memcpy to copy the bytes into an int32_t result;, then return that result. — Eljay
– Eljay, Commented Nov 27, 2021 at 20:55

Quimby · Accepted Answer · 2021-11-27 20:55:36Z

2

I see no placement new in your code, making both reinterpret_casts undefined behaviour. The returned pointer can only be dereferenced if at the given address exists an object of the specified type. With exception of char, std::byte, unsigned char which can always be dereferenced.

The safe way how to serialize and deserialize objects is through std::memcpy:

void write(unsigned char* data, uint32_t position, int32_t value) {
   
    std::memcpy(data+position,&value,sizeof(value));
}

int32_t read(unsigned char* data, uint32_t position) { 
    int32_t result;
    std::memcpy(&result,data+position,sizeof(result));
    return result;
}

This also solves any aligment issues.

answered Nov 27, 2021 at 20:55

Quimby

19.4k4 gold badges40 silver badges61 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

MSalters Over a year ago

Correct. Modern compilers (at least in optimized builds) should recognize what happens here. E.g. godbolt.org/z/7r9ePfT9c - x64 doesn't have a problem with unaligned access,, so it just loads the int.

Adrian Mole · Accepted Answer · 2021-11-27 21:04:52Z

1

To avoid possible issues of violating strict aliasing rules, you can use the std::memcpy function:

#include <cstring> // For std::memcpy

void write(uint8_t* data, uint32_t position, int32_t value)
{
    std::memcpy(&data[position], &value, sizeof(value));
}

int32_t read(uint8_t* data, uint32_t position)
{
    int answer;
    std::memcpy(&answer, &data[position], sizeof(answer));
    return answer;
}

From the (second) linked cppreference page:

Where strict aliasing prohibits examining the same memory as values of two different types, std::memcpy may be used to convert the values.

edited Nov 27, 2021 at 21:04

answered Nov 27, 2021 at 20:59

Adrian Mole

52.1k193 gold badges61 silver badges101 bronze badges

Collectives™ on Stack Overflow

How is it possible to safely copy an int into a byte array unaligned?

2 Answers 2

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related