F: Functions

F.1 “Package” meaningful operations as carefully named functions

这段很令人期待，但是看过以后感觉什么都没说。
如何算作“meaningful operations”什么样算是“carefully named”。在实际操作过程中，经常遇到一个函数的长度超出一个显示器范围的情况，一般我认为这时可能会需要将这个函数分解为多个小段，然后每个小段负责执行一部分功能。但是这么做并不能产生能够重用的代码，而且有时候需要将参数不断地来回传递。确实不知道应当如何判断什么时候不应当写多个小函数而是使用一个相对较长的函数。

F.2 A function should perform a single logical operation

本段我理解即是追求函数短小并且参数化（模板化）。以前多数时候，写一个函数只有两个原因：（1）我知道这个段代码会被重用，所以写一个函数。（2）我感觉函数太长了，将一部分连续的代码复制出来，写好参数表，形成了一个不能复用的函数。对于情况（2），就有可能出现不符合“single logical operation”和parameterization的情况。那么解决方法是什么呢？此段并没有给出明确方案。所给出的实例侧重parameterization，但是具体如何定义“single logical operation”并没有特别好的例子。在本段最后，作者提出几个应当引起注意的现象：（1）使用多于一个输出参数的函数可能是不好的。（2）函数长度超出一个屏幕是不好的。（3）函数参数超过7个是不好的（这个和之前说的4个参数有点不一致，但是意思一样）。

F.3 Keep functions short and simple

本段特意列举了一个具有复杂控制逻辑的函数。示例中将顶层if语句的分支都写成了函数，然后将参数传递进去。这个过程和我在F.1和F.2中讨论的一样，并没有更具体的指导。
本段最后又给出标志函数过长的判据，即函数超过一个屏幕，函数超过5行。我有时函数光声明就可能7-8行（带有类模板和函数模板，参数列表里参数类型有derived类型，需要const和typename这种和namespace这种）。就算把这些参数encapsulate成一个struct，struct的定义也会有这么长，感觉只是转嫁了参数列表的负担到一个抽象过程中去了。这是意味着什么？本段后面指出一个屏幕长度可理解为60行，这个倒是还有实际操作的可能性。
文中特别指出，写了小函数，有可能需要进行inline，这样调用函数的overhead能够得到缓解。参考F.5。

F.4 If a function may have be evaluated at compile time, declare it constexpr

如题，只是编译器不能确保函数的evaluation发生在编译过程。
注意，constexpr隐含了inline。

F.5 If a function is very small and time-critical, declare it inline

如题。。
不要inline大函数。
不要inline定义在类外部的成员函数。所以，想要成员函数inline，就直接在类定义里写，这样也不用加inline关键字。

F.6 If your function may not throw, declare it noexcept

如题，对于非常可能不抛出异常的函数，告诉编译器它不抛出异常。感觉是为了提高运行效率。如何知道自己调用的函数不抛出异常？本段没有给出方法，但是感觉作者的意思是只要我们自己的代码不显式处理内存耗尽的异常，就可以declare成noexcept的，即使我们知道我们滴调用的函数会抛出其他异常。

对于low-level函数，并且经常调用的函数，可以声明为noexcept。

特别注意：析构函数，swap函数，move operations，默认构造函数都不应该抛出异常。没有特别给出示例，同时感觉也有点难遵守。尤其构造函数调用其他可能抛出异常的函数的情况。这就要求我们在构造函数内不进行特殊的操作。而把特殊操作变成public成员函数。

F.7 For general use, take T* or T& arguments rather than smart poitners

啊哈，好多PCL函数都是接受shared_ptr<>为参数的。于是我也跟着这么做的，但是真心发现不太对劲儿。后来感觉直接是指针的也行。

F.8 Prefer pure functions

这段有意思，看代码

template<class T>
auto square(T t) { return t * t; }

为什么写成函数要比写成乘法好？为什么不加inline?

F.15 Prefer simple and conventional ways of passing information

对于expensive的，都用引用。F.16
什么是expensive to move的？

F.16 For “in” parameters, pass cheaply-copied types by value and others by reference to const

