皮皮网

1.tn6文件的重底重底的源代码怎么看，或者是源码怎么把指标从电脑版通达信的导入手机通达信
2.经久不倒的金典“老鸭头”战法+老鸭头选股器，值得收藏、什意思转发！重底重底
3.Go看源码必会知识之unsafe包

tn6文件的源码的源代码怎么看，或者是什意思同花顺 统计涨停 源码怎么把指标从电脑版通达信的导入手机通达信

       一、手机版指标导入流程图解

       这里要清楚一点手机版不能使用选股指标，重底重底选股指标只能通过电脑版使用的源码。代码判断iphone型号4 5 6 6plus

       第一步：打开通达信手机版软件。什意思这里我就不贴了，重底重底我相信没有人做不到打不开通达信手机版软件。源码

       第二步：打开通达信手机版软件之后选择行情界面，什意思然后随便打开一只个股日线图

       第三步：在打开的重底重底日线图上选择指标名称点击一下，主图和幅图一样的源码

       第四步：选择指标编辑，然后选择新建指标。什意思重点说一下，这个位置要切换指标的话可以直接选择下方的指标名称。

       第五步：填写指标名称并选择主图还是幅图指标，然后点击公式编辑

       第六步：直接复制源码点击保存就可以了。

       电脑版指标导入教程

       第一步：打开通达信电脑版软件选择功能——公示系统——公式管理器

       第二步：新建指标，这里重点说一下技术指标就选择技术指标新建，选股指标就选择选股指标新建。

       第三步：粘贴指标源码选择指标位置，点击确定

       第四步：TN6格式导入

       二、电脑版指标安装

       电脑版指标安装分为两种方式，一种是直接导入公式，一种是复制粘贴源代码。

       首先登录电脑版通达信软件，随便点开一只股票。在右下角点击"更多”，再点击“公式管理”打开公式管理器（也可点击左上角系统--公式系统--公式管理器），打开后我们先来讲解第一种安装方式。

       1、直接导入公式

       打开指标公式文件后，会弹出一个界面让你勾选所属指标类型，大类和小类都打上勾，再点击“确定”。这样，导入指标公式就完成了。

       完成导入公式后，可以再打开“公式管理”界面，找到你刚才所勾选的大类小类名下新增的指标公式。比如我新增的“小情人指标”是勾选了放在大类（技术指标公式）和小类（均线型）下，依次打开这两个选项就可以找到“小情人指标（用户）”，选中指标公式，还可以点击右上角的“加入常用”，这样此指标就会出现在右下角的指标栏上，方便直接调用。

       特别注意：指标公式后缀是tn6，可以正常导入。如果是从网上下载别人分享的指标公式，要特别注意下后缀，有些文件不能导入，还要避免胡乱下载使电脑中毒。

       2、复制粘贴源代码

       同样打开“公式管理”界面，首先先选择你的指标要放在哪个大类和小类，比如先点开大类（技术指标公式），再点击选中小类（其他类型）。注意：鼠标一定要选中小类（其他类型）后，再去点击右上角“新建”指标。

       点击“新建”后，会显示指标公式编辑器。将公式名称填好，再选择画线方式，如果你是新增主图指标，就选择”主图叠加“，如果是新增副图指标，就选择”副图“。此外，还要特别注意：如果你新增的指标是有参数的，必须将参数设置一并填好。再在界面空白处复制粘贴进去你的视频专题源码指标源代码。

       最后，点击右上角的”测试公式“对你的新增指标进行测试，测试结果会在最下方显示。通过的话，一定要记得去点击右上角的”确定“按钮，这样你的新增指标就完成了。如何找到你新增的这个指标方法同上，此处不再赘述。

龙腾四海指标是什么东西，哪里有下载的

       指标源代码中的语法错误、指标源代码的版本兼容性。

       1、指标源代码中的语法错误。通达信手机版导入指标源代码前需要确认代码的正确性，代码中有语法错误会导致导入失败。

       2、指标源代码的版本兼容性。通达信手机版支持的指标版本不同，指标源代码的版本与手机版不兼容会导致导入失败。

