自己写了个数组，竟然比原生数组快

神女软件定制

  

窗口程序集名	保 留	保 留	备 注
整数数组
变量名	类 型	数组	备 注
m_pBuff	整数型		分配的空间
m_buffLen	整数型		分配内存可存储的成员数
m_length	整数型		实际的成员数
m_起始下标	整数型

子程序名	返回值类型	公开	备 注
_初始化			当基于本类的对象被创建后，此方法会被自动调用

m_buffLen ＝ 16  ' 默认分配一块能转下16个成员的内存
m_pBuff ＝ 申请内存 (4 × m_buffLen, )

子程序名	返回值类型	公开	备 注
_销毁			当基于本类的对象被销毁前，此方法会被自动调用

释放内存 (m_pBuff)

子程序名	返回值类型	公开	备 注
置起始下标
参数名	类 型	参考	可空	数组	备 注
cs_起始下标	整数型				可空，默认为0

m_起始下标 ＝ cs_起始下标

子程序名	返回值类型	公开	备 注
取起始下标	整数型

返回 (m_起始下标)

子程序名	返回值类型	公开	备 注
取成员数	整数型

返回 (m_length)

子程序名	返回值类型	公开	备 注
清空

释放内存 (m_pBuff)
m_buffLen ＝ 16  ' 默认分配一块能转下16个成员的内存
m_pBuff ＝ 申请内存 (4 × m_buffLen, )
m_length ＝ 0

子程序名	返回值类型	公开	备 注
取成员	整数型
参数名	类 型	参考	可空	数组	备 注
cs_下标	整数型

变量名	类 型	静态	数组	备 注
temp	整数型

cs_下标 ＝ cs_下标 － m_起始下标
如果 (cs_下标 ≥ 0 且 cs_下标 ＜ m_length)
CopyMemory (取变量地址 (temp), m_pBuff ＋ 4 × cs_下标, 4)
调试输出 (“下标超出！”)
暂停 ()
结束 ()
返回 (temp)

子程序名	返回值类型	公开	备 注
置成员
参数名	类 型	参考	可空	数组	备 注
cs_下标	整数型
cs_值	整数型

cs_下标 ＝ cs_下标 － m_起始下标
如果 (cs_下标 ≥ 0 且 cs_下标 ＜ m_length)
写到内存 (cs_值, m_pBuff ＋ 4 × cs_下标, 4)
调试输出 (“下标超出！”)
暂停 ()
结束 ()

子程序名	返回值类型	公开	备 注
加入成员
参数名	类 型	参考	可空	数组	备 注
值	整数型

变量名	类 型	静态	数组	备 注
pBuff	整数型
jb_指数	整数型

如果真 (m_buffLen ＜ m_length ＋ 1)
jb_指数 ＝ 求自然对数 (m_buffLen) ÷ 求自然对数 (2) ＋ 1
m_buffLen ＝ 求次方 (2, jb_指数)
' 调试输出 (“重新分配大小：”, m_buffLen)
pBuff ＝ 申请内存 (4 × m_buffLen, )
CopyMemory (pBuff, m_pBuff, 4 × m_length)
释放内存 (m_pBuff)
m_pBuff ＝ pBuff
写到内存 (值, m_pBuff ＋ 4 × m_length, 4)
m_length ＝ m_length ＋ 1

子程序名	返回值类型	公开	备 注
删除成员
参数名	类 型	参考	可空	数组	备 注
cs_下标	整数型

cs_下标 ＝ cs_下标 － m_起始下标
如果 (cs_下标 ≥ 0 且 cs_下标 ＜ m_length)
MoveMemory (m_pBuff ＋ 4 × cs_下标, m_pBuff ＋ 4 �� (cs_下标 ＋ 1), 4 �� (m_length － cs_下标 － 1))
m_length ＝ m_length － 1
调试输出 (“下标超出！”)
暂停 ()
结束 ()

