对于一些collection(vector,list,set,map)可以对其中每个元素执行后面的函数;

auto lambda_echo = [](int i ) { std::cout << i << std::endl; };  
std::vector<int> col{20,24,37,42,23,45,37};
for_each(col,lambda_echo);

2. Transform

std::transform在指定的范围内应用于给定的操作，并将结果存储在指定的另一个范围内。要使用std::transform函数需要包含头文件。

以下是std::transform的两个声明，一个是对应于一元操作，一个是对应于二元操作：

template <class InputIterator, class OutputIterator, class UnaryOperation>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperation op);
	
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class BinaryOperation>
  OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, OutputIterator result,

对于一元操作，将op应用于[first1, last1)范围内的每个元素，并将每个操作返回的值存储在以result开头的范围内。给定的op将被连续调用last1-first1次。op可以是函数指针或函数对象或lambda表达式。

int op_increase(int i) {return (i + 5)};
std::transform(first1, last1, result, op_increase);

3. auto和decltype联合使用

考虑一个模板函数

template<typename U, typename V>
??? foo(U u, V v){
    ...
    return u*v;
}

总之我要在这个函数做点事情，最后返回一个u*v类型的东西。返回类型该怎么写？ C++11引入了返回类型后置解决这个问题，

template<typename U, typename V>
auto foo(U u, V v) -> decltype(u*v){
    return u*v;
}

4.枚举类

枚举类（“新的枚举”/“强类型的枚举”）主要用来解决传统的C++枚举的三个问题：

• 传统C++枚举会被隐式转换为int，这在那些不应被转换为int的情况下可能导致错误
• 传统C++枚举的每一枚举值在其作用域范围内都是可见的，容易导致名称冲突(同名冲突)
• 不可以指定枚举的底层数据类型，这可能会导致代码不容易理解、兼容性问题以及不可以进行前向声明

枚举类（enum）（“强类型枚举”）是强类型的，并且具有类域：

enum Alert { green, yellow, election, red }; // 传统枚举
enum class Color { red, blue };   // 新的具有类域和强类型的枚举类
// 它的枚举值在类的外部是不可直接访问的，需加“类名::”
//  不会被隐式转换成int
enum class TrafficLight { red, yellow, green };
Alert a = 7;   //  错误，传统枚举不是强类型的，a没有数据类型
Color c = 7;   // 错误，没有int到Color的隐式转换
int a2 = red;  // 正确，Alert被隐式转换成int
// 在 C++98中是错误的，但是在C++11中正确的
int a3 = Alert::red;
int a4 = blue;            // 错误，blue并没有在类域中
int a5 = Color::blue; // 错误，没有Color到int的默认转换
Color a6 = Color::blue;   // 正确

正如上面的代码所展示的那样，传统的枚举可以照常工作，但是你现在可以通过提供一个类名来改善枚举的使用，使其成为一个强类型的具有类域的枚举。 同时，他可以保证枚举值所占的字节大小，枚举类的底层数据类型必须是有符号或无符号的整数类型(int/short/char等)，默认情况下是int。

enum class Color : char { red, blue }; // 紧凑型表示(一个字节)

5. 类型转换

关于强制类型转换的问题，很多书都讨论过，写的最详细的是C++ 之父的《C++ 的设计和演化》。最好的解决方法就是不要使用C风格的强制类型转换，而是使用标准C++的类型转换符：static_cast, dynamic_cast。 标准C++中有四个类型转换符：static_cast、dynamic_cast、reinterpret_cast、 const_cast。

本文曾发表于《程序员》2015年2月刊。转载请注明出处。

1概述

C++11的新特性–可变模版参数（variadic templates）是C++11新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以它也是C++11中最难理解和掌握的特性之一。虽然掌握可变模版参数有一定难度，但是它却是C++11中最有意思的一个特性，本文希望带领读者由浅入深的认识和掌握这一特性，同时也会通过一些实例来展示可变参数模版的一些用法。

2可变模版参数的展开

可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号“…”。比如我们常常这样声明一个可变模版参数：template或者template，一个典型的可变模版参数的定义是这样的：

template <class... T>
void f(T... args);

　　上面的可变模版参数的定义当中，省略号的作用有两个： 1.声明一个参数包T… args，这个参数包中可以包含0到任意个模板参数； 2.在模板定义的右边，可以将参数包展开成一个一个独立的参数。

　　上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。

　　可变模版参数和普通的模版参数语义是一致的，所以可以应用于函数和类，即可变模版参数函数和可变模版参数类，然而，模版函数不支持偏特化，所以可变模版参数函数和可变模版参数类展开可变模版参数的方法还不尽相同，下面我们来分别看看他们展开可变模版参数的方法。

2.1可变模版参数函数

一个简单的可变模版参数函数：

template <class... T>
void f(T... args)
{    
    cout << sizeof...(args) << endl; //打印变参的个数
}

f();        //0
f(1, 2);    //2
f(1, 2.5, "");    //3

上面的例子中，f()没有传入参数，所以参数包为空，输出的size为0，后面两次调用分别传入两个和三个参数，故输出的size分别为2和3。由于可变模版参数的类型和个数是不固定的，所以我们可以传任意类型和个数的参数给函数f。这个例子只是简单的将可变模版参数的个数打印出来，如果我们需要将参数包中的每个参数打印出来的话就需要通过一些方法了。展开可变模版参数函数的方法一般有两种：一种是通过递归函数来展开参数包，另外一种是通过逗号表达式来展开参数包。下面来看看如何用这两种方法来展开参数包。

2.1.1递归函数方式展开参数包

通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数，递归终止函数正是用来终止递归的，来看看下面的例子。

#include <iostream>
using namespace std;
//递归终止函数
void print()
{
   cout << "empty" << endl;
}
//展开函数
template <class T, class ...Args>
void print(T head, Args... rest)
{
   cout << "parameter " << head << endl;
   print(rest...);
}


int main(void)
{
   print(1,2,3,4);
   return 0;
}

上例会输出每一个参数，直到为空时输出empty。展开参数包的函数有两个，一个是递归函数，另外一个是递归终止函数，参数包Args…在展开的过程中递归调用自己，每调用一次参数包中的参数就会少一个，直到所有的参数都展开为止，当没有参数时，则调用非模板函数print终止递归过程。

递归调用的过程是这样的:

print(1,2,3,4);
print(2,3,4);
print(3,4);
print(4);
print();

上面的递归终止函数还可以写成这样：

template <class T>
void print(T t)
{
   cout << t << endl;
}

修改递归终止函数后，上例中的调用过程是这样的：

print(1,2,3,4);
print(2,3,4);
print(3,4);
print(4);

当参数包展开到最后一个参数时递归为止。再看一个通过可变模版参数求和的例子：

template<typename T>
T sum(T t)
{
    return t;
}
template<typename T, typename ... Types>
T sum (T first, Types ... rest)
{
    return first + sum<T>(rest...);
}

sum(1,2,3,4); //10

sum在展开参数包的过程中将各个参数相加求和，参数的展开方式和前面的打印参数包的方式是一样的。

2.1.2逗号表达式展开参数包

递归函数展开参数包是一种标准做法，也比较好理解，但也有一个缺点,就是必须要一个重载的递归终止函数，即必须要有一个同名的终止函数来终止递归，这样可能会感觉稍有不便。有没有一种更简单的方式呢？其实还有一种方法可以不通过递归方式来展开参数包，这种方式需要借助逗号表达式和初始化列表。比如前面print的例子可以改成这样：

template <class T>
void printarg(T t)
{
   cout << t << endl;
}

template <class ...Args>
void expand(Args... args)
{
   int arr[] = {(printarg(args), 0)...};
}

expand(1,2,3,4);

这个例子将分别打印出1,2,3,4四个数字。这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式，比如：

d = (a = b, c); 

这个表达式会按顺序执行：b会先赋值给a，接着括号中的逗号表达式返回c的值，因此d将等于c。

expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。我们可以把上面的例子再进一步改进一下，将函数作为参数，就可以支持lambda表达式了，从而可以少写一个递归终止函数了，具体代码如下：

template<class F, class... Args>void expand(const F& f, Args&&...args) 
{
  //这里用到了完美转发，关于完美转发，读者可以参考笔者在上一期程序员中的文章《通过4行代码看右值引用》
  initializer_list<int>{(f(std::forward< Args>(args)),0)...};
}
expand([](int i){cout<<i<<endl;}, 1,2,3);