哪位高手能写出macd上面那指标的源代码？图为 在8月底到月9号的指标形态。

       龙腾四海是益盟操盘手软件里的一个逃顶指标，可以在>

       RSV:=(CLOSE-LLV(LOW,5))/(HHV(HIGH,5)-LLV(LOW,5));

       K:SMA(RSV,3,1);

       D:SMA(K,3,1);

       ;

经久不倒的金典“老鸭头”战法+老鸭头选股器，值得收藏、转发！

       所谓老鸭头是庄家老高放量再次建仓后，借助外力向下打压股价，破坏原有的拉升走势。其目的就是为了洗出获利盘。然后股价进入短期调整，调整完毕后进行更猛烈的上攻。这个过程所形成的的图形我们称之为老鸭头。

       老鸭头技术形态：

       1股价经过 一波上涨，当5、日均线放量上穿日均线时形成鸭颈部。

       2股价上涨后出现回落，回落时的高点形成鸭头部。

       3当股价回落后，5、日均线形成金叉，且均线斜率向上，形成鸭嘴部。

       日均线死叉日均线后又金叉日所形成的的孔为鸭鼻孔。

       从上图我们可以看出老鸭头的买卖点

       1在5、日均线放量上穿日均线形成鸭颈部时可以买入。

       2在鸭嘴部出现芝麻量（低量）时可以逢低买入。

       3在股价放量上冲时突破鸭头位置买入。

       老鸭头形态市场上比不少见，如何快速挑选出老鸭头，这时老鸭头选股器就能帮我们快速选股。

       这样就可以快速选出老鸭头形态的股票。关于老鸭头今天就讲到这里，喜欢的朋友可以转发、收藏。至于选股器源码我就不发了，老有朋友说我发的源码显示错误，我也好无奈啊┭┮﹏┭┮ 喜欢的朋友可以留言。

老鸭头是日k线还是周k线？新手须知

       庄家经过拉高洗盘后第二波行情的到来。

       股市有句话叫千金难买老鸭头,这种技术形态往往预示着庄家经过拉高洗盘后第二波行情的到来。老鸭头是庄家建仓、洗盘、拉高等一系列行为所形成的经典形态。

       辨别该形态时，经过一波上涨后的“鸭脑壳”要离开日均线一定的距离，否则会表明主力资金建仓意愿不是特别强，会影响后续走势，而且在老鸭头形态构建中，上涨时的成交量必须要放大。

老鸭头洗盘多久

       目前鸭头的应用场景多为其日线形态，也有周线形态。但因为鸭头是短期上涨浪，所以周线形态的走势并不明显。

       总的卖源码挣钱来说，这样的数字是均线配合产生的。当5日和日均线的成交量穿过日均线时，形成了鸭脖；股价回落，高点形成鸭头，主力减少洗盘量形成鸭鼻孔。当股价很快回落时，5日和日的均线再次交叉金叉形成鸭嘴。这样一个标准的鸭头就形成了。

       在我们的实际应用中，需要注意很多问题。一般来说，这样的图形容易在高位形成连续盘整的三重峰值。所以在震荡中，抄底买入的投资者看到有盈利就开始减仓。被卡在原来下跌通道的股民看到股价停止上涨，有下滑趋势，也开始走出陷阱。与此同时，巨大的获利盘脱钩而抓，导致鸭头造型失败。

       一般情况下，老鸭头有效形态的编辑认为有三个重要特征：第一，5日、日均线黄金交叉点与日均线的距离越大越好，因为这意味着个股强势；第二，个股的成交量在突破关口越小越好，也就是说成交量可以在这里积累，5日、日均线很容易上穿日均线形成买点；第三，一定要注意洗盘后股价不能跌破均线，这样在个股上涨时，才有放量突破鸭头的可能。

