C++ 如何将int的字节复制到char数组中

我正在学习套接字编程，需要将数据从主机字节顺序（在我的例子中是LITTLE ENDIAN）转换为网络字节顺序。所以我需要交换将要发送的数据的字节顺序。所以，我习惯于

std:：memcpy

将整数转换为临时字符数组，然后交换该临时字符数组的字节。但现在我正试图使用

std:：reverse\u copy

实现同样的功能，但无法实现（不是编译本身）。这是我的示例代码：

#include <iostream>
#include <cstring>
#include <algorithm>

int main()
{
    const int a = 0x89ABCDEF;
    char arr[sizeof(decltype(a))] {};
    char r_arr[sizeof(decltype(a))] {};
    
    std::memcpy(arr, reinterpret_cast<const char*>(&a), sizeof(decltype(a)));
    char *start = arr;
    char *end = arr + sizeof(decltype(a)) - 1;
    while (start < end) {
        char temp = *start;
        *start = *end;
        *end = temp;
        
        ++start;
        --end;
    }
    for (int32_t i = 0; i < sizeof(decltype(a)); ++i)
        std::cout << std::hex << static_cast<uint16_t>(arr[i]) << std::endl;
    
    // error in below line
    // std::reverse_copy(std::begin(reinterpret_cast<const char*>(&a)), std::begin(reinterpret_cast<const char*>(&a)) + sizeof(decltype(a)), std::begin(r_arr));
    for (int32_t i = 0; i < sizeof(decltype(a)); ++i)
        std::cout << std::hex << static_cast<uint16_t>(r_arr[i]) << std::endl;
        
    return 0;
}

#包括
#包括
#包括
int main（）
{
常数int a=0x89ABCDEF；
char arr[sizeof（decltype（a））]{}；
字符r_arr[sizeof（decltype（a））]{}；
标准：memcpy（arr，reinterpret_cast&a），sizeof（decltype（a））；
char*start=arr；
char*end=arr+sizeof（decltype（a））-1；
while（开始<结束）{
字符温度=*开始；
*开始=*结束；
*结束=温度；
++开始；
--结束；
}
对于（int32_t i=0；istd:：cout您对
std:：begin
的调用太多。您只需要：

std::reverse_copy(reinterpret_cast<const char*>(&a), reinterpret_cast<const char*>(&a) + sizeof(decltype(a)), r_arr);

std：：反向复制（重新解释类型（&a）、重新解释类型（&a）+sizeof（decltype（a）），r\u arr；
这需要一个类型转换视图，既可以在基于C++20范围的代码中使用，也可以在基于迭代器的C++20之前的代码中使用。这样，您就不需要处理临时字符缓冲区等

#include <algorithm>

template <typename Src>
class const_char_view_t {
    const Src &src;
public:
    explicit const_char_view_t(const Src &src) : src(src) {}
    const char * begin() const noexcept {
        return reinterpret_cast<const char*>(&src);
    }
    const char * end() const noexcept { 
        return reinterpret_cast<const char*>((&src)+1);
    }
};

template <typename Src>
auto const_char_view(const Src &val) {
    return const_char_view_t<Src>(val);
}

template <typename Out>
class tie_out_adapter_t {
    Out &out;
public:
    explicit tie_out_adapter_t(Out &out) : out(out) {}
    template <typename Src>
    Out &operator=(Src &&src) {
        return (out = std::move(src.out));
    }
};
template <typename Out>
auto tie_out(Out && out) { return tie_out_adapter_t(out); }

请在
std:：reverse\u copy..
前面张贴实际有错误的代码（即没有
/
）和错误消息
#include <cassert>
#include <iterator>
#include <vector>
#ifdef __has_include
#   if __has_include(<version>)
#   include <version>
#       if __cpp_lib_ranges >= 201911L
#       define HAS_RANGES 1
#       endif
#   endif
#endif

int main() {
    int32_t val_1 = 0x01234567;
    int16_t val_2 = 0x89AB;
    const char copy_expected[4+2] = {'\x01','\x23','\x45','\x67','\x89','\xAB'};

    #if HAS_RANGES
    {
        std::vector<char> copy;
        auto out = std::back_inserter(copy);
        tie_out(out) = std::ranges::reverse_copy(const_char_view(val_1), out);
        tie_out(out) = std::ranges::reverse_copy(const_char_view(val_2), out);
        assert(std::ranges::equal(copy, copy_expected));
        copy.clear();
    }
    #endif

    std::vector<char> copy;
    auto out = std::back_inserter(copy);
    out = std::reverse_copy(cchar_begin(val_1), cchar_end(val_1), out);
    out = std::reverse_copy(cchar_begin(val_2), cchar_end(val_2), out);
    assert(std::equal(std::begin(copy), std::end(copy), std::begin(copy_expected)));
}