上面的例子将打印出每个参数，这里如果再使用C++14的新特性泛型lambda表达式的话，可以写更泛化的lambda表达式了：

expand([](auto i){cout<<i<<endl;}, 1,2.0,”test”);

2.2可变模版参数类

可变参数模板类是一个带可变模板参数的模板类，比如C++11中的元祖std::tuple就是一个可变模板类，它的定义如下：

template< class... Types >
class tuple;

这个可变参数模板类可以携带任意类型任意个数的模板参数：

std::tuple<int> tp1 = std::make_tuple(1);
std::tuple<int, double> tp2 = std::make_tuple(1, 2.5);
std::tuple<int, double, string> tp3 = std::make_tuple(1, 2.5, “”);

可变参数模板的模板参数个数可以为0个，所以下面的定义也是也是合法的：

std::tuple<> tp;

可变参数模板类的参数包展开的方式和可变参数模板函数的展开方式不同，可变参数模板类的参数包展开需要通过模板特化和继承方式去展开，展开方式比可变参数模板函数要复杂。下面我们来看一下展开可变模版参数类中的参数包的方法。

2.2.1模版偏特化和递归方式来展开参数包

可变参数模板类的展开一般需要定义两到三个类，包括类声明和偏特化的模板类。如下方式定义了一个基本的可变参数模板类：

//前向声明
template<typename... Args>
struct Sum;

//基本定义
template<typename First, typename... Rest>
struct Sum<First, Rest...>
{
    enum { value = Sum<First>::value + Sum<Rest...>::value };
};

//递归终止
template<typename Last>
struct Sum<Last>
{
    enum { value = sizeof (Last) };
};

　　这个Sum类的作用是在编译期计算出参数包中参数类型的size之和，通过sum<int,double,short>::value就可以获取这3个类型的size之和为14。这是一个简单的通过可变参数模板类计算的例子，可以看到一个基本的可变参数模板应用类由三部分组成，第一部分是：

template<typename... Args> struct sum

它是前向声明，声明这个sum类是一个可变参数模板类；第二部分是类的定义：

template<typename First, typename... Rest>
struct Sum<First, Rest...>
{
    enum { value = Sum<First>::value + Sum<Rest...>::value };
};

它定义了一个部分展开的可变模参数模板类，告诉编译器如何递归展开参数包。第三部分是特化的递归终止类：

template<typename Last> struct sum<last>
{
    enum { value = sizeof (First) };
}

通过这个特化的类来终止递归：

template<typename First, typename... Args>struct sum;

这个前向声明要求sum的模板参数至少有一个，因为可变参数模板中的模板参数可以有0个，有时候0个模板参数没有意义，就可以通过上面的声明方式来限定模板参数不能为0个。上面的这种三段式的定义也可以改为两段式的，可以将前向声明去掉，这样定义：

template<typename First, typename... Rest>
struct Sum
{
    enum { value = Sum<First>::value + Sum<Rest...>::value };
};

template<typename Last>
struct Sum<Last>
{
    enum{ value = sizeof(Last) };
};

上面的方式只要一个基本的模板类定义和一个特化的终止函数就行了，而且限定了模板参数至少有一个。

递归终止模板类可以有多种写法，比如上例的递归终止模板类还可以这样写：

template<typename... Args> struct sum;
template<typename First, typenameLast>
struct sum<First, Last>
{ 
    enum{ value = sizeof(First) +sizeof(Last) };
};

在展开到最后两个参数时终止。

还可以在展开到0个参数时终止：

template<>struct sum<> { enum{ value = 0 }; };

还可以使用std::integral_constant来消除枚举定义value。利用std::integral_constant可以获得编译期常量的特性，可以将前面的sum例子改为这样：

//前向声明
template<typename First, typename... Args>
struct Sum;

//基本定义
template<typename First, typename... Rest>
struct Sum<First, Rest...> : std::integral_constant<int, Sum<First>::value + Sum<Rest...>::value>
{
};

//递归终止
template<typename Last>
struct Sum<Last> : std::integral_constant<int, sizeof(Last)>
{
};
sum<int,double,short>::value;//值为14

2.2.2继承方式展开参数包

还可以通过继承方式来展开参数包，比如下面的例子就是通过继承的方式去展开参数包：

//整型序列的定义
template<int...>
struct IndexSeq{};

//继承方式，开始展开参数包
template<int N, int... Indexes>
struct MakeIndexes : MakeIndexes<N - 1, N - 1, Indexes...> {};

// 模板特化，终止展开参数包的条件
template<int... Indexes>
struct MakeIndexes<0, Indexes...>
{
    typedefIndexSeq<Indexes...> type;
};

int main()
{
    using T = MakeIndexes<3>::type;
    cout <<typeid(T).name() << endl;
    return 0;
}

其中MakeIndexes的作用是为了生成一个可变参数模板类的整数序列，最终输出的类型是：struct IndexSeq<0,1,2>。

MakeIndexes继承于自身的一个特化的模板类，这个特化的模板类同时也在展开参数包，这个展开过程是通过继承发起的，直到遇到特化的终止条件展开过程才结束。MakeIndexes<1,2,3>::type的展开过程是这样的：

MakeIndexes<3> : MakeIndexes<2, 2>{}
MakeIndexes<2, 2> : MakeIndexes<1, 1, 2>{}
MakeIndexes<1, 1, 2> : MakeIndexes<0, 0, 1, 2>
{
    typedef IndexSeq<0, 1, 2> type;
}

通过不断的继承递归调用，最终得到整型序列IndexSeq<0, 1, 2>。

如果不希望通过继承方式去生成整形序列，则可以通过下面的方式生成。

template<int N, int... Indexes>
struct MakeIndexes3
{
    using type = typename MakeIndexes3<N - 1, N - 1, Indexes...>::type;
};

template<int... Indexes>
struct MakeIndexes3<0, Indexes...>
{
    typedef IndexSeq<Indexes...> type;
};

我们看到了如何利用递归以及偏特化等方法来展开可变模版参数，那么实际当中我们会怎么去使用它呢？我们可以用可变模版参数来消除一些重复的代码以及实现一些高级功能，下面我们来看看可变模版参数的一些应用。

3可变参数模版消除重复代码

C++11之前如果要写一个泛化的工厂函数，这个工厂函数能接受任意类型的入参，并且参数个数要能满足大部分的应用需求的话，我们不得不定义很多重复的模版定义，比如下面的代码：

template<typename T>
T* Instance()
{
    return new T();
}

template<typename T, typename T0>
T* Instance(T0 arg0)
{
    return new T(arg0);
}

template<typename T, typename T0, typename T1>
T* Instance(T0 arg0, T1 arg1)
{
    return new T(arg0, arg1);
}

template<typename T, typename T0, typename T1, typename T2>
T* Instance(T0 arg0, T1 arg1, T2 arg2)
{
    return new T(arg0, arg1, arg2);
}

template<typename T, typename T0, typename T1, typename T2, typename T3>
T* Instance(T0 arg0, T1 arg1, T2 arg2, T3 arg3)
{
    return new T(arg0, arg1, arg2, arg3);
}

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4>
T* Instance(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
    return new T(arg0, arg1, arg2, arg3, arg4);
}
struct A
{
    A(int){}
};

struct B
{
    B(int,double){}
};
A* pa = Instance<A>(1);
B* pb = Instance<B>(1,2);

可以看到这个泛型工厂函数存在大量的重复的模板定义，并且限定了模板参数。用可变模板参数可以消除重复，同时去掉参数个数的限制，代码很简洁， 通过可变参数模版优化后的工厂函数如下：

template<typename…  Args>
T* Instance(Args&&… args)
{
    return new T(std::forward<Args>(args)…);
}
A* pa = Instance<A>(1);
B* pb = Instance<B>(1,2);

4可变参数模版实现泛化的delegate

C++中没有类似C#的委托，我们可以借助可变模版参数来实现一个。C#中的委托的基本用法是这样的：

delegate int AggregateDelegate(int x, int y);//声明委托类型

int Add(int x, int y){return x+y;}
int Sub(int x, int y){return x-y;}

AggregateDelegate add = Add;
add(1,2);//调用委托对象求和
AggregateDelegate sub = Sub;
sub(2,1);// 调用委托对象相减

C#中的委托的使用需要先定义一个委托类型，这个委托类型不能泛化，即委托类型一旦声明之后就不能再用来接受其它类型的函数了，比如这样用：