老鸭头股票一般能涨多少

       三至六个月。

       老鸭头是股市的一个战法，这种技术形态往往表明主力经过第一轮拉升后，然后进行拉高洗盘。一般热点股的洗盘时间在5天左右即可。而该战法较为复杂，这种情况下是属于大盘绩优股的中级洗盘，往往要耗时3至6个月。

       老鸭头是短线主力造就一种经典技术形态，通常是主力经过建仓、洗盘、拉高等一系列行为之后所作成的。大量的数据表明，一旦真正的老鸭头形态形成。个股的上涨往往具有很大的额潜力，短线投资者可积极跟进，往往能捕获一段酣畅淋漓的上涨行情。

老鸭头k线形态会涨多少

       老鸭头一般涨幅从%到%以上不等，它主要是多方面因素影响的。

       1、股市中的老鸭头涨幅多数情况下和该股前期的盘整时间、调整K线形态、成交密集带、庄家的持筹量、庄家的资金量、市场行情有极大的关系，这些因素往往会影响到庄家的操作，进而影响到股价。多数情况下，当庄家开始收集筹码，股价缓慢上升，5日、日均线放量上涨，形成鸭颈部。然后随着其震仓洗筹股价开始回档，股价的高点形成鸭头顶。最后庄家再度建仓收集筹码时，股价再次上升，形成鸭嘴部。经过这样的棋牌观战源码操作，老鸭头形态才会形成，因此这个时间里面就有不少的变动因素。

       2、老鸭头盘整的时间越长，往往会导致人气涣散，这样庄家在第二次进行拉升的时候就缺少跟风，涨幅受限。

       3、调整K线形态若是比较平稳，那么庄家拉升会较为简单，反而K线走势极为复杂，那么反映到庄家层面就是拉升阻力极大，涨幅受限。

       4、老鸭头前期的密集成交带往往会积累大量的套牢盘，这些筹码会在拉升的时候造成抛压，庄家实力不强那么该老鸭头涨幅受限。

       5、庄家持筹量决定着老鸭头的高度，筹码越多相对应地必须要拉升足够高庄家才有空间出货。

       6、庄家资金量和持筹量基本类似，庄家资金量的多少决定着其突破盘整地带的力度和该股最终的涨幅。

       7、市场行情往往是投资者愿意追涨最为本质的原因，所以好马配好鞍，老鸭头个股最终的涨幅离不开投资者不断地追高。

       ：股票(stock)是股份公司所有权的一部分，也是发行的所有权凭证，是股份公司为筹集资金而发行给各个股东作为持股凭证并借以取得股息和红利的一种有价证券。股票是资本市场的长期信用工具，可以转让，买卖，股东凭借它可以分享公司的利润，但也要承担公司运作错误所带来的风险。每股股票都代表股东对企业拥有一个基本单位的所有权。每家上市公司都会发行股票。

