Question

我正在实施一个HTTP服务器，我所遵循的API将原始响应数据定义为std::vector<std::byte>>。

我在我的代码中将http响应标头存储为std::string，在某些时候我必须将它们写入原始响应数据，然后再发回。

问题是，我找不到一种干净的方法来编写/追加从std::string到我的std::vector<std::byte>>的数据（通过干净的方式，我的意思是不在字符串上循环并附加每个字符）。 / p>

最好的方法是什么？

附带问题：从std::vector<std::byte>>读取字符串的最佳方式是什么？

Answer 1

char无法转换为std::byte c++17。它定义为作用域枚举：

enum class byte : unsigned char {} ;

cppreference.com std::byte

由于C ++ 17宽松的枚举类初始化规则，可以使用n将数值std::byte{n}转换为字节值。

你可以做的是使用辅助函数或lambda：

std::string headers;
std::vector<std::byte> response;

response.reserve(response.size() + headers.size());  // Optional
std::transform(headers.begin(), headers.end(), std::back_inserter(response),
    [](unsigned char c) { return std::byte{c}; }              // or `encode(c)`
);

您还可以调整response的大小并跳过back_inserter：

const auto response_size = response.size();
response.resize(response_size + headers.size());
std::transform(headers.begin(), headers.end(), std::next(response.begin(), response_size),
    [](unsigned char c) { return std::byte{c}; }
);

实际上编译器会将整体优化为std::copy。

或者只需将std::byte替换为char，然后使用std::vector::insert()或std::copy()。

Answer 2

只需使用远程 - insert重载（#4）：

void extend(std::vector<std::byte>& v, std::string const& s) {
    auto bytes = reinterpret_cast<std::byte const*>(s.data());
    v.insert(v.end(), bytes, bytes + s.size());
}

您可以将char视为byte，它是允许的别名。

Answer 3

首先以gsl::span或类似的方式开始。

template<class T>
struct span {
  T* b =0, *e = 0;
  T* begin() const { return b; }
  T* end() const { return e; }
  std::size_t size() const { return end()-begin(); }
  bool empty() const { return end()==begin(); }
  span( T* s, T* f ):b(s),e(f) {}
  span( T* s, std::size_t len ):span(s, s+len) {}

  template<class Uptr>
  using is_compatible = std::is_convertible< Uptr*, T* >;

  template<class R,
    std::enable_if_t<!std::is_same<std::decay_t<R>, span>{}, bool> = true,
    std::enable_if_t<is_compatible<decltype(std::declval<R&>().data())>{}, bool> = true
  >
  span( R&& r ):
    span(r.data(), r.size())
  {}
  template<class U, std::size_t N,
    std::enable_if_t<is_compatible<U*>{}, bool> = true
  >
  span( U(&arr)[N] ):span(arr, N) {}
};

现在我们有一个抽象的“可能可变的视图到连续的T s”。

std::vector<std::byte> concat_string( std::vector<std::byte> lhs, span<char const> rhs ) {
  lhs.reserve(lhs.size()+rhs.size());
  lhs.insert( lhs.end(), (std::byte const*)rhs.begin(), (std::byte const*)rhs.end() );
  return rhs;
}

这假设您不想嵌入'\0'。

Answer 4

你想要的东西如下。我意识到这仍然使用副本，但只有一个内存分配是昂贵的部分。

std::vector<std::byte> data;
std::string input;
...
data.reserve(data.size() + input.size());
std::copy(input.begin(), input.end(), std::back_inserter(data));

将字符串数据附加到std :: vector <std :: byte>＆gt;

4 个答案:

cppreference.com std::byte