易语言变量详解-第四课：变量，数组和自定义数据类型

不得不爱2

首先，先说说文本型变量

  

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

变量名	类 型	静态	数组	备 注
文本变量	文本型
变量地址	整数型

文本变量 ＝ “abc”
变量地址 ＝ 取变量地址 (文本变量)
调试输出 (变量地址, 取变量数据地址 (文本变量))
变量地址 ＝ 取字节集数据 (指针到字节集 (变量地址, 4), #整数型, )
调试输出 (变量地址, 指针到字节集 (变量地址, 取文本长度 (文本变量)))

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 文本变量, 文本型<br /> .局部变量 变量地址, 整数型<br /> <br /> 文本变量 ＝ “abc”<br /> 变量地址 ＝ 取变量地址 (文本变量)<br /> 调试输出 (变量地址, 取变量数据地址 (文本变量))<br /> 变量地址 ＝ 取字节集数据 (指针到字节集 (变量地址, 4), #整数型, )<br /> 调试输出 (变量地址, 指针到字节集 (变量地址, 取文本长度 (文本变量)))

开始运行被调试程序
* 1309896 | 11403524
* 11403524 | 字节集:3{97,98,99}
被调试易程序运行完毕

和字节集不同的是，这次变量指向的地址就是数据地址了，不用再+8了

不过这样的话有一个问题：易语言又是如何来确定文本在内存中何时结束的呢？
答案很简单，依靠文本终止符{0}。
当易语言试图将一个变量地址解释为文本的时候，易语言会遍历这个地址里的字节集，直到遇到 0字节为止。
[e=2].版本 2
.支持库 spec


.子程序 测试
.局部变量 文本变量, 文本型
.局部变量 变量地址, 整数型


文本变量 ＝ “abc”
调试输出 (到字节集 (文本变量), 到文本 ({ 97, 98, 99, 0 }), 到文本 ({ 97, 0, 98, 99 }))

[e]
开始运行被调试程序
* 字节集:3{97,98,99} | “abc” | “a”
被调试易程序运行完毕


可以看到abc对应的字节集分别是97,98,99
然后我尝试直接传递这个字节集让易语言转换成文本，结果成功的输出了abc
然后我在他们中间，也就是a对应的97后面插入了一个文本终止符{0}
结果到文本转换下来只剩下a...其他的数据丢失了


这也是我在贴吧再三再三强调的为什么数据加密后不能用到文本存储的原因。
数据加密后会不会出现{0}根本没有人可以保证，如果出现的话转换到文本...数据丢失...然后尝试转换回去解密...你懂的=w=


至于说文本变量的相加...请参考字节集变量。文本变量在相加后内存地址也是会变化的。


文本基本上注意点就是这样了。然后简单说下剩下的几个变量吧


日期时间型 8字节
小数型 4字节
双精度小数型 8字节
逻辑型 4字节
子程序指针 4字节

剩下的几个变量其实已经没什么好讲的了
逻辑型特别简单，0=假，非0=真，或者可以当成{0,0,0,0}=假 非0值都是真，比如{1,0,0,0}甚至改成{255,255,255,255}，结果都是 真。具体上就不做演示了

日期时间型...嘛，存储为双精度小数型,起始时间为 1899年12月30日0时0分0秒  双精度1.0就代表 1.0天+1899年12月30日0时0分0秒=1899年12月31日0时0分0秒

小数型/双精度小数型....嘛，这个就自己百度下吧 .(小数型是32位,双精度小数是64位)
IEEE754两种浮点数的格式参数

类型	位符(s)	阶码(e)	尾数 (m)	总位数
小数型	1	8	23	32
双精度小数型	1	11	52	64

对于阶码为0或为255（2047）的情况，IEEE有特殊的规定：
如果 E 是0 并且 M 是0，这个数±0（和符号位相关） 如果 E = 2 &#8722; 1 并且 M 是0，这个数是 ±无穷大（同样和符号位相关） 如果 E = 2 &#8722; 1 并且 M 非0，这个数表示为不是一个数（NaN）。
标准浮点数的存储在尾数中隐含存储着一个1，因此在计算尾数的真值时比一般形式要多一个整数1。对于阶码E的存储形式因为是127的偏移，所以在计算其移码时与人们熟悉的128偏移不一样，正数的值比用128偏移求得的少1，负数的值多1，为避免计算错误，方便理解，常将E当成二进制真值进行存储。例如：将数值-0.5按IEEE754单精度格式存储，先将-0.5换成二进制并写成标准形式：-0.510=-0.12=-1.0×2-12，这里s=1，M为全0，E-127=-1，E=12610=011111102，则存储形式为：
1 01111110 000000=BE000000(16)
这里不同的下标代表不同的进制。


子程序指针...实质上就是一个子程序的内存地址，长度为4，可当作是整数型处理...之前已经说过了...

windstay

unicode的回车是{32,0}
数据加密如果按文本保存且用unicode估计是可以的。
不知道文本变量最多存多少东西？
楼主还有后续吗？

虎鲸

你好，您辛苦了，内容写的很好，新手特别喜欢，老鸟来温习一下，谢谢

gongyi22

等把汇编学会了再来膜拜!!!!!!!!!!!!!!!!!!!!!!!

不得不爱2

伤心啊,怎么就没有人给个好评啊,打字很辛苦的,也没有人给个精来慰劳慰劳我

不得不爱2

然后我们来看下文本数组

  

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

变量名	类 型	静态	数组	备 注
文本	文本型		0
变量地址	整数型

文本 ＝ { “a”, “b”, “c” }
调试输出 (取变量数据地址 (文本 [1]))
调试输出 (取字节集数据 (指针到字节集 (取变量数据地址 (文本) ＋ 0, 4), #整数型, ))
调试输出 (取变量数据地址 (文本 [2]))
调试输出 (取字节集数据 (指针到字节集 (取变量数据地址 (文本) ＋ 4, 4), #整数型, ))
调试输出 (取变量数据地址 (文本 [3]))
调试输出 (取字节集数据 (指针到字节集 (取变量数据地址 (文本) ＋ 8, 4), #整数型, ))

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 测试<br /> .局部变量 文本, 文本型, , "0"<br /> .局部变量 变量地址, 整数型<br /> <br /> 文本 ＝ { “a”, “b”, “c” }<br /> 调试输出 (取变量数据地址 (文本 [1]))<br /> 调试输出 (取字节集数据 (指针到字节集 (取变量数据地址 (文本) ＋ 0, 4), #整数型, ))<br /> 调试输出 (取变量数据地址 (文本 [2]))<br /> 调试输出 (取字节集数据 (指针到字节集 (取变量数据地址 (文本) ＋ 4, 4), #整数型, ))<br /> 调试输出 (取变量数据地址 (文本 [3]))<br /> 调试输出 (取字节集数据 (指针到字节集 (取变量数据地址 (文本) ＋ 8, 4), #整数型, ))

我想可以看出，当存储的是文本型这种只可以传递内存地址的数据的时候，内存里存储的是内存地址的数组，而非数据的数组

字节集也是一样的道理。这就是易语言，或者说是大部分编程语言的数组在内存中的存储方式。


OK，让我们最后讲讲自定义数据类型吧～
[e=2].版本 2
.支持库 spec


.子程序 测试
.局部变量 自定义数据类型, 数据类型1
.局部变量 变量地址, 整数型


自定义数据类型.a ＝ 123  ' a是整数型
自定义数据类型.b ＝ “abc”  ' b是文本型
自定义数据类型.c ＝ 9  ' c是字节型
自定义数据类型.d ＝ 8  ' d是字节型
变量地址 ＝ 取变量地址 (自定义数据类型)
变量地址 ＝ 取字节集数据 (指针到字节集 (变量地址, 4), #整数型, )
调试输出 (指针到字节集 (变量地址, 4 ＋ 4 ＋ 4 ＋ 4))
调试输出 (取变量数据地址 (自定义数据类型.b))
调试输出 (取字节集数据 (指针到字节集 (变量地址 ＋ 4, 4), #整数型, ))
[e]
开始运行被调试程序
* 字节集:16{123,0,0,0,4,1,174,0,9,0,0,0,8,0,0,0}
* 11403524
* 11403524
被调试易程序运行完毕


如你们所见
实质上自定义数据结构也不过是内存中的一段数据
当变量需要传值的时候，在内存里成员所对应的内存地址里存储的就是那个变量的内存地址
否则直接存储数值。
然而要注意的是，字节型理论上只占用一个字节
实质上在易语言中被解释成了4字节长度

基本上我想讲的就这么多了
我想，如果有人想要设计一个脚本解释器之类的，使用申请内存()来做各种变量应该有思路了吧(笑)

魔方软件

你是我的小丫小苹果，。

不得不爱2

我们来讲讲数组吧← ←
数组其实有两种，一种是传址变量的数组，如字节集，文本型等，一种是无传址变量的数组，如整数型，逻辑型之类的....

我们先用整数型举例
[e=2].版本 2
.支持库 spec


.子程序 测试
.局部变量 整数数组, 整数型, , "0"
.局部变量 变量地址, 整数型


整数数组 ＝ { 11, 22, 33 }
调试输出 (指针到字节集 (取变量数据地址 (整数数组), 4 × 3))
[e]

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


很明显，数组的存储方式就是按照数据的长度。
如整数型的数组，整数型的数据长度是4字节，所以数组的存储实际上是 4个字节存储一个数字，下一个字节存储第二个成员
数组成员数的管理实质上是易语言内部管理的。通过设置，其实是可以让易语言不检查引用下标的

其实在一些编程语言（如C++），编译器有时候是不检查下标的，比如



这段代码创建的整数数组a只有三个成员，但是我却尝试输出了第五个成员...事实上编译器完全没有报错并且可以正常运行

至于原因
数组的存储实质上就是一个内存地址，里面按照被解释的数据类型来取得内容。比如一段内存被解释成整数型数组，那么就是1～4=第一个成员，5～8=第二个成员，以此类推
检查数组成员实质上并不是必须的。只是易语言自身提供了数组的检查罢了。

大表舅

大神好厉害 = = 可惜没有视频= =