周线老鸭头后市如何？

       老鸭头一般涨幅从%到%以上不等，它主要是多方面因素影响的。K线形态的形态1分为红三兵、圆弧底、“V”字型底部、反转十字星、“W”底（双重底）、头肩底股价、低位档五阳线；K线形态2分为芝麻开花、背水一战、趁热打铁等类型。

       K线的形态有：红三兵，在暴跌行情之后，空方已无力继续打低股价，股价在低价区呈“一”字形窄幅波动，小阳线与小阴线交替出现，成交量萎缩。经过较长时间整理之后，多方积蓄了足够上升的能量，伴随着成交量的均匀放大，盘面出现连续上升的三根小阳线，使股价突破盘局开始上升。这三根小阳线称为“红三兵”，它的出现预示着后市大幅上升的可能性很大。圆弧底，随着股价逐渐被打低，空方能量消耗极大，多空双方进入对峙阶段，此时股价走势平稳，成交量萎缩。继而多方进一步反攻，伴随着成交量的放大，股价逐步上升，连续突破三条移动平均线的压力，并创出近期新高，极无双源码说明多方已占据主导优势，股价后市必将上涨。“V”字型底部，当空方连续将股价打低做空能量耗竭时，多方立即发起反攻，不给空方喘息的机会，在成交量的配合下，将股价逐步推高，形成“V”字形上升趋势。

       “W”底（双重底），空方连续三根阴线，打压能量殆尽，多方发起反攻，但在前期密集成交区的高度受阻回落，但股价却未跌破前期低点，接着，多方再次发起反攻，一举突破前期阻力位，逐步走高。当股价从第二谷底上升超过顶点价格的3%，可视为有效突破。股价的这种走势形成双底，为后市上升打下伏笔。头肩底股价，经过长期下跌后，成交量明显减少，股价走缓并略有反弹，成交量略有增加，形成左肩。紧接着继续下跌探底，遇到多方反攻，成交量迅速放大，股价回升超过左肩低价位，形成头肩底，又再次回档下探，形成另一个底部即右肩，此底部不低于头肩底。

       后市看涨！

       周线老鸭头

       一只股票在经过一波较大的中期上涨后，如果经过二个月左右的缩量整理，又开始了一波上涨行情，而当股价越过前期高点时，周线IVlACI)也从死叉回到了金叉，这就是周线“老鸭头”走势，是投资者买人股票的大好时机，也是一种十分经典的中线投资方法。

       一、形成条件

       1、股票大幅上涨后的整理时间在二个月之内；

       2、月线MACD 处于金叉位置，周线的MACD 死叉后又形成金叉，且都在O 轴上方；

       3、周线的MACD从死叉回到新的金叉必须在 周之内；

       4、股价下跌整理时成交量明显萎缩。

       二、市场意义

       股价经过大幅上涨后开始调整，周线的MACD 形成死叉，此时股价的高点就是“老鸭头”的头部，当股价经过5 周之内的下跌后，成交量明显萎缩，说明主力资金看好后市，还处于洗盘过程中，此后股价又迅速重新上升，周线MACD 又形成金叉，说明洗盘结束，股价又继续上涨，当股价上涨到前期高点时，这一段的上涨期就形成了“老鸭头”的“鸭嘴”，股价的新一浪上涨周期又要开始了。

       三、买入时机

       股价在周线形成“老鸭头”形态后，日MACD 也形成金叉时买入，中线持有。

       四，注意事项

       1、周线“老鸭头”形成后，半年内股价的上涨幅度在％ 左右；

       2、MACD 指标从死叉重新金叉，必须在 周内，且金叉时周线的收盘价已创出新高；

       3、如果周K 线在 周线附近形成“老鸭头”走势，则上涨力度更加大。

Go看源码必会知识之unsafe包

       前言

       有看源码的朋友应该会发现，Go标准库中大量使用了unsafe.pointer，要想更好的理解源码实现，就要知道unsafe.pointer到底是什么？所以今天就与大家来聊一聊unsafe包。

什么是unsafe

       众所周知，Go语言被设计成一门强类型的静态语言，那么他的类型就不能改变了，静态也是意味着类型检查在运行前就做了。所以在Go语言中是不允许两个指针类型进行转换的，使用过C语言的朋友应该知道这在C语言中是可以实现的，Go中不允许这么使用是处于安全考虑，毕竟强制转型会引起各种各样的麻烦，有时这些麻烦很容易被察觉，有时他们却又隐藏极深，难以察觉。大多数读者可能不明白为什么类型转换是不安全的，这里用C语言举一个简单的例子：

int main(){ double pi = 3.;double *pv = πvoid *temp = pd;int *p = temp;}

       在标准C语言中，任何非void类型的指针都可以和void类型的指针相互指派，也可以通过void类型指针作为中介，实现不同类型的指针间接相互转换。上面示例中，指针pv指向的空间本是一个双精度数据，占8个字节，但是经过转换后，p指向的是一个4字节的int类型。这种发生内存截断的设计缺陷会在转换后进行内存访问是存在安全隐患。我想这就是Go语言被设计成强类型语言的原因之一吧。

       虽然类型转换是不安全的，但是在一些特殊场景下，使用了它，可以打破Go的类型和内存安全机制，可以绕过类型系统低效，提高运行效率。所以Go标准库中提供了一个unsafe包，之所以叫这个名字，就是不推荐大家使用，但是不是不能用，如果你掌握的特别好，还是可以实践的。

