【c/c++】使用C++实现易语言的到字节集功能

Eric_Yang

a87249594 发表于 2022-12-11 12:22
易语言的数组玩法有没有C++的  加入成员 删除成员   数组排序   重定义数组  取数组成员数 ...

在vector类中都有的   比如out.push_back()这个就是加入成员  还有其他的方法  out.size（）就是取数组成员数  这些都是数组的方法  还有resize重定义数组  clear清除数组   erase删除成员   insert插入成员

一尘不染

学习使人进步
？

阿龙

a87249594 发表于 2022-12-11 12:22
易语言的数组玩法有没有C++的  加入成员 删除成员   数组排序   重定义数组  取数组成员数 ...

stl里都有

a87249594

易语言的数组玩法有没有C++的  加入成员 删除成员   数组排序   重定义数组  取数组成员数

阿龙

vector<unsigned char>是最好的复现方法，相对于自己定义的类能够做到高度解耦，纯仿造易语言命令，可以把其他命令复现，但是还是建议使用类。举些仿易的bytearr操作命令。
到字节集

[C++] 纯文本查看 复制代码

KrnlnApi vector<unsigned char> 到字节集(char* 欲转换为字节集的数据) {
        if (欲转换为字节集的数据 == nullptr) {
                // 如果输入为空指针，直接返回一个空 vector
                return {};
        }
        return vector<unsigned char>((unsigned char*)欲转换为字节集的数据, (unsigned char*)欲转换为字节集的数据 + strlen(欲转换为字节集的数据) * sizeof(char));//为了和易保持同步,没有添加结束符'\0'
}
KrnlnApi vector<unsigned char> 到字节集(wchar_t* 欲转换为字节集的数据) {
        if (欲转换为字节集的数据 == nullptr) {
                // 如果输入为空指针，直接返回一个空 vector
                return {};
        }
        return vector<unsigned char>((unsigned char*)欲转换为字节集的数据, (unsigned char*)欲转换为字节集的数据 + wcslen(欲转换为字节集的数据) * sizeof(wchar_t));//为了和易保持同步,没有添加结束符'\0'
}
KrnlnApi vector<unsigned char> 到字节集(const std::string& 欲转换为字节集的数据) {
        if (欲转换为字节集的数据.empty()) {
                // 如果输入为空字符串，直接返回一个空 vector
                return {};
        }
        size_t len = 欲转换为字节集的数据.size();
        std::vector<unsigned char> byte_array(len * sizeof(char));
        std::memcpy(byte_array.data(), 欲转换为字节集的数据.c_str(), len * sizeof(char));
        return byte_array;

}

KrnlnApi vector<unsigned char> 到字节集(const std::wstring& 欲转换为字节集的数据) {
        if (欲转换为字节集的数据.empty()) {
                // 如果输入为空字符串，直接返回一个空 vector
                return {};
        }
        size_t len = 欲转换为字节集的数据.size();
        std::vector<unsigned char> byte_array(len * sizeof(wchar_t));
        std::memcpy(byte_array.data(), 欲转换为字节集的数据.c_str(), len * sizeof(wchar_t));
        return byte_array;
}
拓展一下模板类
template<typename Type>
vector<unsigned char> 到字节集(const std::vector<Type>& 欲转换为字节集的数据) {
        if (欲转换为字节集的数据.empty()) {
                return {};
        }
        return        vector<unsigned char>((unsigned char*)欲转换为字节集的数据.data(), ((unsigned char*)欲转换为字节集的数据.data() + 欲转换为字节集的数据.size() * sizeof(Type)));
};
template<typename Type>
vector<unsigned char> 到字节集(const Type& 欲转换为字节集的数据) {//大型结构体防止拷贝，保证数据结构的执行效率
        return  vector<unsigned char>((unsigned char*)&欲转换为字节集的数据, ((unsigned char*)&欲转换为字节集的数据 + sizeof(Type)));
};

倒找字节集

[C++] 纯文本查看 复制代码