int Fun(int x, int y, int z){return x+y+z;}
int Fun1(string s, string r){return s.Length+r.Length; }
AggregateDelegate fun = Fun; //编译报错，只能赋值相同类型的函数
AggregateDelegate fun1 = Fun1;//编译报错，参数类型不匹配

这里不能泛化的原因是声明委托类型的时候就限定了参数类型和个数，在C++11里不存在这个问题了，因为有了可变模版参数，它就代表了任意类型和个数的参数了，下面让我们来看一下如何实现一个功能更加泛化的C++版本的委托（这里为了简单起见只处理成员函数的情况，并且忽略const、volatile和const volatile成员函数的处理）。

template <class T, class R, typename... Args>
class  MyDelegate
{
public:
    MyDelegate(T* t, R  (T::*f)(Args...) ):m_t(t),m_f(f) {}

    R operator()(Args&&... args) 
    {
            return (m_t->*m_f)(std::forward<Args>(args) ...);
    }

private:
    T* m_t;
    R  (T::*m_f)(Args...);
};   

template <class T, class R, typename... Args>
MyDelegate<T, R, Args...> CreateDelegate(T* t, R (T::*f)(Args...))
{
    return MyDelegate<T, R, Args...>(t, f);
}

struct A
{
    void Fun(int i){cout<<i<<endl;}
    void Fun1(int i, double j){cout<<i+j<<endl;}
};

int main()
{
    A a;
    auto d = CreateDelegate(&a, &A::Fun); //创建委托
    d(1); //调用委托，将输出1
    auto d1 = CreateDelegate(&a, &A::Fun1); //创建委托
    d1(1, 2.5); //调用委托，将输出3.5
}

MyDelegate实现的关键是内部定义了一个能接受任意类型和个数参数的“万能函数”：R (T::*m_f)(Args…)，正是由于可变模版参数的特性，所以我们才能够让这个m_f接受任意参数。

5总结

使用可变模版参数的这些技巧相信读者看了会有耳目一新之感，使用可变模版参数的关键是如何展开参数包，展开参数包的过程是很精妙的，体现了泛化之美、递归之美，正是因为它具有神奇的“魔力”，所以我们可以更泛化的去处理问题，比如用它来消除重复的模版定义，用它来定义一个能接受任意参数的“万能函数”等。其实，可变模版参数的作用远不止文中列举的那些作用，它还可以和其它C++11特性结合起来，比如type_traits、std::tuple等特性，发挥更加强大的威力，将在后面模板元编程的应用中介绍。

快速设置VSCode使用远程服务器(通常是Linux)上的Docker容器来作为开发环境

优点

• 本地桌面干净： 只有docker客户端~
• 开发环境代码化：Dockerfile
• 切换环境只需切换容器

远程主机配置

安装 Docker Engine

参考这里官方文档

Docker开启远程端口

在远程主机上：

1. 创建文件 daemon.json 到目录 /etc/docker:

   {"hosts": ["tcp://0.0.0.0:2375", "unix:///var/run/docker.sock"]}
   

2. 创建文件 /etc/systemd/system/docker.service.d/override.conf:

   [Service]
   ExecStart=
   ExecStart=/usr/bin/dockerd
   

3. 重启docker：

   systemctl daemon-reload
   systemctl restart docker.service
   

   本地桌面配置

安装 Open SSH 客户端

Linux/Mac

直接用包管理器安装open-ssh

Win7

1. 下载编译好的open ssh二进制包：这里

2. 解压到 C:OpenSSH

3. 把 C:OpenSSH 加到系统环境变量Path上（需要注销再登录才能生效）

4. 打开cmd，运行

   C:> ssh-agent
   

   确保能找到

Win10

巨硬厂从Win10开始终于向社区靠拢，系统自带open ssh了，参考这个 教程

启用ssh-agent

Linux/Mac

安装了open-ssh以后默认自动运行，如果没有:

eval "$(ssh-agent -s)"

Win7

PowerShell 窗口里面运行 （administrator 模式）:

Set-Service ssh-agent -StartupType Automatic

然后 [Windows Task Manger] —> [Services] 找到ssh-agent，启动它

Win10

添加了openssh以后，应该也是自动运行的

生成 ssh 秘钥对

运行 ssh-keygen

ssh-keygen

一路回车，默认生成两个文件:

• id_rsa
• id_rsa.pub

把这个id_rsa.pub 传送到远程主机，复制成文件： ~/.ssh/authorized_keys 如果远程主机上这个authorized_keys已经存在，就添加到后面

cat id_rsa.pub >> ~/.ssh/authorized_keys

本地运行如下命令加上私钥

ssh-add id_rsa

测试一下，无需密码直接ssh连接到远程主机:

ssh <user>@<host>

本地配置 Docker 客户端

安装Docker

Linux/Mac

直接包管理器安装，就这么简单。。。

Windows

下面二选一

• 方法一：安装docker desktop, — 其实不需要这么大而全
• 方法二：下载 docker.exe 放到Path包含的路径下就行了， 比如c:windows

配置本地使用远程 Docker 服务

创建一个context：

docker context create <context name> --docker "host=ssh://<user>@<host>"

切换到上面这个context：

docker context use <context name>

测试一下：

docker info

这里会输出和在远程主机上运行 docker info 一样的结果， 实际上这里docker本地只是一个客户端，连接到远程主机上的docker服务。

Visual Studio Code

安装 VSCode

这里 VSCode 打开 VSCode， 安装插件：

• Extensions -> Search Remote -> Remote Development
• Extensions -> Search Docker -> Docker

开始一个项目!

这里有两个方式，个人觉得第一个更（省）好（事）

方式一： Attach Remote Host Container

本地 VSCode 访问远程容器

切换 Docker context

打开VSCode，按下 ctrl+shift+p 运行 docker contexts use , 选择上面创建的docker context.

连接容器

按下 ctrl+shift+p 运行 Remote-Containers:Attach to Running Container..., 选择上面创建的容器名字。

连接成功后，按下 ctrl+k, ctr+o, 你会发现VSCode弹出的不是本地目录，而是容器内部的目录！现在VSCode只是一个客户端，一切操作都在容器中了！

尝试一下。选择上面创建的 /workspaces/newproj，新建一个main.py，保存。再去主机上看，~/newproj/main.py就躺在那。

现在，可以愉快地在容（工）器（地）里面编（搬）码（砖）了。

方式二 - 微软官方推荐的办（麻）法（烦），略。

在这个网址下载Ubuntu Server，执行

dpkg -i emby-server-deb_*.deb

打开后自动配置在 http://localhost:8096 端口上。

配置媒体库后，可能需要对目标目录配置至少读权限:

chown emby.emby /media/sean/1TB -R
chmod 755 /media/sean/1TB

破解Premium版：

• sudo -i 切换为 root 用户
• 使用 systemctl stop emby-server.service 结束 emby 进程
• 使用 find / -name EmbyServer 找到 emby，比如这里我的 emby 所在目录为/opt/emby-server/system/
• 使用 wget -O /opt/emby-server/system/System.Net.Http.dll 'http://file.neko.re/EmbyCrack/unix-x64/System.Net.Http.dll' --no-check-certificate（注意替换掉命令中的 emby 所在目录）下载破解程序集替换原有程序
• 启动 Emby 进程 systemctl start emby-server.service

PC 浏览器：安装 URLRedirector(Chrome, Firefox) 插件，添加用户规则 原始地址 https://mb3admin.com ，目标地址 https://crackemby.neko.re ，然后确认并保存，别忘了勾选重定向。 在网页版设置-Premium 内输入任意字符即可。

• Android & TV：使用Emby 破解版本，转自nas2X: 蓝奏云下载 ,密码:i06m
• IOS：破解教程

私有云 Nextcloud

安装Docker环境：

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

使用helloworld环境检查：

sudo docker run hello-world

安装官方镜像并运行：

sudo docker run -d \
-v nextcloud:/var/www/html \
-v apps:/var/www/html/custom_apps \
-v config:/var/www/html/config \
-v /media/wayne/Wayne/data:/var/www/html/data \  #此处data最好也使用外面挂载
-v /media/wayne/Wayne:/media/Wayne \
-v /media/wayne/Academic:/media/Academic \
--name nextcloud \
-p 8080:80 nextcloud

成功后在 http://localhost:8080 端口上运行。

针对只能在localhost而不能在局域网下登陆的Trusted Domain问题:

#登陆docker终端
sudo docker exec -it -u root nextcloud  bash
#登陆后
vim config/config.php 一般在/var/www/html目录下