unsafe 实现原理

       在使用之前我们先来看一下unsafe的源码部分，标准库unsafe包中只提供了3``种方法，分别是:

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr

       Sizeof(x ArbitrayType)方法主要作用是用返回类型x所占据的字节数，但并不包含x所指向的内容的大小，与C语言标准库中的Sizeof()方法功能一样，比如在位机器上，一个指针返回大小就是4字节。

       Offsetof(x ArbitraryType)方法主要作用是返回结构体成员在内存中的位置离结构体起始处(结构体的第一个字段的偏移量都是0)的字节数，即偏移量，我们在注释中看一看到其入参必须是一个结构体，其返回值是一个常量。

       Alignof(x ArbitratyType)的主要作用是返回一个类型的对齐值，也可以叫做对齐系数或者对齐倍数。对齐值是一个和内存对齐有关的值，合理的内存对齐可以提高内存读写的性能。一般对齐值是2^n，最大不会超过8(受内存对齐影响).获取对齐值还可以使用反射包的函数，也就是说：unsafe.Alignof(x)等价于reflect.TypeOf(x).Align()。对于任意类型的变量x，unsafe.Alignof(x)至少为1。对于struct结构体类型的变量x，计算x每一个字段f的unsafe.Alignof(x，f)，unsafe.Alignof(x)等于其中的最大值。对于array数组类型的变量x，unsafe.Alignof(x)等于构成数组的元素类型的对齐倍数。没有任何字段的空struct{ }和没有任何元素的array占据的内存空间大小为0，不同大小为0的变量可能指向同一块地址。

       细心的朋友会发发现这三个方法返回的都是uintptr类型，这个目的就是可以和unsafe.poniter类型相互转换，因为*T是不能计算偏移量的，也不能进行计算，但是uintptr是可以的，所以可以使用uintptr类型进行计算，这样就可以可以访问特定的内存了，达到对不同的内存读写的目的。三个方法的入参都是ArbitraryType类型，代表着任意类型的意思，同时还提供了一个Pointer指针类型，即像void *一样的通用型指针。

type ArbitraryType inttype Pointer *ArbitraryType// uintptr 是一个整数类型，它足够大，可以存储type uintptr uintptr

       上面说了这么多，可能会有点懵，在这里对三种指针类型做一个总结：

       *T：普通类型指针类型，用于传递对象地址，不能进行指针运算。

       unsafe.poniter：通用指针类型，用于转换不同类型的指针，不能进行指针运算，不能读取内存存储的值(需转换到某一类型的普通指针)

       uintptr：用于指针运算，GC不把uintptr当指针，uintptr无法持有对象。uintptr类型的目标会被回收。

       三者关系就是：unsafe.Pointer是桥梁，可以让任意类型的指针实现相互转换，也可以将任意类型的指针转换为uintptr进行指针运算，也就说uintptr是用来与unsafe.Pointer打配合，用于指针运算。画个图表示一下：

       基本原理就说到这里啦，接下来我们一起来看看如何使用~

unsafe.Pointer基本使用

       我们在上一篇分析atomic.Value源码时，看到atomic/value.go中定义了一个ifaceWords结构，其中typ和data字段类型就是unsafe.Poniter，这里使用unsafe.Poniter类型的原因是传入的值就是interface{ }类型，使用unsafe.Pointer强转成ifaceWords类型，这样可以把类型和值都保存了下来，方便后面的写入类型检查。截取部分代码如下：

