Go 由于不支持泛型而臭名昭著，但最近，泛型已接近成为现实。Go 团队实施了一个看起来比较稳定的设计草案，并且正以源到源翻译器原型的形式获得关注。本文讲述的是泛型的最新设计，以及如何自己尝试泛型。
创新互联是专业的蔡家坡网站建设公司，蔡家坡接单;提供网站设计、做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行蔡家坡网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!
例子
FIFO Stack
假设你要创建一个先进先出堆栈。没有泛型，你可能会这样实现：
type Stack []interface{}func (s Stack) Peek() interface{} {
return s[len(s)-1]
}
func (s *Stack) Pop() {
*s = (*s)[:
len(*s)-1]
}
func (s *Stack) Push(value interface{}) {
*s =
append(*s, value)
}
但是，这里存在一个问题：每当你 Peek 项时，都必须使用类型断言将其从 interface{} 转换为你需要的类型。如果你的堆栈是 *MyObject 的堆栈，则意味着很多 s.Peek().(*MyObject)这样的代码。这不仅让人眼花缭乱，而且还可能引发错误。比如忘记 * 怎么办？或者如果您输入错误的类型怎么办？s.Push(MyObject{})` 可以顺利编译，而且你可能不会发现到自己的错误，直到它影响到你的整个服务为止。
通常，使用 interface{} 是相对危险的。使用更多受限制的类型总是更安全，因为可以在编译时而不是运行时发现问题。
泛型通过允许类型具有类型参数来解决此问题：
type Stack(type T) []Tfunc (s Stack(T)) Peek() T {
return s[len(s)-1]
}
func (s *Stack(T)) Pop() {
*s = (*s)[:
len(*s)-1]
}
func (s *Stack(T)) Push(value T) {
*s =
append(*s, value)
}
这会向 Stack 添加一个类型参数，从而完全不需要 interface{}。现在，当你使用 Peek() 时，返回的值已经是原始类型，并且没有机会返回错误的值类型。这种方式更安全，更容易使用。（译注：就是看起来更丑陋，^-^）
此外，泛型代码通常更易于编译器优化，从而获得更好的性能（以二进制大小为代价）。如果我们对上面的非泛型代码和泛型代码进行基准测试，我们可以看到区别：
type MyObject struct {
X
int
}
var sink MyObjectfunc BenchmarkGo1(b *testing.B) {
for i := 0; i b.N; i++ {
var s Stack
s.Push(MyObject{})
s.Push(MyObject{})
s.Pop()
sink = s.Peek().(MyObject)
}
}
func BenchmarkGo2(b *testing.B) {
for i := 0; i b.N; i++ {
var s Stack(MyObject)
s.Push(MyObject{})
s.Push(MyObject{})
s.Pop()
sink = s.Peek()
}
}
结果：
BenchmarkGo1BenchmarkGo1-16 12837528 87.0 ns/op 48 B/op 2 allocs/opBenchmarkGo2BenchmarkGo2-16 28406479 41.9 ns/op 24 B/op 2 allocs/op
在这种情况下，我们分配更少的内存，同时泛型的速度是非泛型的两倍。
合约（Contracts）
上面的堆栈示例适用于任何类型。但是，在许多情况下，你需要编写仅适用于具有某些特征的类型的代码。例如，你可能希望堆栈要求类型实现 String() 函数
1.深拷贝与浅拷贝 拷贝即是通常所说的复制(Copy)或克隆(Clone)，对象的拷贝也就是从现有对象复制一个“一模一样”的新对象出来。虽然都是复制对象，但是不同的复制方法，复制出来的新对象却并非完全一模一样，对象内部存在着一些差异。通常的拷贝方法有两种，即深拷贝和浅拷贝，那二者之间有何区别呢？MSDN里对IClone接口的Clone方法有这样的说明：在深层副本中，所有的对象都是重复的；而在浅表副本中，只有顶级对象是重复的，并且顶级以下的对象包含引用。可以看出，深拷贝和浅拷贝之间的区别在于是否复制了子对象。这如何理解呢？下面我通过带有子对象的代码来验证二者的区别。 首先定义两个类型：Student和ClassRoom，其中Student类型里包含ClassRoom，并使这两个类型都分别实现自定义的深拷贝接口(IDeepCopy)和浅拷贝接口(IShallowCopy)。 类图如下： 定义代码如下： 定义代码 /// summary /// 深拷贝接口 /// /summary interface IDeepCopy { object DeepCopy(); } /// summary /// 浅拷贝接口 /// /summary interface IShallowCopy { object ShallowCopy(); } /// summary /// 教室信息 /// /summary class ClassRoom : IDeepCopy, IShallowCopy { public int RoomID = 1; public string RoomName = "Room1"; public override string ToString() { return "RoomID=" + RoomID + "\tRoomName=" + RoomName; } public object DeepCopy() { ClassRoom r = new ClassRoom(); r.RoomID = this.RoomID; r.RoomName = this.RoomName; return r; } public object ShallowCopy() { //直接使用内置的浅拷贝方法返回 return this.MemberwiseClone(); } } class Student : IDeepCopy, IShallowCopy { //为了简化，使用public 字段 public string Name; public int Age; //自定义类型，假设每个Student只拥有一个ClassRoom public ClassRoom Room = new ClassRoom(); public Student() { } public Student(string name, int age) { this.Name = name; this.Age = age; } public object DeepCopy() { Student s = new Student(); s.Name = this.Name; s.Age = this.Age; s.Room = (ClassRoom)this.Room.DeepCopy(); return s; } public object ShallowCopy() { return this.MemberwiseClone(); } public override string ToString() { return "Name:" + Name + "\tAge:" + Age + "\t" + Room.ToString(); } } 测试代码： 测试代码 Student s1 = new Student("Vivi", 28); Console.WriteLine("s1=[" + s1 + "]"); Student s2 = (Student)s1.ShallowCopy(); //Student s2 = (Student)s1.DeepCopy(); Console.WriteLine("s2=[" + s2 + "]"); //此处s2和s1内容相同 Console.WriteLine("-----------------------------"); //修改s2的内容 s2.Name = "tianyue"; s2.Age = 25; s2.Room.RoomID = 2; s2.Room.RoomName = "Room2"; Console.WriteLine("s1=[" + s1 + "]"); Console.WriteLine("s2=[" + s2 + "]"); //再次打印两个对象以比较 Console.ReadLine(); 运行结果： a.ShallowCopy s1=[Name:Vivi Age:28 RoomID=1 RoomName=Room1] s2=[Name:Vivi Age:28 RoomID=1 RoomName=Room1] ------------------------------------------------------------- s1=[Name:Vivi Age:28 RoomID=2 RoomName=Room2] s2=[Name:tianyue Age:25 RoomID=2 RoomName=Room2] b.DeepCopy s1=[Name:Vivi Age:28 RoomID=1 RoomName=Room1] s2=[Name:Vivi Age:28 RoomID=1 RoomName=Room1] ----------------------------- s1=[Name:Vivi Age:28 RoomID=1 RoomName=Room1] s2=[Name:tianyue Age:25 RoomID=2 RoomName=Room2] 从以上结果可以看出，深拷贝时两个对象是完全“分离”的，改变其中一个，不会影响到另一个对象；浅拷贝时两个对象并未完全“分离”，改变顶级对象的内容，不会对另一个对象产生影响，但改变子对象的内容，则两个对象同时被改变。这种差异的产生，即是取决于拷贝子对象时复制内存还是复制指针。深拷贝为子对象重新分配了一段内存空间，并复制其中的内容；浅拷贝仅仅将指针指向原来的子对象。 示意图如下： 2.浅拷贝与赋值操作 大多数面向对象语言中的赋值操作都是传递引用，即改变对象的指针地址，而并没有复制内存，也没有做任何复制操作。由此可知，浅拷贝与赋值操作的区别是顶级对象的复制与否。当然，也有一些例外情况，比如类型定义中重载赋值操作符（assignment operator），或者某些类型约定按值传递，就像C＃中的结构体和枚举类型。 赋值操作示意图如下： 3.C++拷贝构造函数 与其它面向对象语言不同，C++允许用户选择自定义对象的传递方式：值传递和引用传递。在值传递时就要使用对象拷贝，比如说按值传递参数，编译器需要拷贝一个对象以避免原对象在函数体内被破坏。为此，C++提供了拷贝构造函数用来实现这种拷贝行为，拷贝构造函数是一种特殊的构造函数，用来完成一些基于同一类的其它对象的构造和初始化。它唯一的参数是引用类型的，而且不可改变，通常的定义为X(const X)。在拷贝构造函数里，用户可以定义对象的拷贝行为是深拷贝还是浅拷贝，如果用户没有实现自己的拷贝构造函数，那么编译器会提供一个默认实现，该实现使用的是按位拷贝(bitwise copy)，也即本文所说的浅拷贝。构造函数何时被调用呢？通常以下三种情况需要拷贝对象，此时拷贝构造函数将会被调用。 1.一个对象以值传递的方式传入函数体 2.一个对象以值传递的方式从函数返回 3.一个对象需要通过另外一个对象进行初始化 4.C# MemberwiseClone与ICloneable接口 和C++里的拷贝构造函数一样，C#也为每个对象提供了浅拷贝的默认实现，不过C#里没有拷贝构造函数，而是通过顶级类型Object里的MemberwiseClone方法。MemberwiseClone 方法创建一个浅表副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。有没有默认的深拷贝实现呢？当然是没有，因为需要所有参与拷贝的对象定义自己的深拷贝行为。C++里需要用户实现拷贝构造函数，重写默认的浅拷贝；C#则不同，C#(确切的说是.NET Framework，而非C#语言)提供了ICloneable 接口，包含一个成员 Clone，它用于支持除 MemberwiseClone 所提供的克隆之外的克隆。C++通过拷贝构造函数无法确定子对象实现的是深拷贝还是浅拷贝，而C#在“强制”实现浅拷贝的基础上，提供ICloneable 接口由用户定义深拷贝行为，通过接口来强制约束所有参与拷贝的对象，个人觉得，这也算是一小点C#对C++的改进。 5.深拷贝策略与实现 深拷贝的要点就是确保所有参与拷贝的对象都要提供自己的深拷贝实现，不管是C++拷贝构造函数还是C#的ICloneable 接口，事实上都是一种拷贝的约定。有了事先的约定，才能约束实现上的统一，所以关键在于设计。 但偶尔也会在后期才想到要深拷贝，怎么办？总不能修改所有之前的实现吧。有没有办法能够通过顶级类而不关心内部的子对象直接进行深拷贝呢？能不能搞个万能的深拷贝方法，在想用的时候立即用，而不考虑前期的设计。这样“大包大揽”的方法，难点在于实现时必须自动获取子对象的信息，分别为子对象实现深拷贝。C++里比较困难，.NET的反射机制使得实现容易一些。不过这样的方法虽然通用，实则破坏了封装，也不符合“每个类对自己负责”的设计原则。 基于.NET的反射机制，以前写了一个通用的序列化方法，现在可以拿过来，先序列化，然后再反序列化回来，也即是一个深拷贝，示例代码如下： 深拷贝示例代码 #region ICloneable Members /// summary /// 此处的复制为深拷贝，在实现上，为了简化，采用序列化和反序列化。 /// /summary /// returns深拷贝对象/returns public object Clone() { Student stu = new Student(); XmlStorageHelper helper = new XmlStorageHelper(); string strXml = helper.ConvertToString(this); helper.LoadFromString(stu, strXml); //从XML字符串来赋值 return stu; } #endregion
浅拷贝还是深拷贝这是对于指针来说的，基本变量是没有这一说的，都是直接分配一个新的内存给它。
所string类是stl类，已经封装好了，当然是深度拷贝，直接用就可以，完全不用担心内存的问题，经过几十年的安全检验了
Go 中的分片数组，实际上有点类似于Java中的ArrayList,是一个可以扩展的数组，但是Go中的切片由比较灵活，它和数组很像，也是基于数组，所以在了解Go切片前我们先了解下数组。
数组简单描述就由相同类型元素组成的数据结构, 在创建初期就确定了长度，是不可变的。
但是Go的数组类型又和C与Java的数组类型不一样， NewArray 用于创建一个数组，从源码中可以看出最后返回的是 Array{}的指针，并不是第一个元素的指针，在Go中数组属于值类型，在进行传递时，采取的是值传递，通过拷贝整个数组。Go语言的数组是一种有序的struct。
Go 语言的数组有两种不同的创建方式，一种是显示的初始化，一种是隐式的初始化。
注意一定是使用 [...]T 进行创建，使用三个点的隐式创建，编译器会对数组的大小进行推导，只是Go提供的一种语法糖。
其次，Go中数组的类型，是由数值类型和长度两个一起确定的。[2]int 和 [3]int 不是同一个类型，不能进行传参和比较，把数组理解为类型和长度两个属性的结构体，其实就一目了然了。
Go中的数组属于值类型，通常应该存储于栈中，局部变量依然会根据逃逸分析确定存储栈还是堆中。
编译器对数组函数中做两种不同的优化：
在静态区完成赋值后复制到栈中。
总结起来，在不考虑逃逸分析的情况下，如果数组中元素的个数小于或者等于 4 个，那么所有的变量会直接在栈上初始化，如果数组元素大于 4 个，变量就会在静态存储区初始化然后拷贝到栈上。
由于数组是值类型，那么赋值和函数传参操作都会复制整个数组数据。
不管是赋值或函数传参，地址都不一致，发生了拷贝。如果数组的数据较大，则会消耗掉大量内存。那么为了减少拷贝我们可以主动的传递指针呀。
地址是一样的，不过传指针会有一个弊端，从打印结果可以看到，指针地址都是同一个，万一原数组的指针指向更改了，那么函数里面的指针指向都会跟着更改。
同样的我们将数组转换为切片，通过传递切片，地址是不一样的，数组值相同。
切片是引用传递，所以它们不需要使用额外的内存并且比使用数组更有效率。
所以，切片属于引用类型。
通过这种方式可以将数组转换为切片。
中间不加三个点就是切片,使用这种方式创建切片，实际上是先创建数组，然后再通过第一种方式创建。
使用make创建切片，就不光编译期了，make创建切片会涉及到运行期。1. 切片的大小和容量是否足够小；
切片是否发生了逃逸，最终在堆上初始化。如果切片小的话会先在栈或静态区进行创建。
切片有一个数组的指针，len是指切片的长度, cap指的是切片的容量。
cap是在初始化切片是生成的容量。
发现切片的结构体是数组的地址指针array unsafe.Pointer，而Go中数组的地址代表数组结构体的地址。
slice 中得到一块内存地址，array[0]或者unsafe.Pointer(array[0])。
也可以通过地址构造切片
nil切片：指的unsafe.Pointer 为nil
空切片：
创建的指针不为空，len和cap为空
当一个切片的容量满了，就需要扩容了。怎么扩，策略是什么？
如果原来数组切片的容量已经达到了最大值，再想扩容， Go 默认会先开一片内存区域，把原来的值拷贝过来，然后再执行 append() 操作。这种情况对现数组的地址和原数组地址不相同。
从上面结果我们可以看到，如果用 range 的方式去遍历一个切片，拿到的 Value 其实是切片里面的值拷贝,即浅拷贝。所以每次打印 Value 的地址都不变。
由于 Value 是值拷贝的，并非引用传递，所以直接改 Value 是达不到更改原切片值的目的的，需要通过 slice[index] 获取真实的地址。
Golang中复制结构体，可以使用赋值语句
执行结果
可以看出，roger跟mydog在内存中的地址不同。并且对mydog修改属性，对roger没有影响。
但是注意，这里的Dog结构体中的属性，都是值类型。如果是 引用类型 的话，复制的是 指针 ，而不是具体的值。所以通过赋值语句对结构体的拷贝，是 浅拷贝 。如需对引用类型属性进行深拷贝，可以通过手动创建的方式，或者使用实现了deepcopy功能的第三方包
A：浅拷贝就是成员数据之间的一一赋值：把值赋给一一赋给要拷贝的值。但是可能会有这样的情况：对象还包含资源，这里的资源可以值堆资源，或者一个文件。。当值拷贝的时候，两个对象就有用共同的资源，同时对资源可以访问，这样就会出问题。深拷贝就是用来解决这样的问题的，它把资源也赋值一次，使对象拥有不同的资源，但资源的内容是一样的。对于堆资源来说，就是在开辟一片堆内存，把原来的内容拷贝。
如果你拷贝的对象中引用了某个外部的内容（比如分配在堆上的数据），那么在拷贝这个对象的时候，让新旧两个对象指向同一个外部的内容，就是浅拷贝；如果在拷贝这个对象的时候为新对象制作了外部对象的独立拷贝，就是深拷贝
引用和指针的语义是相似的，引用是不可改变的指针，指针是可以改变的引用。其实都是实现了引用语义。
深拷贝和浅拷贝的区别是在对象状态中包含其它对象的引用的时候，当拷贝一个对象时，如果需要拷贝这个对象引用的对象，则是深拷贝，否则是浅拷贝。
COW语义是“深拷贝”与“推迟计算”的组合，仍然是深拷贝，而非浅拷贝，因为拷贝之后的两个对象的数据在逻辑上是不相关的，只是内容相同。
举个简单的例子：
当你实现一个Composite Pattern，你通常都会实现一个深拷贝(如果需要拷贝的话)，很少有要求同的Composite共享Leaf的；
而当你实现一个Observer Pattern时，如果你需要拷贝Observer,你大概不会去拷贝Subject，这时就要实现个浅拷贝。
是深拷贝还是浅拷贝，并不是取决于时间效率、空间效率或是语言等等，而是取决于哪一个是逻辑上正确的。
1：没有虚方法和虚基类
2：所有直系基类的copy constructor都是无代价的
3：所有成员的copy constructor都是无代价的
这时它的copy constructor是无代价的，相当于用memcpy实现。
判断它是深拷贝还是浅拷贝，还是要根据类的实现。
