Compiler Explorer

Source code

#include <cassert>        // assert
#include <cstddef>        // byte, size_t
#include <cstring>        // memcpy
#include <array>          // array
#include <new>            // ::new(void*)
#include <string>         // basic_string
#include <type_traits>    // (lots of stuff)
#include <utility>        // forward, move

#ifndef __clang__
#   define __datasizeof(x) sizeof(x)  // might cause problems with overlapping objects
#endif

template<typename T>
struct _Relocator_Custom { typedef void R; };  // Relocator type is 'void'

namespace std {
template<typename T> requires std::is_same_v< T, std::remove_cvref_t<T> >
class unaligned {
public:
    using value_type = T;
    static constexpr std::size_t alignment = alignof(T);
private:
    std::array<std::byte, __datasizeof(T)> _m_data;
public:
    template<typename D, typename S>
    requires    ((std::is_void_v<D> || std::is_same_v<D,T>)
            && (std::is_void_v<S> || std::is_same_v<S,T>))
    static void unaligned_relocate(D *const d, S *const s) noexcept
    {
        if constexpr ( requires { T::_Relocate(d,s); } )
            { T::_Relocate(d,s); }
        else if constexpr ( requires { T::_Relocate(static_cast<void*>(d),s); } )
            { T::_Relocate(static_cast<void*>(d),s); }
        else if constexpr ( requires { T::_Relocate(d,static_cast<void*>(s)); } )
            { T::_Relocate(d,static_cast<void*>(s)); }
        else if constexpr ( requires{T::_Relocate(static_cast<void*>(d),static_cast<void*>(s));} )
            { T::_Relocate(static_cast<void*>(d),static_cast<void*>(s)); }
        else if constexpr ( !std::is_void_v< typename _Relocator_Custom<T>::R > )
        {
            using R = typename _Relocator_Custom<T>::R;
            if constexpr ( requires { R::relocate(d,s); } )
                { R::relocate(d,s); }
            else if constexpr ( requires { R::relocate(static_cast<void*>(d),s); } )
                { R::relocate(static_cast<void*>(d),s); }
            else if constexpr ( requires { R::relocate(d,static_cast<void*>(s)); } )
                { R::relocate(d,static_cast<void*>(s)); }
            else
                { R::relocate(static_cast<void*>(d),static_cast<void*>(s)); }
        }
        else
        {
            std::memcpy(d,s,__datasizeof(T));
        }
    }
private:
    template<typename Tcv>   // Tcv will be either "T" or "T const"
    class scoped_manipulator_must_align {
        void *const p;
        alignas(T) std::byte buf[ __datasizeof(T) ];
        explicit constexpr scoped_manipulator_must_align(void const *const src) noexcept : p( const_cast<void*>(src) )
        {
            unaligned_relocate( static_cast<T*>(static_cast<void*>(buf)), p);
        }
    public:
        [[nodiscard]] constexpr Tcv &value(void) noexcept { return *static_cast<Tcv*>(static_cast<void*>(buf)); }
        constexpr ~scoped_manipulator_must_align(void) { unaligned_relocate(p, static_cast<T*>(static_cast<void*>(buf))); }
        [[nodiscard]] constexpr auto operator->(void) noexcept
        {
            if constexpr ( std::is_pointer_v<T> ) return static_cast<Tcv&>(*static_cast<Tcv*>(static_cast<void*>(buf)));
            else /******************************/ return static_cast<Tcv*>( static_cast<void*>(buf) );
        }
        scoped_manipulator_must_align(void) = delete;
        scoped_manipulator_must_align(scoped_manipulator_must_align const &) = delete;
        scoped_manipulator_must_align(scoped_manipulator_must_align &&) = delete;
        scoped_manipulator_must_align &operator=(scoped_manipulator_must_align const &) = delete;
        scoped_manipulator_must_align &operator=(scoped_manipulator_must_align &&) = delete;
        scoped_manipulator_must_align const volatile *operator&(void) const volatile = delete;
        template<typename U> void operator,(U&&) = delete;
        friend class unaligned<T>;
    };
    template<typename Tcv>   // Tcv will be either "T" or "T const"
    class scoped_manipulator_no_need_to_align {
        void *const p;
        explicit constexpr scoped_manipulator_no_need_to_align(void const *const src) noexcept : p( const_cast<void*>(src) ) {}
    public:
        [[nodiscard]] constexpr Tcv &value(void) noexcept { return *static_cast<Tcv*>(static_cast<void*>(p)); }
        constexpr ~scoped_manipulator_no_need_to_align(void) = default;
        [[nodiscard]] constexpr auto operator->(void) noexcept
        {
            if constexpr ( std::is_pointer_v<T> ) return static_cast<Tcv&>(*static_cast<Tcv*>(static_cast<void*>(p)));
            else /******************************/ return static_cast<Tcv*>( static_cast<void*>(p) );
        }
        scoped_manipulator_no_need_to_align(void) = delete;
        scoped_manipulator_no_need_to_align(scoped_manipulator_no_need_to_align const &) = delete;
        scoped_manipulator_no_need_to_align(scoped_manipulator_no_need_to_align &&) = delete;
        scoped_manipulator_no_need_to_align &operator=(scoped_manipulator_no_need_to_align const &) = delete;
        scoped_manipulator_no_need_to_align &operator=(scoped_manipulator_no_need_to_align &&) = delete;
        scoped_manipulator_no_need_to_align const volatile *operator&(void) const volatile = delete;
        template<typename U> void operator,(U&&) = delete;
        friend class unaligned<T>;
    };
public:
    template<typename Tcv>    // Tcv is T with CV-qualifiers
    using scoped_manipulator = std::conditional_t< 1u == alignof(Tcv), scoped_manipulator_no_need_to_align<Tcv>, scoped_manipulator_must_align<Tcv> >;
    constexpr unaligned(void) noexcept requires std::is_trivially_constructible_v<T> = default;
    constexpr unaligned(void) noexcept ( noexcept( T() ) ) requires ((1u!=alignof(T)) && std::is_default_constructible_v<T> && !std::is_trivially_constructible_v<T>)
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        ::new(&tmp) T();
        unaligned_relocate(static_cast<void*>(&_m_data.front()), &tmp);
    }
    constexpr unaligned(void) noexcept ( noexcept( T() ) ) requires ((1u==alignof(T)) && std::is_default_constructible_v<T> && !std::is_trivially_constructible_v<T>)
    {
        ::new(&_m_data.front()) T();
    }
    constexpr explicit unaligned(unaligned const&) noexcept requires std::is_trivially_copy_constructible_v<T> = default;
    constexpr explicit unaligned(unaligned const &rhs) noexcept( noexcept( T(rhs.align().value()) ) ) requires ((1u!=alignof(T)) && std::is_copy_constructible_v<T> && !std::is_trivially_copy_constructible_v<T>)
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        ::new(&tmp) T( rhs.align().value() );
        unaligned_relocate(static_cast<void*>(&_m_data.front()), &tmp);
    }
    constexpr explicit unaligned(unaligned const &rhs) noexcept( noexcept( T(rhs.align().value()) ) ) requires ((1u==alignof(T)) && std::is_copy_constructible_v<T> && !std::is_trivially_copy_constructible_v<T>)
    {
        ::new(&_m_data.front()) T( rhs.align().value() );
    }
    constexpr explicit unaligned(unaligned&&) noexcept requires std::is_trivially_move_constructible_v<T> = default;
    constexpr explicit unaligned(unaligned &&rhs) noexcept( noexcept( T(std::move(rhs.align().value())) ) ) requires ((1u!=alignof(T)) && std::is_move_constructible_v<T> && !std::is_trivially_move_constructible_v<T>)
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        ::new(&tmp) T( std::move( rhs.align().value() ) );
        unaligned_relocate(static_cast<void*>(&_m_data.front()), &tmp);
    }
    constexpr explicit unaligned(unaligned &&rhs) noexcept( noexcept( T(std::move(rhs.align().value())) ) ) requires ((1u==alignof(T)) && std::is_move_constructible_v<T> && !std::is_trivially_move_constructible_v<T>)
    {
        ::new(&_m_data.front()) T( std::move( rhs.align().value() ) );
    }
    template<typename... Params>
    requires ((1u!=alignof(T)) && !((1u == sizeof...(Params)) && (std::is_same_v< std::remove_cvref_t<Params>, unaligned > && ...)) )
    constexpr unaligned(Params&& ...args) noexcept( noexcept( T( std::forward<Params>(args)... ) ) )
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        ::new(&tmp) T( std::forward<Params>(args)... );
        unaligned_relocate(static_cast<void*>(&_m_data.front()), &tmp);       
    }
    template<typename... Params>
    requires ((1u==alignof(T)) && !((1u == sizeof...(Params)) && (std::is_same_v< std::remove_cvref_t<Params>, unaligned > && ...)) )
    constexpr explicit unaligned(Params&& ...args) noexcept( noexcept( T( std::forward<Params>(args)... ) ) )
    {
        ::new(&_m_data.front()) T( std::forward<Params>(args)... );      
    }
    constexpr ~unaligned(void) requires   std::is_trivially_destructible_v<T> = default;
    constexpr ~unaligned(void) requires ((1u!=alignof(T)) && !std::is_trivially_destructible_v<T>)
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        unaligned_relocate(&tmp, static_cast<void*>(&_m_data.front()));
        tmp.~T();
    }
    constexpr ~unaligned(void) requires ((1u==alignof(T)) && !std::is_trivially_destructible_v<T>)
    {
        static_cast<T*>(static_cast<void*>(&_m_data.front()))->~T();
    }
    constexpr unaligned &operator=(unaligned const&) noexcept = delete;
    constexpr unaligned &operator=(unaligned const&) noexcept requires std::is_trivially_copy_assignable_v<T> = default;
    constexpr unaligned &operator=(unaligned const &rhs) noexcept( noexcept(std::declval<T&>() = rhs.align().value()) ) 
    requires ((1u!=alignof(T)) && std::is_copy_assignable_v<T> && !std::is_trivially_copy_assignable_v<T>)
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        unaligned_relocate(&tmp, static_cast<void*>(&_m_data.front()));
        tmp = rhs.align().value();
        unaligned_relocate(static_cast<void*>(&_m_data.front()), &tmp);
        return *this;
    }
    constexpr unaligned &operator=(unaligned const &rhs) noexcept( noexcept(std::declval<T&>() = rhs.align().value()) ) 
    requires ((1u==alignof(T)) && std::is_copy_assignable_v<T> && !std::is_trivially_copy_assignable_v<T>)
    {
        *static_cast<T*>(static_cast<void*>(&_m_data.front())) = rhs.align().value();
        return *this;
    }
    constexpr unaligned &operator=(unaligned&&) noexcept requires std::is_trivially_move_assignable_v<T> = default;
    constexpr unaligned &operator=(unaligned &&rhs) noexcept( noexcept(std::declval<T&>() = std::move(rhs.align().value())) ) 
    requires ((1u!=alignof(T)) && std::is_move_assignable_v<T> && !std::is_trivially_move_assignable_v<T>)
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        unaligned_relocate(&tmp, static_cast<void*>(&_m_data.front()));
        tmp = std::move(rhs.align().value());
        unaligned_relocate(static_cast<void*>(&_m_data.front()), &tmp); 
        return *this;
    }
    constexpr unaligned &operator=(unaligned &&rhs) noexcept( noexcept(std::declval<T&>() = std::move(rhs.align().value())) ) 
    requires ((1u==alignof(T)) && std::is_move_assignable_v<T> && !std::is_trivially_move_assignable_v<T>)
    {
        *static_cast<T*>(static_cast<void*>(&_m_data.front())) = std::move(rhs.align().value());
        return *this;
    }
    template<typename Param> requires ( (1u!=alignof(T)) && !std::is_same_v< std::remove_cvref_t<Param>, unaligned > )
    constexpr unaligned &operator=(Param &&arg) noexcept( noexcept( std::declval<T&>() = std::forward<Param>(arg) ) )
    {
        alignas(T) std::byte buf[ __datasizeof(T) ];
        T &tmp = *static_cast<T*>(static_cast<void*>(buf));
        unaligned_relocate(&tmp, static_cast<void*>(&_m_data.front()));
        tmp = std::forward<Param>(arg);
        unaligned_relocate(static_cast<void*>(&_m_data.front()), &tmp);
        return *this;
    }
    template<typename Param> requires ( (1u==alignof(T)) && !std::is_same_v< std::remove_cvref_t<Param>, unaligned > )
    constexpr unaligned &operator=(Param &&arg) noexcept( noexcept( std::declval<T&>() = std::forward<Param>(arg) ) )
    {
        *static_cast<T*>(static_cast<void*>(&_m_data.front())) = std::forward<Param>(arg);
        return *this;
    }
    [[nodiscard]] constexpr scoped_manipulator<T      > align(void)            noexcept { return scoped_manipulator<T      >(this); }
    [[nodiscard]] constexpr scoped_manipulator<T const> align(void)      const noexcept { return scoped_manipulator<T const>(this); }
    [[nodiscard]] constexpr scoped_manipulator<T      > operator->(void)       noexcept { return scoped_manipulator<T      >(this); }
    [[nodiscard]] constexpr scoped_manipulator<T const> operator->(void) const noexcept { return scoped_manipulator<T const>(this); }
};
} // close namespace std

