Ref: https://www.tangramvision.com/blog/c-rust-generics-and-specialization

泛型入门：输入的类型

C++和 Rust 中的泛型都是一种将其他类型作为其定义的一部分的类型。泛型是通过在类型定义中指定占位符的一种方式，然后可以 使用更具体的类型来替换，例如在 C++中可以这定义一个泛型类型：

1template<typename T>
2struct MyArray {
3    T* raw_array;
4    std::size_t size;
5};

对于这个泛型结构而言，MyArray<int>和MyArray<std::string>是不同的类型。我们可以通过指定具体的T类型，来复用MyArray这个泛型结构体。这里的MyArray<T>就像一个“模板”一样。 泛型不仅仅局限于结构体，我们同样也能写出泛型函数：

1template<typename T>
2T timestwo(T number) {
3    return number + number;
4}

上面我们定义了一个非常简单的函数，用来将数值加倍。同理，用具体类型实例化的timestwo<int>和timestwo<double>也不是同一个函数。

而要在 Rust 中实现上面的函数，可能稍微复杂一点：

1use std::ops::Add;
2
3fn timestwo<T>(number: T) -> <T as Add>::Output
4where
5    T: Add + Copy,
6{
7    number + number
8}

很显然，上面 Rust 版本和 C++版本的实现相比看上去多了很多额外的语法。其中主要的区别是我们调用了特征边界检查，也就是T: Add + Copy， 或者用更通俗的话来说，T类型必须实现Add和Copy 特征(trait)。

Ref: https://www.tangramvision.com/blog/c-rust-interior-mutability-moving-and-ownership

C++和 Rust 中的不变性(constness)

值

Rust 和 C++有两个非常相似的概念，即 Rust 中的 mutability/immutability 和 C++中的 constness/non-constness. 在 Rust 中，一个给定的值要么是可变的(mutable)，要么是不可变的(immutable)，正如这些限定符名称所代表的含义，可变的值可以被修改，不可变的值不能被修改。 然而与 C++不同的是，Rust 中不可变的值可以被移动(move)，就像下面的代码实例那样：

1fn foo() {
2    let x = 1;
3    println!("{}", x)
4    let mut x = x;
5    x *= 10;
6    println!("{}", x);
7}

在 C++中，给定的值要么是常量(const)，要么是非常量(non-const)。但是 C++中的常量值不能被移动(move)。在 C++中，对一个 const 限定符修饰的值 进行std::move操作，实际上会触发拷贝构造，这一点在"Effective Modern C++“这本书中作者也有提到：

 1class Annotation {
 2public:
 3    explicit Annotation(const std::string text)
 4     : value(std::move(text)) //here we want to call string(string&&),
 5                              //but because text is const,
 6                              //the return type of std::move(text) is const std::string&&
 7                              //so we actually called string(const string&)
 8                              //it is a bug which is very hard to find out
 9    {}
10private:
11    std::string value;
12};

我们也可以自己写一段程序来验证一下：