对于很小的数据，复制参数比引用参数可能还快，原因是引用参数总是需要通过一个中间变量完成引用，而直接复制的参数就不需要中间变量了。

使用指针作为参数来表示该参数是optional的，C++提供了std::optional，但是暂时不知道如何使用。看C++文档也没有太理解。

F.20 For “out” output values, prefer return values to output parameters

用返回值，而不是用引用参数向函数外传递信息。当有多个信息需要传递时，使用tuple。C++17或之后食用最佳！下述代码来自于这里。

#include <tuple>
#include <iostream>
#include <string>
#include <stdexcept>std::tuple<double, char, std::string> get_student(int id)
{if (id == 0) return std::make_tuple(3.8, 'A', "Lisa Simpson");if (id == 1) return std::make_tuple(2.9, 'C', "Milhouse Van Houten");if (id == 2) return std::make_tuple(1.7, 'D', "Ralph Wiggum");throw std::invalid_argument("id");
}int main()
{auto student0 = get_student(0);std::cout << "ID: 0, "<< "GPA: " << std::get<0>(student0) << ", "<< "grade: " << std::get<1>(student0) << ", "<< "name: " << std::get<2>(student0) << '\n';double gpa1;char grade1;std::string name1;std::tie(gpa1, grade1, name1) = get_student(1);std::cout << "ID: 1, "<< "GPA: " << gpa1 << ", "<< "grade: " << grade1 << ", "<< "name: " << name1 << '\n';// C++17 structured binding:auto [ gpa2, grade2, name2 ] = get_student(2);std::cout << "ID: 2, "<< "GPA: " << gpa2 << ", "<< "grade: " << grade2 << ", "<< "name: " << name2 << '\n';
}

不是很确定的是使用tuple作为返回值会不会自动进行move。

F.21 To return multiple “out” values, prefer returning a struct or tuple

我感觉最有用的建议是如果返回值是一个抽象，那么应该是struct。如果返回值不是一个抽象，例如返回一个数值和一个状态标志，那么应该使用tuple或者C++17的“structured bindings”（就是auto [ <variable0>, <variable1> ] = function();）。

F.23 Use a not_null<T> to indicate that “null” is not a valid value

这个好。

之后的几个话题感觉平时都很少遇见。例如不要返回局部变量的引用等。

F.45 Don’t return a T&&

如题。

F.46 int is the return type for main()

来自作者的执念？但是平时我都是写int main()。

F.47 Return T& from assignment operators

特殊指出当operator=返回T&而不是const T&时，(a = b) = c这样的情况可能导致错误。但是这种情况很少，所以还是推荐返回T&。

F.50 Use a lambda when a function won’t do (to capture local variables, or to write a local function)

说实话不知道什么时候该用lambda。为什么需要local function。感觉如果一段代码如果从原函数里分离出来，只有一行，但要好多参数，并且这一行还重复出现，那么就是lambda上场的时候。

F.51 Where there is a choice, prefer default argument over overloading

如题。能用默认参数解决的就不要用overloading。

F.52 Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms

作者指出，这几乎是最常见的选择。
作者指出，join before returning的并发，使用lambda时也可以用capturing by reference。
示例显示，与for_each结合时，可以使用lambda，感觉像python了。

std::for_each(begin(sockets), end(sockets), [&message](auto& socket)
{socket.send(message);
});

上述示例本来是为了说明如果不capture by referece，那么就会产生无谓的copy。

F.53 Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another thread

和返回局部变量的引用情况相似。

F.54 If you capture this, capture all variables explicitly

class My_class {int x = 0;// ...void f() {int i = 0;// ...auto lambda = [=]{ use(i, x); };   // BAD: "looks like" copy/value capture// [&] has identical semantics and copies the this pointer under the current rules// [=,this] and [&,this] are not much better, and confusingx = 42;lambda(); // calls use(0, 42);x = 43;lambda(); // calls use(0, 43);// ...auto lambda2 = [i, this]{ use(i, x); }; // ok, most explicit and least confusing// ...}
};

作者说这里可能会在后期的C++标准化中发生改变。