struct super_aligned {
    alignas(4096) std::byte buf[4096];
};

static_assert(alignof(std::unaligned<char>)==1);
static_assert(alignof(std::unaligned<int>)==1);
static_assert(alignof(super_aligned)>=4096);
static_assert(alignof(std::unaligned<super_aligned>)==1);

#include <iostream>    // cout, endl
#include <string>      // string
#include <vector>      // vector

template<typename T>
struct MyRelocatorForBasicString {
    using value_type = T;  
    static void relocate(void *const dst_v, void *const src_v) noexcept // both unaligned
    {
        using std::byte, std::memcpy;

byte *const dst = static_cast<byte*>(dst_v),
             *const src = static_cast<byte*>(src_v);

// Step 1: Copy the bytes
        memcpy(dst, src, __datasizeof(T));

// Step 2: Pluck out the pointer (which might be unaligned)
        //         (The pointer is located at offset 0 from 'this')
        byte *p;
        memcpy(&p, src, sizeof p);

// Step 3: Check if the pointer points to within the object (and if not, return)
        if ( p <   src ) return;
        if ( p >= (src + __datasizeof(T)) ) return;

// Step 4: Adjust the pointer
        p += dst - src;

// Step 5: Store in (possibly unaligned) destination
        memcpy(dst,&p,sizeof p);
    }
};