// ifaceWords is interface{ } internal representation.type ifaceWords struct { typunsafe.Pointer data unsafe.Pointer}// Load returns the value set by the most recent Store.// It returns nil if there has been no call to Store for this Value.func (v *Value) Load() (x interface{ }) { vp := (*ifaceWords)(unsafe.Pointer(v))for { typ := LoadPointer(&vp.typ) // 读取已经存在值的类型/**..... 中间省略**/// First store completed. Check type and overwrite data.if typ != xp.typ { //当前类型与要存入的类型做对比 panic("sync/atomic: store of inconsistently typed value into Value")}}

       上面就是源码中使用unsafe.Pointer的一个例子，有一天当你准备读源码时，unsafe.pointer的使用到处可见。好啦，接下来我们写一个简单的例子，看看unsafe.Pointer是如何使用的。

func main(){ number := 5 pointer := &number fmt.Printf("number:addr:%p, value:%d\n",pointer,*pointer) floatNumber := (*float)(unsafe.Pointer(pointer)) *floatNumber = *floatNumber + 3 fmt.Printf("float:addr:%p, value:%f\n",floatNumber,*floatNumber)}

       运行结果：

number:addr:0xc, value:5float:addr:0xc, value:3.

       由运行可知使用unsafe.Pointer强制类型转换后指针指向的地址是没有改变，只是类型发生了改变。这个例子本身没什么意义，正常项目中也不会这样使用。

       总结一下基本使用：先把*T类型转换成unsafe.Pointer类型，然后在进行强制转换转成你需要的指针类型即可。

Sizeof、Alignof、Offsetof三个函数的基本使用

       先看一个例子：

