1. copy trait
语法声明：
#[lang = "copy"]
pub trait Copy: Clone { }
描述：
实现Copy的类型，可以使用简单字节copy的方式复制。
与Clone不同，Copy方式是隐式作用于类型变量，通过赋值语句来完成，因为是字节copy,所以是低成本的。
对于含有指针的类型，字节copy的作用只是复制指针本身，对于指针指向的内容并不复制。
// We can derive a Copy implementation. Clone is also required, as it's
// a supertrait of Copy.
#[derive(Debug, Copy, Clone)]
struct Foo;
let x = Foo;
let y = x;
// y is a copy of x
println!("{:?}", x); // A-OK!
如上面的例子，与Ownership的move不同， 声明了copy trait的的结构类，执行赋值语句后，让然可以访问（内容作了复制）。
另外，copy是clone的子trait, 实现copy 也就需要实现clone.
Copy trailt的两种实现方法：
a。 Derive macro
#[derive(Copy, Clone)] //derive copy的同时需要derive clone
struct MyStruct;
b. 实现 copy和Clone方法
struct MyStruct;
impl Copy for MyStruct { }
impl Clone for MyStruct { //impl copy的同时，需要imp clone
fn clone(&self) -> MyStruct {
*self
}
}
注意点：
-- 一个类型（type）要实现Copy， 则它的所有组件都需要实现了Copy
-- 只读型引用（Shared references (&T)） 是可以Copy的，即使它引用的对象不是实现copy的。
-- 如果一个类型包含有只读型引用，并且其它组件是实现了copy， 则这个类型是可以实现copy的。
上图， PointList 不能实现copy, 因为vec<T> 没有实现Copy。
PointListWrapper是可以实现copy的，因为它只包含了一个只读型引用。
-- 任何实现了Drop trait（销毁内存前调用）的类型，不能实现Copy。
-- String 类型实现了Clone（复制缓存），没有实现Copy（复制指针对String类型不合适）
-- &mut 类型不能实现Copy。 mut 类型引用只能有一个。
参考 Std::marker::Copy
2. clone trait
语法声明:
#[lang = "clone"]
pub trait Clone {
#[must_use = "cloning is often expensive and is not expected to have side effects"]
fn clone(&self) -> Self;
fn clone_from(&mut self, source: &Self) { ... }
}
描述：
Clone是用于显式复制一个对象的trait。
显示复制意味着，需要通过Clone提供的方法来实现复制，这与copy是有明显区别的。
另外，使用Clone方式实现复制所花费的代价由Clone的具体实现决定，可以像Copy一样只做字节Copy，也可以复制整个内容（例如，String类型实现了整个字符缓存的复制）。
// derive implements Clone for Reading<T> when T is Clone.
#[derive(Clone)]
struct Reading<T> {
frequency: T,
}
是用#[derive]的方式标记一个类型，需要这个类型的所有成员都是可以Clone的（实现了Clone）， 特别是在有泛型参数的情况下，会限定泛型参数是可以clone的。原因是，使用derive的方式，系统会调用所有成员的clone方法。
另外一种方式，是使用Imp方式，这种方式不用限定类型的成员。下面这个例子中泛型参数T是函数指针，这个例子没有办法是用derive的方式，但可以直接使用Imp的方式实现Clone。
struct Generate<T>(fn() -> T);
impl<T> Copy for Generate<T> {}
impl<T> Clone for Generate<T> {
fn clone(&self) -> Self {
*self
}
}
-- Types that are Copy should have a trivial implementation of Clone. More formally: if T: Copy, x: T, and y: &T, then let x = y.clone(); is equivalent to let x = *y;.