增加trusted_domains如下：

'trusted_domains' => 
  array (
          0 => 'localhost:8080',
          1 => '192.168.3.13:8080',
  ),

无需重启即可正常。

连接不上应用商店：

Change line 404 in 3rdparty/guzzlehttp/guzzle/src/Handler/CurlFactory.php

increase 1000 to 10000

In lib/private/App/AppStore/Fetcher/Fetcher.php

On line 98 change the timeout from 10 to 30 or 90

in lib/private/Http/Client.php

On line 66 change the timeout from 30 to 90

These changes migh work for you if your connection is slow. They will also invalidate the code checks so nextcloud will complain on the update page.

相册Piwigo

安装docker-compose

pip3 install docker-compose

下载Piwigo:

git clone git@github.com:xmanyou/piwigo-docker.git

进入piwigo目录修改docker-compose.yml

version: "3"
services:
  piwigo:
    image: linuxserver/piwigo
    network_mode: bridge
    volumes:
    #这里为挂载已有相册文件夹到gallery下
      - <path-to-photo>:/config/www/gallery/galleries/Phone_photo
    ports:
      - 8899:80
    links:
      - db

  db:
    image: mysql:5
    network_mode: bridge
    environment:
      MYSQL_USER: "piwigo"
      MYSQL_PASSWORD: "piwigo"
      MYSQL_DATABASE: "piwigo"
      MYSQL_RANDOM_ROOT_PASSWORD: "true"

启动：

docker-compose up -d

安装：

镜像启动后，需要先执行Piwigo的安装，打开页面：http://localhost:8899

数据库配置如下：

• 数据库主机: db (注意，这里要填镜像里的service名，而不是localhost)
• 数据库用户: piwigo (mysql db user)
• 数据库密码: piwigo (mysql db password)
• 数据库名: piwigo (mysql db name)

管理员信息自行配置。

点击底部安装按钮。

同步：

点击管理员-工具-同步

$ wget https://www.coin-or.org/download/source/Ipopt/Ipopt-3.12.7.zip 
$ unzip Ipopt-3.12.7.zip 
$ rm Ipopt-3.12.7.zip
$ cd Ipopt-3.12.7
$ ./configure
......
configure: Main configuration of Ipopt successful
$ make
$ make test
$ make install

参考：https://www.jianshu.com/p/4cdaa93d460b

参考：https://github.com/bapaden/ipopt-cmake-demo

下载 HSL MA21求解器 :

http://www.hsl.rl.ac.uk/ipopt/ https://github.com/casadi/casadi/wiki/Obtaining-HSL

没有学校邮箱的同学，可以选择下载个人版的。

为了避免后续问题，建议安装源码版本的。

#确保安装环境
$ sudo apt-get install libblas3 libblas-dev liblapack3 liblapack-dev gfortran
#方式2：源代码编译
$ tar -xf coinhsl-archive-2014.01.17.tar.gz
$ cd Ipopt-3.12.7/ThirdParty/HSL
$ ln -s ../../../coinhsl-archive-2014.01.17/ coinhsl
$ ./configure --enable-loadable-library
#出现
configure: Configuration of ThirdPartyHSL successful
$ make install 

在$ make test 过程中出现问题：

# 出现错误：
Exception of type: OPTION_INVALID in file "IpAlgBuilder.cpp" at line 271:
Exception message: Selected linear solver MA27 not available.
Tried to obtain MA27 from shared library "libhsl.so", but the following error occured:
libhsl.so: cannot open shared object file: No such file or directory

# 解决：
# 将lib copy到根目录下：
$ cd Ipopt-3.12.7/ThirdParty/HSL/lib
$ ln -s libcoinhsl.so.1.5.6 libhsl.so
$ sudo cp -rd * /usr/local/lib
$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib
#$ env | grep LD #确认设置好环境变量
$ cd Ipopt-3.12.7/lib
$ sudo cp * /usr/local/lib/

回到IPOPT环境下进行编译

$ make test
$ make install

编译成功后，可以看到目录下有这几个文件夹”bin”, “lib” and “include”

有时候需要安装CppAd，安装方法：

sudo apt-get update -y
sudo apt-get install -y cppad

没有装CppAd可能会出现下面的问题：

example.cpp:1:33: fatal error: cppad/ipopt/solve.hpp: No such file or directory

出现问题：

/usr/include/cppad/ipopt/solve_callback.hpp:16:40: fatal error: coin/IpIpoptApplication.hpp: No such file or directory