子程序名	返回值类型	公开	备 注
插入成员_未实现_________

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 整数数组<br /> .程序集变量 m_pBuff, 整数型, , , 分配的空间<br /> .程序集变量 m_buffLen, 整数型, , , 分配内存可存储的成员数<br /> .程序集变量 m_length, 整数型, , , 实际的成员数<br /> .程序集变量 m_起始下标, 整数型<br /> <br /> .子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用<br /> <br /> m_buffLen ＝ 16  ' 默认分配一块能转下16个成员的内存<br /> m_pBuff ＝ 申请内存 (4 × m_buffLen, )<br /> <br /> .子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用<br /> <br /> 释放内存 (m_pBuff)<br /> <br /> .子程序 置起始下标, , 公开<br /> .参数 cs_起始下标, 整数型, 可空, 可空，默认为0<br /> <br /> m_起始下标 ＝ cs_起始下标<br /> <br /> .子程序 取起始下标, 整数型, 公开<br /> <br /> 返回 (m_起始下标)<br /> <br /> .子程序 取成员数, 整数型, 公开<br /> <br /> 返回 (m_length)<br /> <br /> .子程序 清空, , 公开<br /> <br /> 释放内存 (m_pBuff)<br /> m_buffLen ＝ 16  ' 默认分配一块能转下16个成员的内存<br /> m_pBuff ＝ 申请内存 (4 × m_buffLen, )<br /> m_length ＝ 0<br /> <br /> .子程序 取成员, 整数型, 公开<br /> .参数 cs_下标, 整数型<br /> .局部变量 temp, 整数型<br /> <br /> cs_下标 ＝ cs_下标 － m_起始下标<br /> .如果 (cs_下标 ≥ 0 且 cs_下标 ＜ m_length)<br />     CopyMemory (取变量地址 (temp), m_pBuff ＋ 4 × cs_下标, 4)<br /> .否则<br />     调试输出 (“下标超出！”)<br />     暂停 ()<br />     结束 ()<br /> .如果结束<br /> 返回 (temp)<br /> <br /> .子程序 置成员, , 公开<br /> .参数 cs_下标, 整数型<br /> .参数 cs_值, 整数型<br /> <br /> cs_下标 ＝ cs_下标 － m_起始下标<br /> .如果 (cs_下标 ≥ 0 且 cs_下标 ＜ m_length)<br />     写到内存 (cs_值, m_pBuff ＋ 4 × cs_下标, 4)<br /> .否则<br />     调试输出 (“下标超出！”)<br />     暂停 ()<br />     结束 ()<br /> .如果结束<br /> <br /> <br /> .子程序 加入成员, , 公开<br /> .参数 值, 整数型<br /> .局部变量 pBuff, 整数型<br /> .局部变量 jb_指数, 整数型<br /> <br /> .如果真 (m_buffLen ＜ m_length ＋ 1)<br />     jb_指数 ＝ 求自然对数 (m_buffLen) ÷ 求自然对数 (2) ＋ 1<br />     m_buffLen ＝ 求次方 (2, jb_指数)<br />     ' 调试输出 (“重新分配大小：”, m_buffLen)<br />     pBuff ＝ 申请内存 (4 × m_buffLen, )<br />     CopyMemory (pBuff, m_pBuff, 4 × m_length)<br />     释放内存 (m_pBuff)<br />     m_pBuff ＝ pBuff<br /> .如果真结束<br /> 写到内存 (值, m_pBuff ＋ 4 × m_length, 4)<br /> m_length ＝ m_length ＋ 1<br /> <br /> .子程序 删除成员, , 公开<br /> .参数 cs_下标, 整数型<br /> <br /> cs_下标 ＝ cs_下标 － m_起始下标<br /> .如果 (cs_下标 ≥ 0 且 cs_下标 ＜ m_length)<br />     MoveMemory (m_pBuff ＋ 4 × cs_下标, m_pBuff ＋ 4 × (cs_下标 ＋ 1), 4 × (m_length － cs_下标 － 1))<br />     m_length ＝ m_length － 1<br /> .否则<br />     调试输出 (“下标超出！”)<br />     暂停 ()<br />     结束 ()<br /> .如果结束<br /> <br /> <br /> .子程序 插入成员_未实现_________

加入成员这个，是优化了下算法，如果，现在申请的内存，能装下8个成员，还想添加，就申请能装下16个成员的内存，后面32，64，128，。。。，依次*2。
所以这里比易语言原生的快，是有依据的。这样也是最贴合实际的。后面用到的空间越大，申请的缓存空间也就越大。避免大量申请释放内存。
一次性加入的成员越多，我这份会快得越明显


至于删除为什么，可能因为易语言，删除后缩小了内存空间吧（不确定），我这份实现没有缩小，清除时才会缩小。


数组实现.e (9.1 KB, 下载次数: 51)

2020-8-5 21:38 上传

点击文件名下载附件
下载积分: 精币 -2 枚

malin158

感谢分享，很给力！~

a019872140

没测试  是否在线程也能用

神女软件定制

a019872140 发表于 2020-8-6 02:00
没测试  是否在线程也能用

非线程安全，多个线程，同时增删，会出问题

mq853368887

6666666666

李泽勇2

感谢分享。

wjswzj0

66666666666666

漠然°

感谢楼主分享

q22

感谢楼主分享

aaaajjjj

感谢楼主分享