type User struct { Name string Age uint Gender bool // 男:true 女：false 就是举个例子别吐槽我这么用。。。。}func func_example(){ // sizeof fmt.Println(unsafe.Sizeof(true)) fmt.Println(unsafe.Sizeof(int8(0))) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof(int())) fmt.Println(unsafe.Sizeof("asong")) fmt.Println(unsafe.Sizeof([]int{ 1,3,4})) // Offsetof user := User{ Name: "Asong", Age: ,Gender: true} userNamePointer := unsafe.Pointer(&user) nNamePointer := (*string)(unsafe.Pointer(userNamePointer)) *nNamePointer = "Golang梦工厂" nAgePointer := (*uint)(unsafe.Pointer(uintptr(userNamePointer) + unsafe.Offsetof(user.Age))) *nAgePointer = nGender := (*bool)(unsafe.Pointer(uintptr(userNamePointer)+unsafe.Offsetof(user.Gender))) *nGender = false fmt.Printf("u.Name: %s, u.Age: %d,u.Gender: %v\n", user.Name, user.Age,user.Gender) // Alignof var b bool var i8 int8 var i int var i int var f float var s string var m map[string]string var p *int fmt.Println(unsafe.Alignof(b)) fmt.Println(unsafe.Alignof(i8)) fmt.Println(unsafe.Alignof(i)) fmt.Println(unsafe.Alignof(i)) fmt.Println(unsafe.Alignof(f)) fmt.Println(unsafe.Alignof(s)) fmt.Println(unsafe.Alignof(m)) fmt.Println(unsafe.Alignof(p))}

       为了省事，把三个函数的使用示例放到了一起，首先看sizeof方法，我们可以知道各个类型所占字节大小，这里重点说一下int类型，Go语言中的int类型的具体大小是跟机器的 CPU位数相关的。如果 CPU 是 位的，那么int就占4字节，如果 CPU是位的，那么 int 就占8 字节，这里我的电脑是位的，所以结果就是8字节。

       然后我们在看Offsetof函数，我想要修改结构体中成员变量，第一个成员变量是不需要进行偏移量计算的，直接取出指针后转换为unsafe.pointer，在强制给他转换成字符串类型的指针值即可。如果要修改其他成员变量，需要进行偏移量计算，才可以对其内存地址修改，所以Offsetof方法就可返回成员变量在结构体中的偏移量，也就是返回结构体初始位置到成员变量之间的字节数。看代码时大家应该要住uintptr的使用，不可以用一个临时变量存储uintptr类型，前面我们提到过用于指针运算，GC不把uintptr当指针，uintptr无法持有对象。uintptr类型的目标会被回收，所以你不知道他什么时候会被GC掉，那样接下来的内存操作会发生什么样的错误，咱也不知道。比如这样一个例子：

// 切记不要这样使用p1 := uintptr(userNamePointer)nAgePointer := (*uint)(unsafe.Pointer(p1 + unsafe.Offsetof(user.Age)))

       最后看一下Alignof函数，主要是获取变量的对齐值，除了int、uintptr这些依赖CPU位数的类型，基本类型的对齐值都是固定的，结构体中对齐值取他的成员对齐值的最大值，结构体的对齐涉及到内存对齐，我们在下面详细介绍。

经典应用：string与[]byte的相互转换

       实现string与byte的转换，正常情况下，我们可能会写出这样的标准转换：

// string to []bytestr1 := "Golang梦工厂"by := []byte(s1)// []byte to stringstr2 := string(by)

       使用这种方式进行转换都会涉及底层数值的拷贝，所以想要实现零拷贝，我们可以使用unsafe.Pointer来实现，通过强转换直接完成指针的指向，从而使string和[]byte指向同一个底层数据。在reflect包中有·string和slice对应的结构体，他们的分别是：

type StringHeader struct { Data uintptr Lenint}type SliceHeader struct { Data uintptr Lenint Capint}

       StringHeader代表的是string运行时的表现形式(SliceHeader同理)，通过对比string和slice运行时的表达可以看出，他们只有一个Cap字段不同，所以他们的内存布局是对齐的，所以可以通过unsafe.Pointer进行转换，因为可以写出如下代码：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr0

       上面的代码我们通过重新构造slice header和string header完成了类型转换，其实[]byte转换成string可以省略掉自己构造StringHeader的方式，直接使用强转就可以，因为string的底层也是[]byte，强转会自动构造，省略后的代码如下：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr1

       虽然这种方式更高效率，但是不推荐大家使用，前面也提高到了，这要是不安全的，使用当不当会出现极大的隐患，一些严重的情况recover也不能捕获。

内存对齐

       现在计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但是实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就对齐。

       对齐的作用和原因：CPU访问内存时，并不是逐个字节访问，而是以字长（word size)单位访问。比如位的CPU，字长为4字节，那么CPU访问内存的单位也是4字节。这样设计可以减少CPU访问内存的次数，加大CPU访问内存的吞吐量。假设我们需要读取8个字节的数据，一次读取4个字节那么就只需读取2次就可以。内存对齐对实现变量的原子性操作也是有好处的，每次内存访问都是原子的，如果变量的大小不超过字长，那么内存对齐后，对该变量的访问就是原子的，这个特性在并发场景下至关重要。

       我们来看这样一个例子：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr2

       从结果可以看出，字段放置不同的顺序，占用内存也不一样，这就是因为内存对齐影响了struct的大小，所以有时候合理的字段可以减少内存的开销。下面我们就一起来分析一下内存对齐，首先要明白什么是内存对齐的规则，C语言的对齐规则与Go语言一样，所以C语言的对齐规则对Go同样适用：

       对于结构的各个成员，第一个成员位于偏移为0的位置，结构体第一个成员的偏移量（offset）为0，以后每个成员相对于结构体首地址的 offset 都是该成员大小与有效对齐值中较小那个的整数倍，如有需要编译器会在成员之间加上填充字节。

       除了结构成员需要对齐，结构本身也需要对齐，结构的长度必须是编译器默认的对齐长度和成员中最长类型中最小的数据大小的倍数对齐。

       好啦，知道规则了，我们现在来分析一下上面的例子，根据我的mac使用的位CPU,对齐参数是8来分析，int、[]int、string、bool对齐值分别是4、8、8、1，占用内存大小分别是4、、、1，我们先根据第一条对齐规则分析User1：

       第一个字段类型是int，对齐值是4，大小为4，所以放在内存布局中的第一位.

       第二个字段类型是[]int，对齐值是8，大小为，所以他的内存偏移值必须是8的倍数，所以在当前user1中，就不能从第4位开始了，必须从第5位开始，也就偏移量为8。第4,5,6,7位由编译器进行填充，一般为0值，也称之为空洞。第9位到第位为第二个字段B.

       第三个字段类型是string，对齐值是8，大小为，所以他的内存偏移值必须是8的倍数，因为user1前两个字段就已经排到了第位，所以下一位的偏移量正好是，正好是字段C的对齐值的倍数，不用填充，可以直接排列第三个字段，也就是从第位到位第三个字段C.

       第三个字段类型是bool，对齐值是1，大小为1，所以他的内存偏移值必须是1的倍数，因为user1前两个字段就已经排到了第位，所以下一位的偏移量正好是。正好是字段D的对齐值的倍数，不用填充，可以直接排列到第四个字段，也就是从到第位是第三个字段D.

       好了现在第一条内存对齐规则后，内存长度已经为字节，我们开始使用内存的第2条规则进行对齐。根据第二条规则，默认对齐值是8，字段中最大类型程度是，取最小的那一个，所以求出结构体的对齐值是8，我们目前的内存长度是，不是8的倍数，所以需要补齐，所以最终的结果就是，补了7位。

       说了这么多，画个图看一下吧：

       现在你们应该懂了吧，按照这个思路再去分析其他两个struct吧，这里就不再分析了。

       对于内存对齐这里还有一最后需要注意的知识点，空struct不占用任何存储空间，空 struct{ } 大小为 0，作为其他 struct 的字段时，一般不需要内存对齐。但是有一种情况除外：即当 struct{ } 作为结构体最后一个字段时，需要内存对齐。因为如果有指针指向该字段, 返回的地址将在结构体之外，如果此指针一直存活不释放对应的内存，就会有内存泄露的问题（该内存不因结构体释放而释放）。来看一个例子：

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr3

       简单来说，对于任何占用0大小空间的类型，像struct { }或者[0]byte这些，如果该类型出现在结构体末尾，那么我们就假设它占用1个字节的大小。因此对于test1结构体，他看起来就是这样：`

func Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr4

       因此在内存对齐时，最后结构体占用的字节就是8了。

       重点要注意的问题：不要在结构体定义的最后添加零大小的类型

总结

       好啦，终于又到文章的末尾了，我们来简单的总结一下，unsafe 包绕过了 Go 的类型系统，达到直接操作内存的目的，使用它有一定的风险性。但是在某些场景下，使用 unsafe 包提供的函数会提升代码的效率，Go 源码中也是大量使用 unsafe 包。

       unsafe 包定义了 Pointer 和三个函数：

type ArbitraryType inttype Pointer *ArbitraryTypefunc Sizeof(x ArbitraryType) uintptrfunc Offsetof(x ArbitraryType) uintptrfunc Alignof(x ArbitraryType) uintptr

       uintptr 可以和 unsafe.Pointer 进行相互转换，uintptr 可以进行数学运算。这样，通过 uintptr 和 unsafe.Pointer 的结合就解决了 Go 指针不能进行数学运算的限制。通过 unsafe 相关函数，可以获取结构体私有成员的地址，进而对其做进一步的读写操作，突破 Go 的类型安全限制。

       最后我们又学习了内存对齐的知识，这样设计可以减少CPU访问内存的次数，加大CPU访问内存的吞吐量，所以结构体中字段合理的排序可以更节省内存，注意：不要在结构体定义的最后添加零大小的类型。

原文：/post/

       好啦，这篇文章就到这里啦，素质三连（分享、点赞、在看）都是笔者持续创作更多优质内容的动力！

       创建了一个Golang学习交流群，欢迎各位大佬们踊跃入群，我们一起学习交流。入群方式：加我vx拉你入群，或者公众号获取入群二维码

       结尾给大家发一个小福利吧，最近我在看[微服务架构设计模式]这一本书，讲的很好，自己也收集了一本PDF，有需要的小伙可以到自行下载。获取方式：关注公众号：[Golang梦工厂]，后台回复：[微服务]，即可获取。

       我翻译了一份GIN中文文档，会定期进行维护，有需要的小伙伴后台回复[gin