C++ 将字符串数据附加到std:：vector<；std:：byte>&燃气轮机；

我正在实现一个HTTP服务器，我遵循的API将原始响应数据定义为

std:：vector>

在代码中，我将http响应头存储为

std:：string

，在返回之前，我必须将它们写入原始响应数据

问题是，我找不到一种干净的方法将数据从

std:：string

写入/追加到我的

std:：vector>

（所谓干净的方法，我的意思是不在字符串上循环并追加每个字符）

最好的方法是什么

---

旁白：从

std:：vector>

读取字符串的最佳方式是什么？

您将需要以下内容。我意识到这仍然使用复制，但只有一个内存分配，这是昂贵的部分

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:：矢量数据；
std：：字符串输入；
...
data.reserve（data.size（）+input.size（））；
std:：copy（input.begin（）、input.end（）、std:：back_插入器（数据））；

无法将

字符

do转换为。其定义为作用域枚举：

enum class byte : unsigned char {} ;

由于C++17宽松的枚举类初始化规则，可以使用

std:：byte{n}

将数值

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)`
);  

实际上，编译器将对整个过程进行优化，使其类似于

std:：copy

---

或者只需将

std:：byte

替换为

char

并使用

std:：vector:：insert（）

或

std:：copy（）

void扩展（std:：vector&v，std:：string const&s）{
自动字节=重新解释转换（s.data（））；
v、 插入（v.end（），bytes，bytes+s.size（））；
}

您可以将
char
读取为
byte
，这是一个允许的别名
 首先从一个
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) {}
};

这假设您不想使用迭代器在末尾嵌入
“\0”
？要创建字符串，也要使用迭代器（使用迭代器对）？@Someprogrammerdude不确定我是否理解您的意思。像这样的std:：string rr=“http/1.1”；std:：vector>raw；插入（raw.begin（），rr.begin（），rr.end（））`不适用于C++17:）
char
不适用于
std:：byte
std:：transform（headers.begin（）、headers.end（）、std:：back_inserter（response），[]（char C）{return std:：byte（C）；}）其中lambda是
encode（）
。这不会编译：/
错误：与“operator=”不匹配（操作数类型为“std:：back\u insert\u iterator”和“const char”）
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());
}

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) {}
};

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;
}