// 传统，不建议，可读性差，使用也不方便
void GetName(std::string& name) noexcept {
  name = "UMU";
}

// URVO，C++ 17 开始必然优化
std::string GetName() noexcept {
  return "UMU618";
}

// NRVO, 可选优化，具体来说，以下的写法会优化
std::string GetName() noexcept {
  std::string name("UMU618");
  return name;
}

避坑

没有必要对返回值再加一次 std::move，因为返回本身就已经是 move，再加一次就是多一次没必要的 move。

2021-09-05 18:20:06

UMUTech

现代 C++【2】std::span

前提

多现代？C++ 20。

C++ 17 才有 std::string_view，而相似的 std::span 居然到 C++ 20 才有。

问题

如何解决 C-Style 数组（包含动态分配的连续内存）的退化（array decay）和越界访问（range errors）两大问题？

解决

C 语言解决这两个问题，主要是增加一个长度参数。很多 Win32 API 这样做，例如：

PCSTR WSAAPI inet_ntop(
  INT        Family,
  const VOID *pAddr,
  PSTR       pStringBuf,
  size_t     StringBufSize
);

int GetWindowTextA(
  HWND  hWnd,
  LPSTR lpString,
  int   nMaxCount
);

但它会带来新问题：不小心传错！另外也有一些地方并没有提供长度参数，比如下面 Linux 内核代码里的函数：

1	static inline int ip_decrease_ttl(struct iphdr *iph);

当我们打算把 uint8_t 数组转成 struct iphdr * 时，必须在调用前保证数组长度大于等于最小 IP 头长度。

C++ 的解决方案是：std::span，它是一个连续对象存储的观察者。类似 std::string_view 是 std::string 的观察者。它可以同时管理数组的地址和大小，并且它没有数据所有权，仅占用最多两个指针的空间，可以像 std::string_view 一样在绝大多数时候直接按值传递。

例子

以下函数用于获取 IP 头的长度：

std::uint8_t GetHeaderLength(const void* ip_header, size_t size) noexcept;

std::uint8_t ip[] = {0x45, 0x00, 0x00, 0x54, 0xfa, 0xa6, 0x40, 0x00,
                     0x40, 0x01, 0xb3, 0x9a, 0xc0, 0xa8, 0x0b, 0x02,
                     0xc0, 0xa8, 0x00, 0x15};
std::cout << "HeaderLength: " << (int)GetHeaderLength(ip, sizeof(ip)) << '\n';

它可以用 std::span 包装成：

template <typename T, size_t N>
inline std::uint8_t GetHeaderLength(std::span<T, N> ip_header) noexcept {
  return GetHeaderLength(ip_header.data(), sizeof(T) * ip_header.size());
}

std::cout << "HeaderLength: " << (int)GetHeaderLength(std::span{ip}) << '\n';

另一个便利是，使用 subspan 成员函数可以对其内部指针和长度成对操作，以避免单独处理时可能不小心少处理一个的问题。

避坑

std::span 和 std::string_view 一样，没有数据所有权，所以要担心数据失效问题，不要在数据被释放后使用。

下面是个错误示范，来自：std::string_view encourages use-after-free; the Core Guidelines Checker doesn’t complain #1038

#include <iostream>
#include <string>
#include <string_view>

int main() {
  std::string s = "Hellooooooooooooooo ";
  std::string_view sv = s + "World\n";
  std::cout << sv;
}

2021-08-17 22:49:46

UMUTech

现代 C++【1】类对象作为函数参数

前提

多现代？C++ 17，因为本文内含 std::string_view。

目前 C++ 20 还未普及，CLang 和 GCC 对 C++ 20 不是很上心，【直到今天 2020-08-18】连 std::format 都没有，被 MSVC 甩开。

问题

类对象作为参数究竟应该怎么传？

《Effective C++》的条款 20 说：

宁以 pass-by-reference-to-const 替换 pass-by-value

为什么新规范又建议构造函数 pass-by-value？

原则

只读访问并且不复制时，使用 pass-by-reference-to-const。
需要保存对象副本时，并且对象可移动，使用 pass-by-value。
对象很小时，使用 pass-by-value。

例子

// 只读访问，不需要将 text 保存起来。
void Print(const std::string& text) {
  std::cout << text;
}

class Foo {
 public:
  // 需要保存 message 到类成员变量
  Foo(std::string message) : message_(std::move(message)) {}

 private:
  std::string message_;
};

// std::string_view 很小，连 const 都没必要加，就好像 int 型参数不会加 const
void CallCStyleApi(std::string_view dir) {
  if (0 < dir.size()) {
    chdir(dir.data());
  }
}

说明

Foo 的构造函数使用 pass-by-value，这使得它变成“两用”的，相当于针对这个类对象参数同时实现复制构造函数（ctor）、移动构造函数（mtor）。

当传一个左值给它时，参数 message 是复制的，但它立刻移动给了成员变量 message_，整个过程发生一次复制和一次移动；
当传一个右值给它时，参数 message 是这个右值移动而来的，然后又立刻移动给了成员变量 message_，整个过程发生两次移动；

1
2
3

std::string name("UMU618");
Foo f1(name);  // copy + move
Foo f2(std::move(name)); // move 2 times

如果类实现得妥当，移动两次对象实际上最多可以被编译器优化成零次。