解决办法：(参考：https://zhuanlan.zhihu.com/p/34650692)

$ sudo cp ~/Ipopt-3.12.7/include/* /usr/local/include

AMPL 的C++ API

方法：https://ampl.com/api/latest/cpp/getting-started.html

下载：https://ampl.com/products/api/

学习例子参考：

1）https://github.com/mez/model_predictive_controller_cpp

2）https://github.com/tianchenji/CarND-MPC-Project

此篇我们讨论如何在 C++ 中集合如何进行交集和并集操作。

std::set 和 std::unordered_set 简介

在 C++ 标准中，std::set 是基于平衡二叉树的（经典的 SGI STL 以红黑树实现），因而是有序的。以恰当的方式，比如以 std::set 的迭代器，遍历，可以得到有序的结果。在 C++ 标准中，std::unordered_set 则是基于哈希表的。因此，遍历 std::unordered_set 得到的顺序是不被保证的。std::unordered_set 的插入、查找、计数等操作的时间复杂度是 O(1)。

如果你更喜欢 hash_set 这个名字，你也可以借助 C++11 的 using 关键字的新功能，将 hash_set 作为 unordered_set 的别名。

因为 std::set 和 std::unordered_set 底层使用了不同的数据结构，它们对外表现出来的性能也不相同。std::set 的插入、查找、计数等操作的时间复杂度是 O(log⁡n)。std::unordered_set 的插入、查找、计数等操作的时间复杂度是 O(1)。因此，在集合中元素的顺序很重要时，可以考虑使用 set::set 来保存元素；当顺序相对不重要，但会反复进行插入、查找等操作时，则应考虑使用 set::unordered_set。

我们用下面这段代码来演示 std::set 和 std::unordered_set 的用法。

#include <iostream>
#include <string>

#ifdef HASH_       
#include <unordered_set>
#else  // HASH_
#include <set>
#endif

namespace test {
#ifdef HASH_        
template <typename Key,
          typename Hash = std::hash<Key>,
          typename KeyEqual = std::equal_to<Key>,
          typename Allocator = std::allocator<Key>>
using set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
#else  // HASH_
template <typename Key,
          typename Compare = std::less<Key>,
          typename Allocator = std::allocator<Key>>
using set = std::set<Key, Compare, Allocator>;
#endif  // HASH_
}  // namespace test

int main() {
    test::set<std::string> set{"Hello", "world", "!"};          
    set.insert("hello");                                        
    set.insert("world");                                        
    for (const auto& i : set) {
        std::cout << i;                                          
        if ((set.count(i) > 0) == (set.find(i) != set.end())) {  
            std::cout << "\tYES!\n";
        }
    }

    return 0;
}

当定义 HASH_ 时，可能的输出为：

$ g++ -std=c++11 foo.cpp -DHASH_
$ ./a.out
hello   YES!
!       YES!
world   YES!
Hello   YES!

当不定义 HASH_ 时，输出应为：

$ g++ -std=c++11 foo.cpp
$ ./a.out
!       YES!
Hello   YES!
hello   YES!
world   YES!

不难发现，不论是使用 std::set 还是 std::unordered_set，重复插入的 "hello" 在集合中都只存在一份；此外，std::set 是有序的，而 std::unordered_set 是无序的。另一方面，我们发现，使用 set.count(i) > 0 和 set.find(i) != set.end() 判断集合中是否存在元素 i 是等价的。

标准库提供的 std::set_intersection 和 std::set_union

标准库提供了 std::set_intersection 和 std::set_union 两个函数，用于对容器内的元素进行集合求交、求并，而后将得到的结果保存在 OutputIt 对应的容器当中。这两个函数定义在头文件 algorithm 当中。

我们用下面这段代码演示这两个函数的用法。

#include <iostream>
#include <iterator>
#include <algorithm>

#ifdef HASH_
#include <unordered_set>
#else  // HASH_
#include <set>
#endif

namespace test {
#ifdef HASH_
template <typename Key,
          typename Hash = std::hash<Key>,
          typename KeyEqual = std::equal_to<Key>,
          typename Allocator = std::allocator<Key>>
using set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
#else  // HASH_
template <typename Key,
          typename Compare = std::less<Key>,
          typename Allocator = std::allocator<Key>>
using set = std::set<Key, Compare, Allocator>;
#endif  // HASH_
}  // namespace test

int main() {
    test::set<int> lhs{1, 2, 3, 4};                             
    test::set<int> rhs{3, 4, 5, 6};                            
    test::set<int> result;

    std::set_intersection(lhs.begin(), lhs.end(),               
                          rhs.begin(), rhs.end(),               
                          std::inserter(result, result.end())); 
    for (const auto& i : result) {
        std::cout << i << ' ';
    }
    std::cout << '\n';

    result.clear();
    std::set_union(lhs.begin(), lhs.end(),                     
                   rhs.begin(), rhs.end(),                     
                   std::inserter(result, result.end()));        
    for (const auto& i : result) {
        std::cout << i << ' ';
    }
    std::cout << '\n';

    return 0;
}

如此一来，我们应有可能的输出：

$ g++ -std=c++11 foo.cpp -DHASH_
$ ./a.out

5 6 1 2 3 4
$ g++ -std=c++11 foo.cpp
$ ./a.out
3 4
1 2 3 4 5 6

不难发现，当使用 std::unordered_set 时，函数 std::set_intersection 工作不正常（std::set_union 恰好看起来正常，实际也不正常）。当使用 std::set 时，由于基于平衡二叉树的集合是有序的，因此两个函数工作正常。

由于 std::set_intersection 和 std::set_union 接受的输入是迭代器；事实上，这两个函数不光能对集合求交集和并集，还能接收任意有序的序列的迭代器并求交集和并集。可见，虽然名字是「集合交集」和「集合并集」，但这两个函数的行为与我们默认的交集和并集的概念并不一致。更有甚者，由于这两个函数要求容器有序，所以不能作用在 std::unoredered_set 类型的对象上。因此，我们可以考虑定义自己的求交、求并函数。

定义自己的求交、求并函数

我们以下面的例子呈现我们自己定义的求交、求并函数。

#include <iostream>

#ifdef HASH_
#include <unordered_set>
#else  // HASH_
#include <set>
#endif

namespace test {
#ifdef HASH_
template <typename Key, typename Hash = std::hash<Key>,
          typename KeyEqual = std::equal_to<Key>,
          typename Allocator = std::allocator<Key>>
using set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
#else   // HASH_
template <typename Key, typename Compare = std::less<Key>,
          typename Allocator = std::allocator<Key>>
using set = std::set<Key, Compare, Allocator>;
#endif  // HASH_
}  // namespace test

namespace setop {
template <typename Set>
static inline Set set_union(const Set& lhs, const Set& rhs) {
  Set uset{lhs};
  uset.insert(rhs.begin(), rhs.end());
  return std::move(uset);
}

template <typename Set, typename Key = typename Set::value_type>
static inline Set set_intersection(const Set& lhs, const Set& rhs) {
  if (lhs.size() <= rhs.size()) {
    Set iset;
    for (const Key& key : lhs) {
      if (rhs.count(key) > 0) {
        iset.insert(key);
      }
    }
    return std::move(iset);
  } else {
    return set_intersection(rhs, lhs);
  }
}
}  // namespace setop

int main() {
  test::set<int> lhs{1, 2, 3, 4};
  test::set<int> rhs{3, 4, 5, 6};

  const auto iset = setop::set_intersection(lhs, rhs);
  const auto uset = setop::set_union(lhs, rhs);

  for (const auto& i : iset) {
    std::cout << i << ' ';
  }
  std::cout << '\n';

  for (const auto& i : uset) {
    std::cout << i << ' ';
  }
  std::cout << '\n';
  return 0;
}

如此一来，我们有可能的输出：

$ g++ -std=c++11 foo.cpp -DHASH_
$ ./a.out
3 4
5 6 1 2 3 4
$ g++ -std=c++11 foo.cpp
$ ./a.out
3 4
1 2 3 4 5 6

不难发现，两个函数工作良好。

Overview

This guide offers detailed instructions for migrating your home directory into its own dedicated partition. Setting up /home on a separate partition is beneficial because your settings, files, and desktop will be maintained if you upgrade, (re)install Ubuntu or another distro. This works because /home has a subdirectory for each user’s settings and files which contain all the data & settings of that user. Telling Ubuntu to use an existing home partition can be done by selecting “Manual Partitioning” during the installation of Ubuntu and specifying that you want your home partitions mount point to be /home, ensure you mark your /home partition not be formatted in the process. You should also make sure the usernames you enter for accounts during installation match usernames that existed in a previous installation.

This guide will follow these 8 basic steps:

1. Set-up your new partition
2. Find the uuid (=address) of the new partition
3. Backup and edit your fstab to mount the new partition as /media/home (just for the time being) and reboot.
4. Use rsync to migrate all data from /home into /media/home
5. Check copying worked!
6. Move /home to /old_home to avoid confusion later!
7. Edit fstab again so the new partition mounts as /home instead of as /media/home
8. Reboot or remount all. Check system seems to be working well
9. Delete the /old_home after a while

The guide is written in such a way so that at any point in time if there is a system failure, power outage or random restart that it will not have a negative impact on the system and SHOULD safeguard against the possibility of the user accidentally deleting their home directory in the process.

Creating a new partition

Setting up /home on a separate partition is beneficial because your settings, files, and desktop will be maintained if you upgrade, (re)install Ubuntu or another distro. This works because /home has a subdirectory for each user’s settings and files which contain all the data & settings of that user. Also, fresh installs for linux typically like to wipe whatever partition they are being installed to so either the data & settings need to be backed-up elsewhere or else avoid the fuss each time by having /home on a different partition.

Setup Partitions

建立新分区可以使用gparted,可视化软件.

sudo apt-get install gparted

This is beyond the scope of this page. Try here if you need help. Memorize or write down the location of the partition, something like /sda3. When you do create a new partition it is highly suggested that you create an ext3 or ext4 partition to house your new home directory.

Find the uuid of the Partition

The uuid (Universally Unique Identifier) reference for all partitions can be found by opening a command-line to type the following:

sudo blkid

Alternative Method

For some older releases of Ubuntu the “blkid” command might not work so this could be used instead

sudo vol_id -u <partition>

for example

sudo vol_id -u /dev/sda3

Now you just need to take note (copy&paste into a text-file) the uuid of the partition that you have set-up ready to be the new /home partition.

Setup Fstab

Your fstab is a file used to tell Ubuntu what partitions to mount at boot. The following commands will duplicate your current fstab, append the year-month-day to the end of the file name, compare the two files and open the original for editing.

1. Duplicate your fstab file:

sudo cp /etc/fstab /etc/fstab.$(date +%Y-%m-%d)

1. Compare the two files to confirm the backup matches the original:

cmp /etc/fstab /etc/fstab.$(date +%Y-%m-%d)

1. Open the original fstab in a text editor:

sudo gedit /etc/fstab 

and add these lines into it

# (identifier)  (location, eg sda5)   (format, eg ext3 or ext4)      (some settings) 
UUID=????????   /media/home    ext3          defaults       0       2 

and replace the “????????” with the UUID number of the intended /home partition.

NOTE: In the above example, the specified partition in the new text is an ext3, but if yours is an ext4 partition, you should change the part above that says “ext3” to say “ext4”, in addition to replacing the ???’s with the correct UUID. Also note that if you are using Kubuntu, Xubuntu or Lubuntu you may need to replace “gedit” with “kate”, “mousepad” or “leafpad”, respectively. They are text editors included with those distributions.

1. Save and Close the fstab file, then type the following command:

sudo mkdir /media/home

This command will create a new directory, later used for temporarily mounting the new partition. At the end of the procedure this directory can be removed.

Now you can restart your machine or instead of rebooting you might prefer to just re-load the updated fstab

sudo mount -a

Either should have mounted the new partition as /media/home. We will edit the fstab again later so this arrangement of the partition is only temporary.

Copy /home to the New Partition

Next we will copy all files, directories and sub-directories from your current /home directory into the new partition. If you do not have an encrypted home file system, just do the following:

sudo rsync -aXS --exclude='/*/.gvfs' /home/. /media/home/.

I prefer adding the “–progress” tag just before the “–excludes” one - otherwise there is no indication of anything happening. The “–progress” tag reports on each file individually so you see tons of unfamiliar stuff scrolling by very fast. Rsync can be interrupted as many times as you like and it checks to see how much has already been done when you start it up again. So, this copying stage can be broken down into many sessions. After it has completed once it’s wise to run it a couple more times just to make sure it includes everything you may have added since first starting the first copying/syncing session - even if you’ve done the whole thing all in just one session.

The –exclude=’/*/.gvfs’ prevents rsync from complaining about not being able to copy .gvfs, but I believe it is optional. Even if rsync complains, it will copy everything else anyway. (See here for discussion on this)

Encrypted file systems

If you have an encrypted home file system, then the above will just leave you with an unencrypted copy of your files, which is probably not what you want. You could re-encrypt them after copying, or copy them in their encrypted form. Here is one way to do that.

First, you’ll need to shut down, and reboot from a LiveCD or USB stick. Then you’ll need to mount your root partition and new home partition. (You can do this by selecting those devices in the file viewer). They will be mounted under /media/ubuntu - so for example, if you named your root partition linux-root, then your old home directory will be found at /media/ubuntu/linux-root/home. And if you named your new home partition linux-home, then this will be found at /media/ubuntu/linux-home. So, now you can copy your encrypted home files (here assuming your partitions are named linux-root and linux-home):

sudo rsync -aXS /media/ubuntu/linux-root/home/. /media/ubuntu/linux-home/.

There is no point trying to exclude any files with specific names, because the names of the files are encrypted too!

Leave your machine running from the LiveCD or USB for the moment.

Optional: Check Copying Worked

You should now have two duplicate copies of all the data within your home directory; the original being located in /home and the new duplicate located in /media/home. You should confirm all files and directories copied over successfully. One way to do this (for an unencrypted file system) is by using the diff command:

sudo diff -r /home /media/home -x ".gvfs/*"

If you are doing this from a LiveCd or to an existing partition that already has stuff on it you may find differences but hopefully it should be obvious which diffs you can ignore.

You can also expect to see some errors about files not found. These are due to symbolic links that point to places that don’t presently exist (but will do after you have rebooted). You can ignore these - but check out anything else.

Encrypted file systems

If you have an encrypted file system, the command will look more like this.

sudo diff -r /media/ubuntu/linux-root/home /media/ubuntu/linux-home

Now you can shut-down, remove the LiveCD / USB stick, and reboot as normal.

Preparing fstab for the switch

We now need to modify the fstab again to point to the new partition and mount it as /home. So again on a command-line

sudo gedit /etc/fstab

and now edit the lines you added earlier, changing the “/media/home” part to simply say “/home” so that it looks like this:

# (identifier)  (location, eg sda5)   (format, eg ext3 or ext4)      (some settings) 
UUID=????????   /home    ext3          defaults       0       2

Then, press Save, close the file but don’t reboot just yet.

Moving /home into /old_home

Backing up your old home, just in case things have not gone completely smoothly, is best done right now. Here is how:

As long as you have not rebooted yet, you will still see 2 copies of your /home directory; the new one on the new partition (currently mounted as /media/home) and the old one still in the same partition it was always in (currently mounted as /home). We need to move the contents of the old home directory out of the way and create an empty “place-holder” directory to act as a “mount point” for our new partition.

Type the following string of commands in to do all this at once:

cd / && sudo mv /home /old_home && sudo mkdir /home

By default, when you open a terminal window it places you within your home directory. Typing cd / takes us to the root directory and out of home so we can then use the sudo mv command to essentially rename /home into /old_home, and finally create a new, empty /home placeholder.

Reboot or Remount all

With;

1. your fstab now edited to mount your new partition to our /home place-holder and
2. the original /home now called /old_home,

it should be a good time to reboot your computer to check the whole thing really did work. Your new partition should mount as /home and everything should look exactly the same as it did before you started.

Btw, geeks might prefer to avoid rebooting by just re-loading the updated fstab

sudo mount -a

There is no need to reboot - unless you have an encrypted file system.

Troubleshooting

If you receive an error like ‘The volume may already be mounted’, use the following command to unmount the drive first before re-doing the last step again. (note the “n” should be missing from the command, making it “umount”)

sudo umount /media/home/

Then try mounting again

sudo mount -a

Deleting the old Home

You can keep using the system as it is for ages before doing this, unless you are desperately short of space on the / partition. It’s probably best to leave this step until a long time after you have been using the system happily. When you do eventually feel safe enough to delete the old home then you can try;

cd /
sudo rm -rI /old_home

Be careful with the above command because mis-typing it could result in the deletion of other files and directories!

Technical Notes and Resources

http://ubuntu.wordpress.com/2006/01/29/move-home-to-its-own-partition/

http://ubuntuforums.org/showthread.php?t=46866

#pre-requirements
sudo apt install python3-dev
pip install pytest 
#download source code
git clone https://github.com/pybind/pybind11.git
cd pybind11
mkdir build
cd build
#make 
cmake ..
make check -j 8
sudo make install

Using

Attention: DO NOT use g++ or c++ to build (in case we haven’t install pybind11 in python environment(which is also no need to do)).

Instead, we use Cmake to compile our code.

cmake_minimum_required(VERSION 3.0)

set(PROJ_NAME "example")
project(${PROJ_NAME})

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -O3")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -O3")

find_package(pybind11 REQUIRED)
pybind11_add_module(${PROJ_NAME} example.cpp)

target_link_libraries(${PROJ_NAME} PRIVATE pybind11::module)

find_package(Python)
find_path(PYTHON_SITE_PACKAGES site-packages ${PYTHON_INCLUDE_PATH}/..)

install(TARGETS ${PROJ_NAME} RUNTIME DESTINATION ${PYTHON_SITE_PACKAGES}
							 LIBRARY DESTINATION ${PYTHON_SITE_PACKAGES}
							 ARCHIVE DESTINATION ${PYTHON_SITE_PACKAGES}
							 )

And folder is such like:

├── build
│   ├  ...
├── CMakeLists.txt
└── example.cpp

C++ 的类有四类特殊成员函数，它们分别是：默认构造函数、析构函数、拷贝构造函数以及拷贝赋值运算符。这些类的特殊成员函数负责创建、初始化、销毁，或者拷贝类的对象。如果程序员没有显式地为一个类定义某个特殊成员函数，而又需要用到该特殊成员函数时，则编译器会隐式的为这个类生成一个默认的特殊成员函数。例如：

清单 1

class X{ 
private: 
 int a; 
}; 

X x;

在清单 1 中，程序员并没有定义类 X 的默认构造函数，但是在创建类 X 的对象 x 的时候，又需要用到类 X 的默认构造函数，此时，编译器会隐式的为类 X 生成一个默认构造函数。该自动生成的默认构造函数没有参数，包含一个空的函数体，即 X::X（）{ }。虽然自动生成的默认构造函数仅有一个空函数体，但是它仍可用来成功创建类 X 的对象 x，清单 1 也可以编译通过。

但是，如果程序员为类 X 显式的自定义了非默认构造函数，却没有定义默认构造函数的时候，清单 2 将会出现编译错误：

清单 2

class X{ 
public: 
 X(int i){ 
   a = i; 
 }     
private: 
 int a; 
}; 

X x;  // 错误 , 默认构造函数 X::X() 不存在

清单 2 编译出错的原因在于类 X 已经有了用户自定义的构造函数，所以编译器将不再会为它隐式的生成默认构造函数。如果需要用到默认构造函数来创建类的对象时，程序员必须自己显式的定义默认构造函数。例如：

清单 3

class X{ 
public: 
 X(){};  // 手动定义默认构造函数
 X(int i){ 
   a = i; 
 }     
private: 
 int a; 
}; 

X x;   // 正确，默认构造函数 X::X() 存在

从清单 3 可以看出，原本期望编译器自动生成的默认构造函数需要程序员手动编写了，即程序员的工作量加大了。此外，手动编写的默认构造函数的代码执行效率比编译器自动生成的默认构造函数低。类的其它几类特殊成员函数也和默认构造函数一样，当存在用户自定义的特殊成员函数时，编译器将不会隐式的自动生成默认特殊成员函数，而需要程序员手动编写，加大了程序员的工作量。类似的，手动编写的特殊成员函数的代码执行效率比编译器自动生成的特殊成员函数低。

Defaulted 函数的提出

为了解决如清单 3 所示的两个问题：1. 减轻程序员的编程工作量；2. 获得编译器自动生成的默认特殊成员函数的高的代码执行效率，C++11 标准引入了一个新特性：defaulted 函数。程序员只需在函数声明后加上“=default;”，就可将该函数声明为 defaulted 函数，编译器将为显式声明的 defaulted 函数自动生成函数体。例如：

清单 4

class X{ 
public: 
 X()= default; 
 X(int i){ 
   a = i; 
 }     
private: 
 int a; 
}; 

X x;

在清单 4 中，编译器会自动生成默认构造函数 X::X(){}，该函数可以比用户自己定义的默认构造函数获得更高的代码效率。

Defaulted 函数定义语法

Defaulted 函数是 C++11 标准引入的函数定义新语法，defaulted 函数定义的语法如图 1 所示：

Defaulted 函数的用法及示例

Defaulted 函数特性仅适用于类的特殊成员函数，且该特殊成员函数没有默认参数。例如：

清单 5

class X { 
public: 
 int f() = default;      // 错误 , 函数 f() 非类 X 的特殊成员函数
 X(int) = default;       // 错误 , 构造函数 X(int, int) 非 X 的特殊成员函数
 X(int = 1) = default;   // 错误 , 默认构造函数 X(int=1) 含有默认参数
};

Defaulted 函数既可以在类体里（inline）定义，也可以在类体外（out-of-line）定义。例如：

清单 6

class X{ 
public:  
  X() = default; //Inline defaulted 默认构造函数
  X(const X&); 
  X& operator = (const X&); 
  ~X() = default;  //Inline defaulted 析构函数
}; 

X::X(const X&) = default;  //Out-of-line defaulted 拷贝构造函数
X& X::operator = (const X&) = default;     //Out-of-line defaulted  
    // 拷贝赋值操作符

在 C++ 代码编译过程中，如果程序员没有为类 X 定义析构函数，但是在销毁类 X 对象的时候又需要调用类 X 的析构函数时，编译器会自动隐式的为该类生成一个析构函数。该自动生成的析构函数没有参数，包含一个空的函数体，即 X::~X（）{ }。例如：

清单 7

class X { 
private: 
 int x; 
}; 

class Y: public X { 
private: 
 int y; 
}; 

int main(){ 
 X* x = new Y; 
 delete x; 
}

在清单 7 中，程序员没有为基类 X 和派生类 Y 定义析构函数，当在主函数内 delete 基类指针 x 的时候，需要调用基类的析构函数。于是，编译器会隐式自动的为类 X 生成一个析构函数，从而可以成功的销毁 x 指向的派生类对象中的基类子对象（即 int 型成员变量 x）。

但是，这段代码存在内存泄露的问题，当利用 delete 语句删除指向派生类对象的指针 x 时，系统调用的是基类的析构函数，而非派生类 Y 类的析构函数，因此，编译器无法析构派生类的 int 型成员变量 y。

因此，一般情况下我们需要将基类的析构函数定义为虚函数，当利用 delete 语句删除指向派生类对象的基类指针时，系统会调用相应的派生类的析构函数（实现多态性），从而避免内存泄露。但是编译器隐式自动生成的析构函数都是非虚函数，这就需要由程序员手动的为基类 X 定义虚析构函数，例如：

清单 8

class X { 
public: 
 virtual ~X(){};     // 手动定义虚析构函数
private: 
 int x; 
}; 

class Y: public X { 
private: 
 int y; 
}; 

int main(){ 
 X* x = new Y; 
 delete x; 
 }

在清单 8 中，由于程序员手动为基类 X 定义了虚析构函数，当利用 delete 语句删除指向派生类对象的基类指针 x 时，系统会调用相应的派生类 Y 的析构函数（由编译器隐式自动生成）以及基类 X 的析构函数，从而将派生类对象完整的销毁，可以避免内存泄露。

但是，在清单 8 中，程序员需要手动的编写基类的虚构函数的定义（哪怕函数体是空的），增加了程序员的编程工作量。更值得一提的是，手动定义的析构函数的代码执行效率要低于编译器自动生成的析构函数。

为了解决上述问题，我们可以将基类的虚析构函数声明为 defaulted 函数，这样就可以显式的指定编译器为该函数自动生成函数体。例如：

清单 9

class X { 
public: 
 virtual ~X()= defaulted; // 编译器自动生成 defaulted 函数定义体
private: 
 int x; 
}; 

class Y: public X { 
private: 
 int y; 
}; 

int main(){ 
 X* x = new Y; 
 delete x;
}

在清单 9 中，编译器会自动生成虚析构函数 virtual X::X(){}，该函数比用户自己定义的虚析构函数具有更高的代码执行效率。

许多年轻的都市人不想拥有汽车，与前几代人不同的是，他们不需要依赖公共交通。相反，他们将交通出行视为一种服务。当他们需要长途旅行时，比如说超过5英里（8公里），他们会用手机叫一辆Uber（或类似的共享单车公司的车）。如果他们的行程不到一英里左右，他们要么步行，要么使用各种 “微移动 “服务，比如越来越多的Lime和Bird踏板车，或者在一些城市，共享单车。

问题是，如今移动即服务生态系统往往不能很好地覆盖中间距离，比如说几英里的距离。雇佣Uber或Lyft来进行这种短途旅行，其费用令人沮丧，而且骑着踏板车或自行车超过一英里左右的路程对很多人来说可能会很费劲。因此，将自己送到1到5英里外的目的地可能是一个挑战。然而，这样的旅行占到了乘客总里程的一半左右。

这些中长途旅行中，很多都是在车流量有限的环境中进行的，比如大学校园和工业园区，在这些地方部署小型、低速的自主车辆，在经济上和技术上都是可行的。我们已经与一家初创公司合作，打算将这种交通方式普及化。这家名为PerceptIn的公司已经在日本奈良和福冈的旅游景点、中国深圳的工业园区、以及公司总部所在地–印地安那州的Fishers市，都有自主车辆在运营。

考虑到目前自主汽车的生产量仍然是多么的昂贵—一个实验车型的价格可能在30万美元左右—你可能不可能认为有可能以更低的价格卖出一辆自驾车汽车。我们过去几年的经验表明，事实上，今天生产出一辆自驾车乘用车是有可能的。PerceptIn的车辆目前的售价约为7万美元，未来价格肯定会下降。以下是我们和PerceptIn的同事们如何将自主驾驶汽车的成本降下来的。

高成本无人车标准技术方案

首先，我们先来解释一下为什么自主驾驶汽车通常会这么贵。一言以蔽之，就是因为它们所携带的传感器和计算机非常昂贵。

自主驾驶所需的传感器套件通常包括一个高端卫星导航接收器、激光雷达（光线探测和测距）、一个或多个摄像头、雷达和声纳。该车还需要至少有一台非常强大的计算机。

这种情况下使用的卫星导航接收器与手机中的卫星导航接收器不一样。内置在自主车辆上的那种卫星导航接收器具有所谓的实时运动学（RTK）功能，可进行高精度的位置固定，精确度可达10厘米。这些设备的价格通常在4000美元左右。即便如此，这种卫星导航接收机也不能完全依靠它来告诉汽车的位置。在卫星信号从附近的建筑物上反弹的情况下，它所得到的固定信号可能会产生噪音和延迟。在任何情况下，卫星导航都需要无遮挡的天空视野。在封闭的环境比如隧道内，卫星导航无疑直接失效。

幸运的是，自动驾驶汽车还有其他方法来确定自己的位置。特别是，它们可以使用激光雷达，通过将激光束反弹到物体上并测量光线反射回来所需的时间来确定与物体的距离。一个典型的自主车辆用激光雷达装置的探测范围为150米，每秒采样超过100万个空间点。

这样的激光雷达扫描可用于识别当地环境中的不同形状。然后，车辆的计算机将所观察到的形状与该地区的高清数字地图中记录的形状进行比较，使其能够随时跟踪车辆的准确位置。激光雷达还可用于识别和避开瞬时障碍物，如行人和其他车辆等。

Lidar是一项很棒的技术，但它有两个问题。首先，这些设备的价格非常昂贵。一台用于自主驾驶的高端激光雷达的价格很容易超过8万美元，虽然成本在下降，但对于低速应用来说，4000美元左右就能买到一台合适的设备。另外，激光雷达作为一种光学设备，在大雨或大雾等恶劣天气下，可能无法提供合理的测量结果。

这些车辆上的摄像头也是如此，主要用于识别和跟踪不同的物体，如车道、红绿灯、行人等边界。通常情况下，在车辆周围安装了多个摄像头。这些摄像头通常以每秒60帧的速度运行，所使用的多个摄像头每秒可以产生超过1千兆字节的原始数据。当然，处理这些海量的信息，对车辆的计算机提出了非常大的计算需求。好的一面是，摄像头的价格并不昂贵。

自主汽车上的雷达和声纳系统被用于避障。它们产生的数据集显示了车辆路径上最近的物体的距离。这些系统的主要优点是可以在各种天气条件下工作。声纳通常覆盖的范围最多10米，而雷达的范围通常可达200米。与摄像机一样，这些传感器的价格相对便宜，通常每个传感器的价格不到1000美元。

这类传感器提供的许多测量结果会被输入到车辆的计算机中，计算机必须将所有这些信息整合在一起，以产生对环境的理解。人工神经网络和深度学习，这种近年来发展迅速的方法在这里发挥了很大的作用。通过这些技术，计算机可以跟踪附近行驶的其他车辆，以及过马路的行人，确保自主车辆不会与任何东西或任何人发生碰撞。

当然，指挥自主车辆的计算机要做的事情还不止是避免撞到东西。它们必须做出大量的决策，决定转向的方向和速度。为此，车辆的计算机会对附近车辆的即将到来的移动情况进行预测，然后根据这些预测以及乘员需要去哪里，再决定行动方案。

最后，自动驾驶汽车需要一张好的地图。传统的数字地图通常是由卫星图像生成的，精确度为米级。虽然这对于人类驾驶者来说已经绰绰有余，但自主汽车对车道级信息的精度要求更高。因此，需要特殊的高清地图。

就像传统的数字地图一样，这些高清地图包含了很多层信息。最底层是地图的网格单元格，约5×5厘米；它是由专用汽车收集的原始激光雷达数据生成的。这个网格记录了环境中物体的高程和反射信息。

在这个基础网格之上，还有几层附加信息。例如，车道信息被添加到网格地图上，以便自主车辆判断是否在正确的车道上。在车道信息的基础上，还添加了交通标志标签，以通知自主车辆当地的限速、是否接近红绿灯等。这在车辆上的摄像头无法读取交通标志的情况下，有一定的帮助。

传统的数字地图是每6到12个月更新一次。为了确保自主车辆使用的地图包含最新信息，高清地图应该每周刷新一次。因此，对于一个中等规模的城市来说，生成和维护高清地图每年的成本可能高达数百万美元。

这些高清地图上的所有数据都必须存储在车辆上的固态存储器中，以便随时访问，这就增加了计算硬件的成本，而计算硬件需要相当强大。举个例子，百度在自主驾驶中采用的一个早期计算系统，使用的是英特尔Xeon E5处理器和4到8个Nvidia K80 GPU加速器。该系统每秒能够提供64.5万亿次浮点运算，但它的功耗约为3000瓦，并产生了大量的热量。而它的成本约为3万美元。

PerceptIn低速无人车低成本方案

考虑到光是传感器和计算机的成本就很容易超过10万美元，这就不难理解为什么自主汽车的价格如此昂贵了，至少在今天是这样。当然，随着生产总量的增加，价格会有所下降。但目前还不清楚创建和维护高清地图的成本将如何转嫁。无论如何，在正常道路和高速公路上自主驾驶所带来的所有明显的安全问题都需要时间来解决，而更好的技术还需要时间来解决。

我们和PerceptIn的同事们一直在努力解决这些挑战，他们将注意力集中在那些在有限的区域内运行且不需要与高速交通混合的小型、低速车辆上–例如大学校园和工业园区。

我们用来降低成本的主要策略是完全抛弃激光雷达，转而使用更经济实惠的传感器：摄像头、惯性测量单元、卫星定位接收器、车轮编码器、雷达和声纳。这些传感器所提供的数据可以通过一个叫做传感器融合的过程进行组合。

这些传感器的缺点和优点都是相辅相成的。当其中一个传感器出现故障或故障时，其他传感器可以接替，以确保系统的可靠性。采用这种传感器融合的方式，传感器的成本最终可能会下降到2000美元左右。

因为我们的汽车以低速行驶，最多只需要7米就能停下来，这使得它比普通的汽车要安全得多，因为普通的汽车可能需要几十米才能停下来。而且由于速度较低，计算系统的延迟要求也没有高速自主汽车上使用的系统那么苛刻。

PerceptIn的车辆使用卫星定位进行初始定位。这些卫星导航接收机虽然不如高速公路上的自主汽车上的系统准确，但仍能提供亚米级的精度。通过将摄像头图像和惯性测量单元的数据结合在一起（在一种称为视觉惯性里程法的技术中），车辆的计算机进一步提高了精度，将位置固定到分米级。

在成像方面，PerceptIn在一个硬件模块中集成了四个摄像头。一对摄像头面向车头，另一对面向车尾。每一对摄像头都能提供双目视力，能够捕捉到通常由激光雷达提供的空间信息。更重要的是，这四个摄像头合在一起可以捕捉到360度的环境视图，帧与帧之间有足够多的空间重叠区域，确保视觉测距仪可以在任何方向上工作。

即使视觉测距仪出现故障，卫星定位信号中断，也不会丢失。该车仍然可以使用连接在车轮上的旋转编码器计算出位置更新—-遵循水手们几个世纪以来使用的一般策略，即死计算。

将所有这些传感器的数据集结合起来，让车辆对环境有一个整体的了解。基于这种了解，车辆的计算机可以做出所需的决策，以确保顺利安全行驶。

此外，车辆还有一个独立于主电脑之外的防撞系统，为车辆提供了最后一道防线。这套系统利用毫米波雷达和声纳的组合，当车辆靠近物体5米以内时，就会感应到，在这种情况下，车辆会立即停止行驶。

依靠成本较低的传感器只是PerceptIn为降低成本而采取的策略之一。另一个策略是将计算推到传感器上，以减少对车辆主电脑的要求，一台普通的PC机总成本不到1500美元，系统峰值功率只有400W。

以PerceptIn的摄像头模块为例，每秒可以产生400兆字节的图像信息。如果将这些数据全部传输到主计算机上进行处理，那么该计算机就必须非常复杂，这将在可靠性、功率和成本方面产生重大影响。相反，PerceptIn让每个传感器模块尽可能多地进行计算。这就减少了主计算机的负担，简化了设计。

更具体地说，GPU被嵌入到摄像头模块中，从原始图像中提取特征。然后，只将提取的特征发送到主计算机，将数据传输率降低一千倍。

另一种限制成本的方法涉及到高清地图的创建和维护。PerceptIn不使用装有激光雷达装置的车辆来提供地图数据，而是用视觉信息增强现有的数字地图，以达到分米级精度。

由此产生的高精度可视地图，就像它们所取代的基于激光雷达的高清地图一样，由多个图层组成。底层可以是任何现有的数字地图，例如来自OpenStreetMap项目的数字地图。这个底层的分辨率约为1米。第二层记录了路面的视觉特征，将地图分辨率提高到分米级。第三层同样以分米分辨率保存，记录了环境中其他部分的视觉特征，如标志、建筑物、树木、围墙和灯杆等。第四层是语义层，它包含了车道标记、交通标志标签等。

总结

虽然在过去的十年里已经取得了很大的进展，但要想让完全自主的汽车开始在大多数道路和高速公路上行驶，可能还需要十年或更长时间。在此期间，一个实用的方法是在限制性的环境下使用低速自主汽车。包括Navya、EasyMile和May Mobility在内的几家公司，以及PerceptIn等公司一直在认真地研究这一战略，并取得了良好的进展。

最终，随着相关技术的进步，车辆的类型和部署范围可以扩大，最终可以包括能够与人类专家级驾驶员的性能相当甚至超过人类专家级驾驶员的车辆。

PerceptIn已经表明，制造小型、低速自主汽车的成本远远低于制造一辆能上高速公路的自主汽车的成本。当车辆大量生产时，我们预计制造成本将低于1万美元。在不远的将来，这样的清洁能源自主班车或许有可能在城市中心地带载客，比如曼哈顿的中央商务区，现在这里的平均车速只有7英里/小时。这样的车队将大大降低乘客的成本，改善交通状况，提高安全性，并改善空气质量。在世界高速公路上解决自主驾驶的问题可以在以后进行。

关于作者

Shaoshan Liu is the cofounder and CEO of PerceptIn, an autonomous vehicle startup in Fishers, Ind.

Jean-Luc Gaudiot is a professor of electrical engineering and computer science at the University of California, Irvine.