template<typename T>
struct _Relocator_Custom< std::basic_string<T> > { typedef MyRelocatorForBasicString< std::basic_string<T> > R; };

int main(void)
{
    using std::unaligned;

unaligned< std::string > monkey;

{
        auto alignedmonkeymanipulator = monkey.align();
        std::string &alignedmonkey = alignedmonkeymanipulator.value();
        alignedmonkey += "I have ";
    }

unaligned<std::string > fish;
    fish.align().value() += " five";
    {
        auto alignedfishmanipulator = fish.align();
        alignedfishmanipulator->push_back('(');
        alignedfishmanipulator->push_back('5');
        alignedfishmanipulator->push_back(')');
        std::string const &alignedfish = alignedfishmanipulator.value();
        monkey.align().value() += alignedfish;
    }

fish.align().value() = " axolotls";
    monkey.align().value() += fish.align().value();
    unaligned< std::string > cow( std::move(monkey) );

cow.align().value() += " in a 250L tank.";

std::cout << cow.align().value() << std::endl;

// Check if it works with 'const'
    unaligned< std::string > const &bull = cow;
    std::cout << "Size: " << bull->size() << std::endl;

{ // Now try it with T as a pointer
        auto manipulator = cow.align();
        std::string &val = manipulator.value();
        std::cout << "Size of val: " << val.size() << std::endl;
        unaligned<std::string*> carpet(&val);
        carpet->resize(10u);
        std::cout << "Size of carpet: " << carpet->size() << std::endl;
        std::cout << "Size of carpet: " << carpet.align().value()->size() << std::endl;
    }

std::cout << "Size: " << cow->size() << std::endl;

{ // Now try it with T as a pointer to const
        auto manipulator = cow.align();
        std::string &val = manipulator.value();
        std::cout << "Size of val: " << val.size() << std::endl;
        unaligned<std::string const *> carpet(&val);
        std::cout << "Size of carpet: " << carpet->size() << std::endl;
        std::cout << "Size of carpet: " << carpet.align().value()->size() << std::endl;
    }

// Now let's see if it works with an std::basic_string<char32_t>
    using std::basic_string;
    basic_string<char32_t> a;
    a += 56;
    a += 57;

char unsigned buf1[1u + __datasizeof(a)];
    char unsigned buf2[2u + __datasizeof(a)];
    char unsigned buf3[3u + __datasizeof(a)];

MyRelocatorForBasicString< basic_string<char32_t> >::relocate(buf1 + 1u, &a);
    std::memset(&a, 255, sizeof a);
    MyRelocatorForBasicString< basic_string<char32_t> >::relocate(buf2 + 2u, buf1 + 1u);
    std::memset(buf1, 0, sizeof buf1);
    MyRelocatorForBasicString< basic_string<char32_t> >::relocate(buf3 + 3u, buf2 + 2u);
    std::memset(buf2, 0, sizeof buf2);
    MyRelocatorForBasicString< basic_string<char32_t> >::relocate(&a, buf3 + 3u);

unaligned< std::string > uch, uch2;
    uch  = uch2;
    uch2 = std::move(uch);

unaligned< std::vector<double> > uch3, uch4;
    uch3  = uch4;
    uch4 = std::move(uch3);

// Now let's try treat a pre-existing buffer as an std::unaligned<T>

struct Monkey { int a; long b; char c; };

char buf[1024u] = {};

#if __cpp_lib_start_lifetime_as
    unaligned<Monkey> &m = *std::start_lifetime_as< unaligned<Monkey> >(buf);
#else
    unaligned<Monkey> &m = *static_cast< unaligned<Monkey>* >(static_cast<void*>(buf));
#endif

m->a = 7;

unaligned< std::basic_string<char32_t> > frog1, frog2;

frog1.align().value() += 42;
    frog2 = frog1;
}