intptr_t 倒找字节集(const std::vector<unsigned char>& 被搜寻的字节集, const std::vector<unsigned char>& 欲寻找的字节集, size_t 起始搜寻位置) {
        if (欲寻找的字节集.size() == 0 || 欲寻找的字节集.empty() || 被搜寻的字节集.empty()) {
                return -1;
        }

        intptr_t nLen = 被搜寻的字节集.size();
        intptr_t nSubLen = 欲寻找的字节集.size();
        if (nLen == 0 || nSubLen == 0 || nSubLen > nLen) return -1;
        const unsigned char* pSrc = 被搜寻的字节集.data();
        intptr_t off = 起始搜寻位置;
        if (off < 1)
                return -1;
        if (off <= nLen)
                nLen = off;
        if (nLen < nSubLen)
        {
                return -1;
        }
        off = nLen - nSubLen;
        const  unsigned char* pDes = 欲寻找的字节集.data();
        if (nSubLen == 1)
        {
                intptr_t i = off;
                for (intptr_t p = 0; p < off; p++, i--)
                {
                        if (pSrc == pDes[0]) {
                                return i + 1;
                        }
                }
                return -1;
        }
        else if (nSubLen == 2)
        {
                intptr_t i = off;
                for (intptr_t p = 0; p < off; p++, i--) {
                        if (((short*)(pSrc + i))[0] == ((short*)pDes)[0]) {
                                return i + 1;
                        }
                }
                return -1;
        }
        else if (nSubLen == 3)
        {
                intptr_t i = off;
                for (intptr_t p = 0; p < off; p++, i--) {
                        if (((short*)(pSrc + i))[0] == ((short*)pDes)[0]) {
                                if (pSrc[i + 2] == pDes[2]) {
                                        return i + 1;
                                }
                        }
                }
                return -1;
        }
        else if (nSubLen == 4)
        {
                intptr_t i = off;
                for (intptr_t p = 0; p < off; p++, i--) {
                        if (((int*)(pSrc + i))[0] == ((int*)pDes)[0]) {
                                return i + 1;
                        }
                }
                return -1;
        }
        else if (nSubLen == 5)
        {
                intptr_t i = off;
                for (intptr_t p = 0; p < off; p++, i--) {
                        if (((int*)(pSrc + i))[0] == ((int*)pDes)[0]) {
                                if (pSrc[i + 4] == pDes[4]) {
                                        return i + 1;
                                }
                        }
                }
                return -1;
        }
        else if (nSubLen == 6)
        {
                intptr_t i = off;
                for (intptr_t p = 0; p < off; p++, i--) {
                        if (((int*)(pSrc + i))[0] == ((int*)pDes)[0]) {
                                if (((short*)(pSrc + i + 4))[0] == ((short*)(pDes + 4))[0]) {
                                        return i + 1;
                                }
                        }
                }
                return -1;
        }

        // 长串使用KMP算法查找模式串
        // 创建一个长整型数组，用于存储模式串的最长前后缀信息
        std::unique_ptr<intptr_t[]> kmp(new long long[nSubLen]);
        for (long long i = 0; i < nSubLen; i++) {
                kmp = 0;
        }
        intptr_t i = 0;
        intptr_t j = 0;
        while (i < nLen && j < nSubLen) {
                if (pSrc == pDes[j]) {
                        i++;
                        j++;
                }
                else {
                        if (j > 0) {
                                j = kmp[j - 1];
                        }
                        else {
                                i++;
                        }
                }
        }

        // 如果模式串在文本中找到了，则返回位置；否则返回-1
        if (j == nSubLen) {
                return i - nSubLen + 1;
        }
        else {
                return -1;
        }
}

取空白字节集

[C++] 纯文本查看 复制代码

KrnlnApi std::vector<unsigned char>  取空白字节集(size_t  零字节数目)
{
        if (零字节数目 == 0) {
                return  std::vector<unsigned char>();
        }
        return std::vector<unsigned char>(零字节数目, 0);
}

取重复字节集

[C++] 纯文本查看 复制代码

std::vector<unsigned char> 取重复字节集(size_t 重复次数, const std::vector<unsigned char>& 待重复的字节集)
{
        if (重复次数 <= 0 || 待重复的字节集.empty())
        {
                return {};
        }

        std::vector<unsigned char> buffer(待重复的字节集.size() * 重复次数);
        for (size_t i = 0; i < 重复次数; ++i)
        {
                std::copy(待重复的字节集.begin(), 待重复的字节集.end(), buffer.begin() + i * 待重复的字节集.size());
        }
        return buffer;
}

杨明煜

学习进步！......

kantal

谢谢分享，来支持一波