易语言变量详解-第二课：继续深入字节集变量和参考

不得不爱2

第一章的时候我说过，字节集变量和字节数组在传递的时候是不同的，不过在此之前，我们先来看看字节集变量的存储方式吧，还是按照之前的方法写

  

子程序名	返回值类型	公开	备 注
测试

变量名	类 型	静态	数组	备 注
字节集变量	字节集
内存地址	整数型
临时字节集	字节集

字节集变量 ＝ { 11, 22, 33 }
内存地址 ＝ 取变量地址 (字节集变量)
调试输出 (内存地址, 取变量数据地址 (字节集变量))
临时字节集 ＝ 指针到字节集 (内存地址, 4)
内存地址 ＝ 取字节集数据 (临时字节集, #整数型, )
调试输出 (内存地址, 指针到字节集 (内存地址, 8 ＋ 3))

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 字节集变量, 字节集<br /> .局部变量 内存地址, 整数型<br /> .局部变量 临时字节集, 字节集<br /> <br /> 字节集变量 ＝ { 11, 22, 33 }<br /> 内存地址 ＝ 取变量地址 (字节集变量)<br /> 调试输出 (内存地址, 取变量数据地址 (字节集变量))<br /> 临时字节集 ＝ 指针到字节集 (内存地址, 4)<br /> 内存地址 ＝ 取字节集数据 (临时字节集, #整数型, )<br /> 调试输出 (内存地址, 指针到字节集 (内存地址, 8 ＋ 3))

开始运行被调试程序
* 1309896 | 1432024
* 1432016 | 字节集:11{1,0,0,0,3,0,0,0,11,22,33}
被调试易程序运行完毕

这次情况和之前很不一样了

首先我们来看下字节集的变量地址和数据地址，他们是不一样的。
我在代码里从变量地址(1309896)读取了长度为4的内存地址，这个内存地址(1432016)和数据地址(1432024)相差8...很奇怪，于是我尝试输出了内存地址里+8+字节集长度的字节集数据来看看。

得到结果
{1,0,0,0,3,0,0,0,11,22,33}
OK,还记得之前说的整数型变量占用长度为4么？我们假设这个变量是由多个数据组合的，那么把它分开看看
{1,0,0,0}
{3,0,0,0}
{11,22,33}
第三个是字节集的真实数据，这点毫无争议。
我们来看下第二组数据，有个3，而我们字节集的长度也是3，那么他存储的可能是字节集的长度。为了做实验我们赋值一个255的空白字节集来试试。

  

子程序名	返回值类型	公开	备 注
测试

变量名	类 型	静态	数组	备 注
字节集变量	字节集
内存地址	整数型
临时字节集	字节集

字节集变量 ＝ 取空白字节集 (255)
内存地址 ＝ 取变量地址 (字节集变量)
临时字节集 ＝ 指针到字节集 (内存地址, 4)
内存地址 ＝ 取字节集数据 (临时字节集, #整数型, )
调试输出 (指针到字节集 (内存地址, 8))

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 字节集变量, 字节集<br /> .局部变量 内存地址, 整数型<br /> .局部变量 临时字节集, 字节集<br /> <br /> 字节集变量 ＝ 取空白字节集 (255)<br /> 内存地址 ＝ 取变量地址 (字节集变量)<br /> 临时字节集 ＝ 指针到字节集 (内存地址, 4)<br /> 内存地址 ＝ 取字节集数据 (临时字节集, #整数型, )<br /> 调试输出 (指针到字节集 (内存地址, 8))

开始运行被调试程序
* 字节集:8{1,0,0,0,255,0,0,0}
被调试易程序运行完毕


可以看出，第二组数据变成了{255,0,0,0}
与字节集长度是一样的，我们可以大胆的猜测，第二组数据的用途就是记录字节集的长度
为了进一步验证我们的想法，我们可以这样做一个实验

  

子程序名	返回值类型	公开	备 注
测试

变量名	类 型	静态	数组	备 注
字节集变量	字节集
内存地址	整数型
临时字节集	字节集

字节集变量 ＝ { 11, 22, 33 }
内存地址 ＝ 取变量地址 (字节集变量)
临时字节集 ＝ 指针到字节集 (内存地址, 4)
内存地址 ＝ 取字节集数据 (临时字节集, #整数型, )
写到内存 ({ 9 }, 内存地址 ＋ 4, 1)
调试输出 (字节集变量)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 字节集变量, 字节集<br /> .局部变量 内存地址, 整数型<br /> .局部变量 临时字节集, 字节集<br /> <br /> 字节集变量 ＝ { 11, 22, 33 }<br /> 内存地址 ＝ 取变量地址 (字节集变量)<br /> 临时字节集 ＝ 指针到字节集 (内存地址, 4)<br /> 内存地址 ＝ 取字节集数据 (临时字节集, #整数型, )<br /> 写到内存 ({ 9 }, 内存地址 ＋ 4, 1)<br /> 调试输出 (字节集变量)

开始运行被调试程序
* 字节集:9{11,22,33,171,171,171,171,171,171}
被调试易程序运行完毕


可以看到，我们明明定义的字节集长度是3，最后输出了长度为9的字节集，由此可以证明字节集变量在内存里，它的内存地址前四位存储的是字节集的长度


不过第一组数据我不管如何的修改字节集，(估计是指的是数组的维数,但是字节集是一维的,不可能是二维或者更多的维数,所以随便怎么修改都没有用),都没什么用，也不知道是干嘛的，具体用途怕是只有吴涛知道了QAQ...或者哪位大神去破J易语言主程序看看内部怎么处理？

duanyijun

不会写代码的只能看看

duanyijun

奥利给奥利给！！

XChuang

6666666666666666666666666666666666666666

不得不爱2

飞翔的淡泊 发表于 2014-6-19 21:44
看不太懂 顶一个

请先从第一课开始看起

飞翔的淡泊

看不太懂 顶一个

大表舅

不得不爱2 发表于 2014-6-19 21:14
不厉害,还差得很远,你看懂了吗

如果视频就好了 现在谁还看文字 = =

不得不爱2

大表舅 发表于 2014-6-19 21:11
顶  你好厉害哈

不厉害,还差得很远,你看懂了吗

大表舅

顶  你好厉害哈

不得不爱2

我们可以简单做一个总结，易语言的字节集变量存储是这样的

变量名对应一个内存地址
通过读取变量名对应的内存地址的四字节内容视为整数处理后+8可以获得字节集变量的数据在内存中的地址
而字节集的长度存储在字节集数据地址前4位。

所以字节集将不能超过4G(因为四位字节所能存储的最大数字相当于4G内存，具体将在深入整数讲解)

接下来我们简单讲下传值，首先看两个范例:

  

子程序名	返回值类型	公开	备 注
测试

变量名	类 型	静态	数组	备 注
字节集变量	字节集
内存地址	整数型
临时字节集	字节集
字节	字节型

子程序1 (字节, 字节集变量)
调试输出 (字节, 字节集变量)

子程序名	返回值类型	公开	备 注
子程序1
参数名	类 型	参考	可空	数组	备 注
字节	字节型
字节集变量	字节集

字节 ＝ 223
字节集变量 ＝ { 223 }

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 字节集变量, 字节集<br /> .局部变量 内存地址, 整数型<br /> .局部变量 临时字节集, 字节集<br /> .局部变量 字节, 字节型<br /> <br /> 子程序1 (字节, 字节集变量)<br /> 调试输出 (字节, 字节集变量)<br /> <br /> .子程序 子程序1<br /> .参数 字节, 字节型<br /> .参数 字节集变量, 字节集<br /> <br /> 字节 ＝ 223<br /> 字节集变量 ＝ { 223 }

开始运行被调试程序
* 0 | 字节集:1{223}
被调试易程序运行完毕

  

子程序名	返回值类型	公开	备 注
测试

变量名	类 型	静态	数组	备 注
字节集变量	字节集
内存地址	整数型
临时字节集	字节集
字节	字节型

子程序1 (字节, 字节集变量)
调试输出 (字节, 字节集变量)

子程序名	返回值类型	公开	备 注
子程序1
参数名	类 型	参考	可空	数组	备 注
字节	字节型
字节集变量	字节集

字节 ＝ 223
字节集变量 ＝ { 223 }

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 字节集变量, 字节集<br /> .局部变量 内存地址, 整数型<br /> .局部变量 临时字节集, 字节集<br /> .局部变量 字节, 字节型<br /> <br /> 子程序1 (字节, 字节集变量)<br /> 调试输出 (字节, 字节集变量)<br /> <br /> .子程序 子程序1<br /> .参数 字节, 字节型, 参考<br /> .参数 字节集变量, 字节集<br /> <br /> 字节 ＝ 223<br /> 字节集变量 ＝ { 223 }

开始运行被调试程序
* 223 | 字节集:1{223}
被调试易程序运行完毕





可以看到，第一个范例里只有字节集被子程序改变了，第二个范例里，字节和字节集都被改变了，区别只是第二个范例里的参考被勾选了

这是为什么呢？
依旧回到内存地址的问题。还记得那句话么？变量是存储在内存地址里的。

当你勾选参考的时候，子程序传递的参数实质上传递的是内存地址，如果不勾选则直接传递值。

举个例子，一个字节，内容是8，地址是12345。
如果你没有使用参考，那么传递给子程序的时候传递的是8这个数值，然后子程序里修改，实际上并没有修改变量实际上的数值

然而如果你勾选了参考，那么实际上传递给子程序的是8所在的内存地址，也就是12345。当子程序里修改内容的时候，修改的是变量地址12345里的内容，这时变量的数值就被修改了，所以第二张图里字节变成了255


在易语言内，字节集，文本，数组，自定义数据类型他们无论是否使用参考(传址)，他们都将通过参考的方式传递，具体把鼠标放在参考的方框上就会有介绍。这也是为什么不勾选参考字节集也可以通过子程序修改的原因。

不过之所以说字节型数组和字节集不同，具体可能要到自定义数据类型的时候才会给出解答了←w← 不要在意细节

嘛，最后我们来讲讲字节集最后一个细节吧。字节集的相加

我们已经知道了，字节集是存储在内存地址里的，比如内存1里存储的{1,2,3}，内存地址2里存储的{4,5,6}
如果我们使用 字节集1+字节集2可以得到一个{1,2,3,4,5,6}结果的字节集。
但是实际上是怎么回事呢？难道是将两段不相关联的内存拼接在一起么？这很明显是不科学的。我们继续来测试下

  

子程序名	返回值类型	公开	备 注
测试

变量名	类 型	静态	数组	备 注
字节集变量	字节集
内存地址	整数型
临时字节集	字节集
字节	字节型

字节集变量 ＝ { 1, 2, 3 }
临时字节集 ＝ { 4, 5, 6 }
调试输出 (取变量地址 (字节集变量), 取变量数据地址 (字节集变量))
字节集变量 ＝ 字节集变量 ＋ 临时字节集
调试输出 (取变量地址 (字节集变量), 取变量数据地址 (字节集变量))

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 字节集变量, 字节集<br /> .局部变量 内存地址, 整数型<br /> .局部变量 临时字节集, 字节集<br /> .局部变量 字节, 字节型<br /> <br /> 字节集变量 ＝ { 1, 2, 3 }<br /> 临时字节集 ＝ { 4, 5, 6 }<br /> 调试输出 (取变量地址 (字节集变量), 取变量数据地址 (字节集变量))<br /> 字节集变量 ＝ 字节集变量 ＋ 临时字节集<br /> 调试输出 (取变量地址 (字节集变量), 取变量数据地址 (字节集变量))

开始运行被调试程序
* 1309896 | 1432024
* 1309896 | 1432384
被调试易程序运行完毕

可以看到，两次变量地址并没有区别，但是变量数据地址并不相同。

我们可以大胆推测一下易语言字节集相加的过程：
首先获取第一个字节集的长度（访问字节集数据地址前4位）
获取第二个字节集的长度
将两个长度相加获得新字节集的长度
申请一段和两个新字节集长度+8长度的内存
为新申请的内存里的 4～8的位置写入新字节集的长度
将第一个字节集内容复制到新字节集，然后释放第一个字节集
将第二个字节集内容复制到新字节集后面，然后释放第二个字节集
最后，变量地址里指向的内存地址修改成新内存的地址

不过很不幸，本人基本不会逆向，也没办法验证猜想了，所以说这只是一个猜想QwQ

基本上字节集就讲到这里吧，还有一些细节我也不知道真是抱歉了QAQ