├── .gitattributes ├── .gitignore ├── LibKrnln.sln ├── LibKrnln.vcxproj ├── LibKrnln.vcxproj.filters ├── README.md ├── TestProject ├── test.cpp ├── test.vcxproj └── test.vcxproj.filters ├── include ├── Edefcn.h ├── krnln.h ├── 位运算.h ├── 字节集操作.h ├── 控制台操作.h ├── 操作系统.h ├── 数值转换.h ├── 数据操作.h ├── 数组.h ├── 文件读写.h ├── 文本操作.h ├── 文本转换.h ├── 时间操作.h ├── 流程控制.h ├── 环境存取.h ├── 磁盘操作.h ├── 程序进程.h ├── 算术运算.h ├── 系统处理.h ├── 线程操作.h ├── 网络通信.h └── 逻辑比较.h └── src ├── 位运算 ├── 位取反.cpp ├── 取整数型某位.cpp ├── 取长整数高低位.cpp ├── 右移.cpp ├── 合并整数.cpp ├── 合并短整数.cpp └── 左移.cpp ├── 字节集操作 ├── 倒找字节集.cpp ├── 分割字节集.cpp ├── 到字节集.cpp ├── 取字节集中间.cpp ├── 取字节集内整数.cpp ├── 取字节集右边.cpp ├── 取字节集左边.cpp ├── 取字节集长度.cpp ├── 取空白字节集.cpp ├── 取重复字节集.cpp ├── 子字节集替换.cpp ├── 字节集拼接.cpp ├── 字节集替换.cpp ├── 字节集重载运算符.cpp ├── 寻找字节集.cpp ├── 指针到字节集.cpp └── 置字节集内整数.cpp ├── 控制台操作 ├── 打开控制台.cpp ├── 标准输入.cpp ├── 标准输出.cpp └── 置控制台标题.cpp ├── 操作系统 ├── 信息框.cpp ├── 写注册项.cpp ├── 安装与卸载字体.cpp ├── 延迟.cpp ├── 播放MIDI.cpp ├── 播放音乐.cpp ├── 注册项是否存在.cpp └── 高级信息框.cpp ├── 数值转换 ├── 二进制.cpp ├── 到字节.cpp ├── 到小数.cpp ├── 到数值.cpp ├── 到整数.cpp ├── 到短整数.cpp ├── 到长整数.cpp ├── 十六进制.cpp ├── 反转整数字节序.cpp ├── 取八进制文本.cpp ├── 取十六进制文本.cpp ├── 数值到大写.cpp ├── 数值到格式文本.cpp └── 数值到金额.cpp ├── 数据操作 ├── 取数据摘要.cpp └── 数据加解密.cpp ├── 文件读写 └── 内存文件.cpp ├── 文本操作 ├── 倒找文本.cpp ├── 分割文本.cpp ├── 删全部空.cpp ├── 删尾空.cpp ├── 删首尾空.cpp ├── 删首空.cpp ├── 到全角.cpp ├── 到半角.cpp ├── 到大写.cpp ├── 到小写.cpp ├── 到文本.cpp ├── 取代码.cpp ├── 取文本中间.cpp ├── 取文本右边.cpp ├── 取文本左边.cpp ├── 取文本长度.cpp ├── 取空白文本.cpp ├── 取统一拓展名.cpp ├── 取重复文本.cpp ├── 子文本替换.cpp ├── 字符.cpp ├── 寻找文本.cpp ├── 指针到文本.cpp ├── 文本替换.cpp ├── 文本比较.cpp ├── 是否以文本开头.cpp └── 是否以文本结尾.cpp ├── 文本转换 └── 文本转换.cpp ├── 时间操作 ├── 到时间.cpp ├── 取分钟.cpp ├── 取小时.cpp ├── 取年份.cpp ├── 取日.cpp ├── 取日期.cpp ├── 取时间.cpp ├── 取时间部分.cpp ├── 取时间间隔.cpp ├── 取星期几.cpp ├── 取月份.cpp ├── 取某月天数.cpp ├── 取现行时间.cpp ├── 取秒.cpp ├── 增减时间.cpp ├── 指定时间.cpp ├── 时间到文本.cpp └── 置现行时间.cpp ├── 环境存取 ├── 写环境变量.cpp ├── 取命令行.cpp ├── 取完整目录.cpp ├── 取执行文件名.cpp ├── 取运行目录.cpp ├── 枚举注册表.cpp ├── 规范化路径.cpp └── 读环境变量.cpp ├── 磁盘操作 ├── 写到文件.cpp ├── 创建目录.cpp ├── 删除文件.cpp ├── 删除目录.cpp ├── 取临时文件名.cpp ├── 取当前目录.cpp ├── 取文件尺寸.cpp ├── 取文件属性.cpp ├── 取文件时间.cpp ├── 取父路径.cpp ├── 取磁盘剩余空间.cpp ├── 取磁盘卷标.cpp ├── 取磁盘总空间.cpp ├── 复制文件.cpp ├── 定位文件.cpp ├── 寻找文件.cpp ├── 改变目录.cpp ├── 改变驱动器.cpp ├── 文件是否存在.cpp ├── 文件更名.cpp ├── 清空目录.cpp ├── 移动文件.cpp ├── 置文件属性.cpp ├── 置磁盘卷标.cpp └── 读入文件.cpp ├── 程序进程 └── 禁止程序重复运行.cpp ├── 算数运算 ├── 一阶微分.cpp ├── 取整.cpp ├── 取斐波那契数列项值.cpp ├── 取符号.cpp ├── 取绝对值.cpp ├── 取随机数.cpp ├── 四舍五入.cpp ├── 弧度到角度.cpp ├── 数值积分计算.cpp ├── 是否素数.cpp ├── 是否运算正确.cpp ├── 求余弦.cpp ├── 求反对数.cpp ├── 求反正切.cpp ├── 求平方根.cpp ├── 求次方.cpp ├── 求正切.cpp ├── 求正弦.cpp ├── 求自然对数.cpp ├── 绝对取整.cpp ├── 角度到弧度.cpp └── 阶乘.cpp ├── 系统处理 ├── 关闭系统.cpp ├── 剪辑板中可有文本.cpp ├── 取屏幕宽度.cpp ├── 取屏幕高度.cpp ├── 延时.cpp └── 终止进程.cpp ├── 线程操作 └── 线程操作.cpp ├── 网络通信 ├── 取本机ip.cpp ├── 取本机名.cpp └── 打开指定网址.cpp └── 逻辑比较 ├── 文本对比.cpp └── 近似等于.cpp /.gitattributes: -------------------------------------------------------------------------------- 1 | ############################################################################### 2 | # Set default behavior to automatically normalize line endings. 3 | ############################################################################### 4 | * text=auto 5 | 6 | ############################################################################### 7 | # Set default behavior for command prompt diff. 8 | # 9 | # This is need for earlier builds of msysgit that does not have it on by 10 | # default for csharp files. 11 | # Note: This is only used by command line 12 | ############################################################################### 13 | #*.cs diff=csharp 14 | 15 | ############################################################################### 16 | # Set the merge driver for project and solution files 17 | # 18 | # Merging from the command prompt will add diff markers to the files if there 19 | # are conflicts (Merging from VS is not affected by the settings below, in VS 20 | # the diff markers are never inserted). Diff markers may cause the following 21 | # file extensions to fail to load in VS. An alternative would be to treat 22 | # these files as binary and thus will always conflict and require user 23 | # intervention with every merge. To do so, just uncomment the entries below 24 | ############################################################################### 25 | #*.sln merge=binary 26 | #*.csproj merge=binary 27 | #*.vbproj merge=binary 28 | #*.vcxproj merge=binary 29 | #*.vcproj merge=binary 30 | #*.dbproj merge=binary 31 | #*.fsproj merge=binary 32 | #*.lsproj merge=binary 33 | #*.wixproj merge=binary 34 | #*.modelproj merge=binary 35 | #*.sqlproj merge=binary 36 | #*.wwaproj merge=binary 37 | 38 | ############################################################################### 39 | # behavior for image files 40 | # 41 | # image files are treated as binary by default. 42 | ############################################################################### 43 | #*.jpg binary 44 | #*.png binary 45 | #*.gif binary 46 | 47 | ############################################################################### 48 | # diff behavior for common document formats 49 | # 50 | # Convert binary document formats to text before diffing them. This feature 51 | # is only available from the command line. Turn it on by uncommenting the 52 | # entries below. 53 | ############################################################################### 54 | #*.doc diff=astextplain 55 | #*.DOC diff=astextplain 56 | #*.docx diff=astextplain 57 | #*.DOCX diff=astextplain 58 | #*.dot diff=astextplain 59 | #*.DOT diff=astextplain 60 | #*.pdf diff=astextplain 61 | #*.PDF diff=astextplain 62 | #*.rtf diff=astextplain 63 | #*.RTF diff=astextplain 64 | -------------------------------------------------------------------------------- /LibKrnln.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.32106.194 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibKrnln", "LibKrnln.vcxproj", "{8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}" 7 | EndProject 8 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test", "TestProject\test.vcxproj", "{2D5BF970-6325-4B13-A100-CDE231FB309B}" 9 | ProjectSection(ProjectDependencies) = postProject 10 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE} = {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE} 11 | EndProjectSection 12 | EndProject 13 | Global 14 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 15 | DebugLib|x64 = DebugLib|x64 16 | DebugLib|x86 = DebugLib|x86 17 | Lib|x64 = Lib|x64 18 | Lib|x86 = Lib|x86 19 | Static|x64 = Static|x64 20 | Static|x86 = Static|x86 21 | EndGlobalSection 22 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 23 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.DebugLib|x64.ActiveCfg = DebugLib|x64 24 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.DebugLib|x64.Build.0 = DebugLib|x64 25 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.DebugLib|x86.ActiveCfg = DebugLib|Win32 26 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.DebugLib|x86.Build.0 = DebugLib|Win32 27 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Lib|x64.ActiveCfg = Lib|x64 28 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Lib|x64.Build.0 = Lib|x64 29 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Lib|x86.ActiveCfg = Lib|Win32 30 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Lib|x86.Build.0 = Lib|Win32 31 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Static|x64.ActiveCfg = Static|x64 32 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Static|x64.Build.0 = Static|x64 33 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Static|x86.ActiveCfg = Static|Win32 34 | {8797A36D-5147-4AE1-9F2A-AFA4E87A1AAE}.Static|x86.Build.0 = Static|Win32 35 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.DebugLib|x64.ActiveCfg = DebugLib|x64 36 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.DebugLib|x64.Build.0 = DebugLib|x64 37 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.DebugLib|x86.ActiveCfg = DebugLib|Win32 38 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.DebugLib|x86.Build.0 = DebugLib|Win32 39 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Lib|x64.ActiveCfg = Lib|x64 40 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Lib|x64.Build.0 = Lib|x64 41 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Lib|x86.ActiveCfg = Lib|Win32 42 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Lib|x86.Build.0 = Lib|Win32 43 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Static|x64.ActiveCfg = Static|x64 44 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Static|x64.Build.0 = Static|x64 45 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Static|x86.ActiveCfg = Static|Win32 46 | {2D5BF970-6325-4B13-A100-CDE231FB309B}.Static|x86.Build.0 = Static|Win32 47 | EndGlobalSection 48 | GlobalSection(SolutionProperties) = preSolution 49 | HideSolutionNode = FALSE 50 | EndGlobalSection 51 | GlobalSection(ExtensibilityGlobals) = postSolution 52 | SolutionGuid = {7B039A19-076D-48E4-8E4C-C00D859E3DEC} 53 | EndGlobalSection 54 | EndGlobal 55 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## LibKrnln🎃跨平台中文命令库 2 | 3 | 4 | 5 | ## 编译与安装 6 | 1. 打开对应的工程文件 7 | 2. 根据需求编译为动态库或者静态库，目前没有在项目里添加.so的编译，静态库通过msvc以及clang-llvm的编译，可以在两个平台之间编译。 8 | 3. 编译后，在项目中引入库和Krnln.h头文件即可 9 | 10 | 11 | ## 源码使用事项 12 | 非商业用途及非法用途，源码可以任意使用及传播，包不限于包含进入商业软件 13 | 14 | 在复制与传播时，必须注明开源地址！ 15 | 16 | 17 | ## 代码编写规范 18 | 如果你想参与更新、优化或修复BUG，请仔细阅读以下事项： 19 | 1. 代码使用C++17及以上标准 20 | 2. 能够通过clang和MSVC同标准下的编译 21 | 3. 尽量不要用内联汇编 22 | 4. 确保代码的易用性、简洁美观、高效、稳定及安全性。 23 | 5. 保证代码的高度解耦性，也就是代码之间尽量减少依赖。 24 | 6. 编辑的源代码文件的时候，请使用UTF8编码。 25 | 7. 不要使用非平台库或stl以外的任何外部库，如可以提取部分代码以完成需求函数或对象请根据开源协议来标注。 26 | 8. 尽量使用标注库来实现命令，如需使用平台函数请使用条件编译来确保不同平台之间能正确调用暴漏接口和编译的正确性 27 | 9. 使用intptr_t size_t SetWindowPtr等平台整数或者函数来确保跨架构的正确性。 28 | 10.请尽可能不要使编译器出现警告提醒，如果完全确保函数的安全性，请使用忽略警告的宏来告诉编译器。 29 | 30 | ## 参与贡献 31 | 1. 可以加入此开源项目的管理团队 32 | 2. 可以在GitHub或Gitee中通过Issues页面提交错误和改进建议 33 | 3. 可以在GitHub或Gitee中`Fork`, 修改后通过`Pull Request`合并代码 34 | 35 | 36 | -------------------------------------------------------------------------------- /TestProject/test.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | 源文件 20 | 21 | 22 | -------------------------------------------------------------------------------- /include/Edefcn.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef UseEdefcn 3 | #define UseEdefcn 4 | #include 5 | #include 6 | //兼容unicode ansi 7 | #ifdef _UNICODE 8 | typedef std::wstring lstring; 9 | typedef wchar_t lchar; 10 | #define _l(X) L##X 11 | #else 12 | typedef std::string lstring; 13 | typedef char lchar; 14 | #define _l(X) X 15 | #endif 16 | 17 | 18 | #ifdef 使用中文代码 19 | 20 | //宏定义的数据类型尽量不要使用，微软默认32为编译器，如果文件过大预编译过程容易卡死 21 | //本库中并不会使用除std::tm以外的任何定义函数 22 | /****************************************************************************** 23 | * 易基本数据类型 * 24 | *******************************************************************************/ 25 | #define 整数型 int 26 | #define 长整数型 long 27 | #define 字节型 unsigned char 28 | #define 小数型 float 29 | #define 双精度小数型 double 30 | #define 逻辑型 bool 31 | 32 | typedef std::vector 字节集类; 33 | #define 文本型 lstring 34 | #define 子程序指针 void* 35 | #define 字节集 字节集类 36 | /****************************************************************************** 37 | * 拓展类型 * 38 | *******************************************************************************/ 39 | //兼容unicode ansi x86 x64 40 | #define 字符型 char 41 | #define 宽字符型 wchar_t 42 | #ifdef _WIN64 43 | #define 变整数 long long 44 | #else 45 | #define 变整数 int 46 | #endif 47 | struct 字体 { 48 | const wchar_t* 字体名称; 49 | BOOL 加粗 = false; 50 | BOOL 倾斜 = false; 51 | BOOL 下划线 = false; 52 | BOOL 删除线 = false; 53 | //点(1/72英寸）为单位 54 | ULONG 字体大小 = 9; 55 | }; 56 | struct 尺寸 57 | { 58 | LONG 宽; 59 | LONG 高; 60 | }; 61 | struct 矩形 62 | { 63 | LONG 左边; 64 | LONG 顶边; 65 | LONG 右边; 66 | LONG 底边; 67 | }; 68 | struct 矩形F 69 | { 70 | float 左边; 71 | float 顶边; 72 | float 宽度; 73 | float 高度; 74 | }; 75 | 76 | struct 坐标F 77 | { 78 | float x; 79 | float y; 80 | }; 81 | struct 坐标 82 | { 83 | LONG x; 84 | LONG y; 85 | }; 86 | 87 | 88 | 89 | 90 | 91 | #else 92 | //低版本MSVC或其他C++主流编译器 93 | #endif 94 | 95 | 96 | #endif // !UseEdefcn 97 | 98 | 99 | -------------------------------------------------------------------------------- /include/krnln.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | #if __cplusplus > 202004L 7 | import STL; 8 | #endif 9 | 10 | 11 | #ifndef UseKrnln //防止重复引用，C++23可以尝试重构为模块 12 | #define UseKrnln 13 | //中文函数我就不加命名空间了，一般不会冲突 14 | /****************************************************************************** 15 | 如果为MSVC则使用全中文模块--开始（MSVC版本没做定义，如果你还在用VC6自行修改吧） 16 | *******************************************************************************/ 17 | #ifdef _MSC_VER 18 | //使用vcide环境下定义默认为win环境，并使用中文代码。 19 | #pragma region 20 | #define 使用中文代码 21 | #include 22 | //using namespace std; 23 | #pragma endregion 24 | #include"Edefcn.h"//定义函数 25 | //#include"模板打包.h" 26 | #include"文本转换.h"//辅助类函数 27 | #include"数组.h" 28 | /*--函数头文件，将易核心库和常用支持库的常用命令囊括在内，落后的命令和有问题的命令都进行了修改以及删除，修改的内容也会在命令注释中体现。*/ 29 | #include"流程控制.h" 30 | #include"算术运算.h" 31 | #include"逻辑比较.h" 32 | #include"位运算.h" 33 | #include"环境存取.h" 34 | #include"字节集操作.h" 35 | #include"文本操作.h" 36 | #include"时间操作.h" 37 | #include"数值转换.h" 38 | #include"磁盘操作.h" 39 | #include"数据操作.h" 40 | /*此文件中会包含操作系统独占函数*/ 41 | #include"操作系统.h" 42 | #include"系统处理.h" 43 | #include"线程操作.h" 44 | #include"网络通信.h" 45 | #include"程序进程.h" 46 | 47 | //#include"图片处理.h" 48 | //#include"其他.h" 49 | 50 | //#include"窗口操作.h" 51 | #include"控制台操作.h" 52 | //#include"COM变体型.h" 53 | 54 | #include"文件读写.h" 55 | //#include"Sqlite数据库.h" 56 | //#include"通用易类.h" 57 | //*****************************DEBUG时请自行添加调试宏|重载使用方便************************ 58 | #pragma region 调试输出 59 | #ifdef 调试版 60 | 61 | 62 | template 63 | static void pt(std::wstring& str, Ty v) 64 | { 65 | using namespace std; 66 | str.append(to_wstring(v) + L" | "); 67 | } 68 | template 69 | static void pt(std::wstring& str, std::vector v) 70 | { 71 | using namespace std; 72 | if (v.empty()) 73 | { 74 | str.append(L" 数组:(空) |"); 75 | return; 76 | } 77 | for (size_t i = 0; i < v.size(); i++) 78 | { 79 | if (i == 0) { 80 | str.append(L" 数组 :" + to_wstring(v.size()) + L" {"); 81 | } 82 | str.append(to_wstring(v[i])); 83 | str.append(L","); 84 | } 85 | str.pop_back(); 86 | str.append(L"} | "); 87 | } 88 | static void pt(std::wstring& str, const wchar_t* s) //这个是 L"" 89 | { 90 | using namespace std; 91 | str.append(L"\""); 92 | if (!s) 93 | { 94 | str.append(L"(空)"); 95 | str.append(L"\" | "); 96 | return; 97 | } 98 | 99 | str.append(s); 100 | 101 | str.append(L"\" | "); 102 | } 103 | static void pt(std::wstring& str, const char* s) //这个是 L"" 104 | { 105 | using namespace std; 106 | str.append(L"\""); 107 | if (!s) 108 | { 109 | str.append(L"(空)"); 110 | str.append(L"\" | "); 111 | return; 112 | } 113 | str.append(L"\""); 114 | 115 | str.append(文本到宽文本(s)); 116 | 117 | str.append(L"\" | "); 118 | } 119 | static void pt(std::wstring& str, std::string s) 120 | { 121 | using namespace std; 122 | str.append(L"\""); 123 | 124 | str.append(文本到宽文本(s)); 125 | 126 | str.append(L"\" | "); 127 | } 128 | static void pt(std::wstring& str, std::wstring s) 129 | { 130 | using namespace std; 131 | str.append(L"\""); 132 | str.append(s); 133 | str.append(L"\" | "); 134 | } 135 | static void pt(std::wstring& str, std::vector s) 136 | { 137 | using namespace std; 138 | if (s.empty()) 139 | { 140 | str.append(L" 字节集:(空) |"); 141 | return; 142 | } 143 | for (size_t i = 0; i < s.size(); i++) 144 | { 145 | if (i == 0) { 146 | str.append(L" 字节集 :" + to_wstring(s.size()) + L" {"); 147 | } 148 | str.append(to_wstring((int)s.data()[i])); 149 | str.append(L","); 150 | } 151 | str.pop_back(); 152 | str.append(L"} | "); 153 | 154 | }; 155 | static void pt(std::wstring& str, char* s) 156 | { 157 | using namespace std; 158 | str.append(到文本W(std::string(s)) + L" | "); 159 | 160 | }; 161 | static void pt(std::wstring& str, std::tm s) 162 | { 163 | using namespace std; 164 | str.append(到文本W(s) + L" | "); 165 | 166 | }; 167 | //调试输出 支持 无限参数! 任意类型! (没有的可以重载方法自定义) 168 | template 169 | static void 调试输出(T... args) 170 | { 171 | std::wstring str = L""; 172 | std::initializer_list{(pt(str, std::forward(args)), 0)...}; 173 | 174 | str.pop_back(); 175 | str.pop_back(); 176 | str.append(L"\r\n"); 177 | OutputDebugStringW(str.c_str()); 178 | }; 179 | 180 | #else 181 | #define 调试输出(...) 182 | #endif 183 | 184 | #pragma endregion 185 | #endif 186 | 187 | 188 | 189 | /***************************************************************************** 190 | 如果为非MSVC则使用使用英文模块 191 | ******************************************************************************/ 192 | #ifdef __GNUC__ 193 | 194 | #include"Edef.h" 195 | #endif 196 | #ifdef __BORLANDC__ 197 | #include"Edef.h" 198 | #endif 199 | #else 200 | #endif -------------------------------------------------------------------------------- /include/位运算.h: -------------------------------------------------------------------------------- 1 | #ifndef E_BIT_OPERTAIN//模板类防止复用 2 | #define E_BIT_OPERTAIN 3 | /*此库尽量少用，微软有很多现成的宏可以使用，甚至强制转换都可以，位运算远远不止库中的几个,如果不是特别需要，或者对位运算完全不懂的小白可以使用，其他不建议使用，自己手撸比套一层代码强多了*/ 4 | 5 | int 位取反(int 欲取反的数值); 6 | int 左移(int 欲移动的整数, int 欲移动的位数); 7 | int 右移(int 欲移动的整数, int 欲移动的位数); 8 | int 合并整数(int 低位, int 高位); 9 | short 合并短整数(int 低位, int 高位); 10 | short 合并短整数(char 低位, char 高位); 11 | void 取长整数高低位(long long 预取长整数, int* 高位, int* 低位); 12 | //取整数型某一位的值，为1返回真，为0返回假 32位bit 位号下标为0-31 13 | bool 取整数型某位(int 整数, char 位号); 14 | 15 | 16 | 17 | template 18 | long long 位与(const T& t) { 19 | return t; 20 | }; 21 | template 22 | int 位与(const T& num, const Args... args) { 23 | return num & 位与(args...); 24 | }; 25 | template 26 | long long 位或(const T& t) { 27 | return t; 28 | }; 29 | template 30 | long long 位或(const T& num, const Args... args) { 31 | return num | 位或(args...); 32 | }; 33 | 34 | template 35 | long long 位异或(const T& t) { 36 | return t; 37 | }; 38 | template 39 | long long 位异或(const T& num, const Args... args) { 40 | return num ^ 位异或(args...); 41 | }; 42 | 43 | 44 | #endif -------------------------------------------------------------------------------- /include/控制台操作.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef KRNLNCONSOLE 3 | #define KRNLNCONSOLE 4 | #include 5 | bool 置控制台标题(const std::string& title); 6 | bool 置控制台标题(const std::wstring& title); 7 | void 标准输出(int 输出方向); 8 | 9 | template 10 | void 标准输出(int 输出方向, T 输出内容, Args... args) { 11 | // 判断输出内容的类型是否为宽字符 12 | if constexpr (std::is_same::value 13 | || std::is_same::value 14 | || std::is_same::value 15 | || std::is_same::value 16 | || std::is_same::value) { 17 | // 输出内容是宽字符，使用 std::wcout 输出 18 | if (输出方向 == 2) { 19 | std::wcerr << 输出内容; 20 | } 21 | else { 22 | std::wcout << 输出内容; 23 | } 24 | } 25 | else { 26 | // 输出内容不是宽字符，使用 std::cout 输出 27 | if (输出方向 == 2) { 28 | std::cerr << 输出内容; 29 | } 30 | else { 31 | std::cout << 输出内容; 32 | } 33 | } 34 | 35 | // 继续处理其余的参数 36 | 标准输出(输出方向, args...); 37 | } 38 | 39 | std::string 标准输入A(bool 是否回显 = 1); 40 | std::wstring 标准输入W(bool 是否回显 = 1, std::string 编码格式 = std::wcin.getloc().name()); 41 | #ifdef _UNICODE 42 | #define 标准输入(是否回显) 标准输入W(是否回显) 43 | #else 44 | #define 标准输入(是否回显) 标准输入A(是否回显) 45 | #endif 46 | 47 | inline void 释放控制台() { 48 | 49 | } 50 | 51 | template 52 | void 置控制台编码(const std::wstring& 编码类型, Stream& 流 = std::wcin) { 53 | 流.imbue(std::locale(编码类型)); 54 | } 55 | template 56 | void 置控制台编码(const std::string& 编码类型, Stream& 流 = std::wcin) { 57 | 流.imbue(std::locale(编码类型)); 58 | } 59 | template 60 | std::locale 取控制台编码(Stream& 流 = std::wcin) { 61 | 62 | return 流.getloc(); 63 | } 64 | 65 | #endif // !KRNLNCONSOLE 66 | 67 | -------------------------------------------------------------------------------- /include/操作系统.h: -------------------------------------------------------------------------------- 1 | //此位置为平台系统级常用处理函数,不同平台的提供的代码并不相同，注意区分 2 | #ifdef _WIN32//win环境下的系统处理 3 | #include 4 | 5 | #pragma region 注册表操作 6 | enum class 注册表根目录 7 | { 8 | 根类 = 1, 9 | 现行设置, 10 | 现行用户, 11 | 本地机器, 12 | 所有用户 13 | }; 14 | bool 注册项是否存在(注册表根目录 根目录, const std::string& 注册项名称); 15 | bool 注册项是否存在(注册表根目录 根目录, const std::wstring& 注册项名称); 16 | bool 写注册项(注册表根目录 rootDirectory, const std::string& fullPathKeyName, const std::string& value); 17 | bool 写注册项(注册表根目录 rootDirectory, const std::string& fullPathKeyName, const std::vector& value); 18 | bool 写注册项(注册表根目录 rootDirectory, const std::wstring& fullPathKeyName, const std::wstring& value); 19 | bool 写注册项(注册表根目录 rootDirectory, const std::wstring& fullPathKeyName, const std::vector& value); 20 | 21 | #pragma endregion 22 | 23 | 24 | 25 | BOOL 安装字体(const std::string& 字体文件); 26 | /*当安装字体为内存资源时为临时安装，生命周期跟随进程，并且为进程独占，其他进程须发共享已安装的字体资源*/ 27 | HANDLE 安装字体(const std::vector& FontData); 28 | BOOL 安装字体(const std::wstring& 字体文件); 29 | BOOL 卸载字体(const std::string& 字体文件); 30 | BOOL 卸载字体(const std::wstring& 字体文件); 31 | BOOL 卸载字体(HANDLE 字体句柄); 32 | BOOL 延迟(INT64 millisecond); 33 | BOOL 播放音乐(const std::vector& 欲播放的音乐, bool 是否循环播放 = false, bool 是否同步播放 = false); 34 | BOOL 播放音乐(const std::string& 欲播放的音乐, bool 是否循环播放 = false, bool 是否同步播放 = false); 35 | BOOL 播放音乐(const std::wstring& 欲播放的音乐, bool 是否循环播放 = false, bool 是否同步播放 = false); 36 | BOOL 停止播放(); 37 | #pragma region 非暴漏接口 38 | namespace KrnlnMidInside { 39 | struct MIDIFILEDATAINFO 40 | { 41 | unsigned char* pData; 42 | size_t dwSize; 43 | }; 44 | //字符串0，宽字符串1，数据指针2; 45 | struct MIDMUSIC 46 | { 47 | 48 | std::string name; 49 | std::wstring wname; 50 | MIDIFILEDATAINFO data; 51 | 52 | int datatype; 53 | }; 54 | void PackMid(std::vector& MidStruct, std::string MemData); 55 | void PackMid(std::vector& MidStruct, std::wstring MemData); 56 | void PackMid(std::vector& MidStruct, std::vector MemData); 57 | void PlayMid(int times, int interval, std::vector wannaplay); 58 | } 59 | #pragma endregion 60 | 61 | template 62 | void 播放MID(int 播放次数, int 间隔时间, T... 欲播放MID) 63 | { 64 | std::vector Data; 65 | std::initializer_list{(PackMid(Data, std::forward(欲播放MID)), 0)...}; 66 | KrnlnMidInside::PlayMid(播放次数, 间隔时间, Data); 67 | }; 68 | 69 | 70 | 71 | 72 | /* 73 | 调用格式： 〈整数型〉 信息框 （通用型 提示信息，整数型 按钮，［文本型 窗口标题］） - 系统核心支持库->系统处理 74 | 英文名称：MsgBox 75 | 在对话框中显示信息，等待用户单击按钮，并返回一个整数告诉用户单击哪一个按钮。该整数为以下常量值之一： 0、#确认钮； 1、#取消钮； 2、#放弃钮； 3、#重试钮； 4、#忽略钮； 5、#是钮； 6、#否钮。如果对话框有“取消”按钮，则按下 ESC 键与单击“取消”按钮的效果相同。本命令为初级命令。 76 | 参数<1>的名称为“提示信息”，类型为“通用型（all）”。提示信息只能为文本、数值、逻辑值或日期时间。如果提示信息为文本且包含多行，可在各行之间用回车符 (即“字符 (13)”)、换行符 (即“字符 (10)”) 或回车换行符的组合 (即：“字符 (13) + 字符 (10)”) 来分隔。 77 | 参数<2>的名称为“按钮”，类型为“整数型（int）”，初始值为“0”。参数值由以下几组常量值组成，在将这些常量值相加以生成参数值时，每组值只能取用一个数字（第五组除外）： 78 | 第一组（描述对话框中显示按钮的类型与数目）： 79 | 0、#确认钮； 1、#确认取消钮； 2、#放弃重试忽略钮； 3、#取消是否钮； 4、#是否钮； 5、#重试取消钮 80 | 第二组（描述图标的样式）： 81 | 16、#错误图标； 32、#询问图标； 48、#警告图标； 64、#信息图标 82 | 第三组（说明哪一个按钮是缺省默认值）： 83 | 0、#默认按钮一； 256、#默认按钮二； 512、#默认按钮三； 768、#默认按钮四 84 | 第四组（决定如何等待消息框结束）： 85 | 0、#程序等待； 4096、#系统等待 86 | 第五组（其它）： 87 | 65536、#位于前台； 524288、#文本右对齐 88 | 89 | 参数<3>的名称为“窗口标题”，类型为“文本型（text）”，可以被省略。参数值指定显示在对话框标题栏中的文本。如果省略，默认为文本“信息：”。 90 | */ 91 | int 信息框(const std::string& 提示信息, int 按钮 = 0, const std::string& 窗口标题 = "信息", HWND 父窗口 = NULL, DWORD 留存时长 = 0); 92 | /* 93 | 调用格式： 〈整数型〉 信息框 （通用型 提示信息，整数型 按钮，［文本型 窗口标题］） - 系统核心支持库->系统处理 94 | 英文名称：MsgBox 95 | 在对话框中显示信息，等待用户单击按钮，并返回一个整数告诉用户单击哪一个按钮。该整数为以下常量值之一： 0、#确认钮； 1、#取消钮； 2、#放弃钮； 3、#重试钮； 4、#忽略钮； 5、#是钮； 6、#否钮。如果对话框有“取消”按钮，则按下 ESC 键与单击“取消”按钮的效果相同。本命令为初级命令。 96 | 参数<1>的名称为“提示信息”，类型为“通用型（all）”。提示信息只能为文本、数值、逻辑值或日期时间。如果提示信息为文本且包含多行，可在各行之间用回车符 (即“字符 (13)”)、换行符 (即“字符 (10)”) 或回车换行符的组合 (即：“字符 (13) + 字符 (10)”) 来分隔。 97 | 参数<2>的名称为“按钮”，类型为“整数型（int）”，初始值为“0”。参数值由以下几组常量值组成，在将这些常量值相加以生成参数值时，每组值只能取用一个数字（第五组除外）： 98 | 第一组（描述对话框中显示按钮的类型与数目）： 99 | 0、#确认钮； 1、#确认取消钮； 2、#放弃重试忽略钮； 3、#取消是否钮； 4、#是否钮； 5、#重试取消钮 100 | 第二组（描述图标的样式）： 101 | 16、#错误图标； 32、#询问图标； 48、#警告图标； 64、#信息图标 102 | 第三组（说明哪一个按钮是缺省默认值）： 103 | 0、#默认按钮一； 256、#默认按钮二； 512、#默认按钮三； 768、#默认按钮四 104 | 第四组（决定如何等待消息框结束）： 105 | 0、#程序等待； 4096、#系统等待 106 | 第五组（其它）： 107 | 65536、#位于前台； 524288、#文本右对齐 108 | 109 | 参数<3>的名称为“窗口标题”，类型为“文本型（text）”，可以被省略。参数值指定显示在对话框标题栏中的文本。如果省略，默认为文本“信息：”。 110 | */ 111 | int 信息框(const std::wstring& 提示信息, int 按钮 = 0, const std::wstring& 窗口标题 = L"信息", HWND 父窗口 = NULL, DWORD 留存时长 = 0); 112 | enum class 高级信息框按钮 { 113 | 确认 = 1, 114 | 是 = 2, 115 | 否 = 4, 116 | 取消 = 8, 117 | 重试 = 16, 118 | 关闭 = 32, 119 | 失败 = 0 120 | }; 121 | 高级信息框按钮 operator| (高级信息框按钮 lhs, 高级信息框按钮 rhs); 122 | 高级信息框按钮 高级信息框(const std::wstring& 信息, const std::wstring& 标题 = L"提示", const std::wstring& 窗口标题 = L"", 高级信息框按钮 按钮 = 高级信息框按钮::确认, HWND parent = 0, int 图标 = -1); 123 | #else//Linux POSIX 环境下的系统处理macos用苹果的编程语言比较多，不再单独列出 124 | 125 | 126 | 127 | #endif 128 | 129 | -------------------------------------------------------------------------------- /include/数值转换.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #pragma region 到数值 3 | 4 | double 到数值(const std::string& 待转换的文本或数值); 5 | double 到数值(const std::wstring& 待转换的文本或数值); 6 | 7 | #pragma endregion 8 | #pragma region 数值转换类(WA)及其宏 9 | std::string 数值到大写A(double 欲转换形式的数值, bool 是否转换为简体 = false); 10 | std::string 数值到金额A(double 欲转换形式的数值, bool 是否转换为简体 = false); 11 | std::string 数值到格式文本A(double 欲转换为文本的数值, int 小数保留位数 = 1, bool 是否进行千分位分隔 = false); 12 | std::string 取十六进制文本A(int 欲取进制文本的数值); 13 | std::string 取八进制文本A(int 欲取进制文本的数值); 14 | 15 | std::wstring 数值到大写W(double 欲转换形式的数值, bool 是否转换为简体 = false); 16 | std::wstring 数值到金额W(double 欲转换形式的数值, bool 是否转换为简体 = false); 17 | std::wstring 数值到格式文本W(double 欲转换为文本的数值, int 小数保留位数 = 1, bool 是否进行千分位分隔 = false); 18 | std::wstring 取十六进制文本W(int 欲取进制文本的数值); 19 | std::wstring 取八进制文本W(int 欲取进制文本的数值); 20 | 21 | #ifdef _UNICODE 22 | #define 数值到大写 数值到大写W 23 | #define 数值到金额 数值到金额W 24 | #define 数值到格式文本 数值到格式文本W 25 | #define 取十六进制文本 取十六进制文本W 26 | #define 取八进制文本 取八进制文本W 27 | #else 28 | #define 数值到大写 数值到大写A 29 | #define 数值到金额 数值到金额A 30 | #define 数值到格式文本 数值到格式文本A 31 | #define 取十六进制文本 取十六进制文本A 32 | #define 取八进制文本 取八进制文本A 33 | #endif 34 | 35 | #pragma endregion 36 | #pragma region 到字节 37 | unsigned char 到字节(const std::string& 待转换的文本或数值); 38 | unsigned char 到字节(const std::wstring& 待转换的文本或数值); 39 | 40 | #pragma endregion 41 | 42 | #pragma region 到短整数 43 | 44 | short 到短整数(const std::string& 待转换的文本或数值); 45 | short 到短整数(const std::wstring& 待转换的文本或数值); 46 | #pragma endregion 47 | 48 | #pragma region 到整数 49 | 50 | int 到整数(const std::string& 待转换的文本或数值); 51 | int 到整数(const std::wstring& 待转换的文本或数值); 52 | #pragma endregion 53 | 54 | #pragma region 到长整数 55 | 56 | long long 到长整数(const std::string& 待转换的文本或数值); 57 | long long 到长整数(const std::wstring& 待转换的文本或数值); 58 | 59 | #pragma endregion 60 | 61 | #pragma region 到小数 62 | float 到小数(const std::wstring& 待转换的文本或数值); 63 | float 到小数(const std::string& 待转换的文本或数值); 64 | 65 | #pragma endregion 66 | 67 | long 十六进制(const std::wstring& 十六进制文本常量); 68 | long 十六进制(const std::string& 十六进制文本常量); 69 | long 二进制(const std::string& 二进制文本常量); 70 | long 二进制(const std::wstring& 二进制文本常量); 71 | int 反转整数字节序(int 待反转的整数值); -------------------------------------------------------------------------------- /include/数据操作.h: -------------------------------------------------------------------------------- 1 | /*获取指定数据的MD5,可用网络传输中简单的的数据验证，但是不建议出于安全目的使用MD5，因为它被认为容易受到冲突攻击。还有更安全的替代方案，如SHA-2和SHA-3。对于高度安全数据更简易使用更专业openssl库，或者自己实现算法*/ 2 | std::string 取数据摘要A(std::vector 字节集数据); 3 | /*获取指定数据的MD5,可用网络传输中简单的的数据验证，但是不建议出于安全目的使用MD5，因为它被认为容易受到冲突攻击。还有更安全的替代方案，如SHA-2和SHA-3。对于高度安全数据更简易使用更专业openssl库，或者自己实现算法*/ 4 | std::wstring 取数据摘要W(std::vector 字节集数据); 5 | #ifdef _UNICODE 6 | #define 取数据摘要(X) 取数据摘要W(X) 7 | #else 8 | #define 取数据摘要(X) 取数据摘要A(X) 9 | #endif // _UNICODE 10 | std::vector 加密数据(std::vector 字节集数据, const std::string& 密码文本, const int 加密算法 = 1); 11 | std::vector 加密数据(std::vector 字节集数据, const std::wstring& 密码文本, const int 加密算法 = 1); 12 | std::vector 解密数据(std::vector 字节集数据, const std::wstring& 密码文本, const int 加密算法 = 1); 13 | std::vector 解密数据(std::vector 字节集数据, const std::string& 密码文本, const int 加密算法 = 1); -------------------------------------------------------------------------------- /include/数组.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef E_BIT_VECTOR//模板类防止复用 3 | #define E_BIT_VECTOR 4 | #include"vector" 5 | #include 6 | template 7 | using 数组 = std::vector; 8 | template 9 | void 重定义数组(std::vector& 欲重定义的数组变量, bool 是否保留以前的内容, intptr_t 数组对应维的上限值) 10 | { 11 | if (是否保留以前的内容) { 12 | 欲重定义的数组变量.resize(数组对应维的上限值); 13 | } 14 | else { 15 | 16 | 欲重定义的数组变量.clear(); 17 | 欲重定义的数组变量.resize(数组对应维的上限值); 18 | } 19 | } 20 | template 21 | size_t 取数组成员数(std::vector& 欲重定义的数组变量) { 22 | return 欲重定义的数组变量.size(); 23 | } 24 | template 25 | int 取数组下标(const std::vector& 欲取某维最大下标的数组变量) { 26 | 27 | return 欲取某维最大下标的数组变量.capacity(); 28 | 29 | } 30 | template 31 | void 复制数组(std::vector& 复制到的数组变量, const std::vector& 待复制的数组数据) { 32 | 复制到的数组变量.assign(待复制的数组数据.begin(), 待复制的数组数据.end()); 33 | } 34 | template 35 | void 加入成员(std::vector& 欲加入成员的数组变量, const Type2& 欲加入的成员数据) { 36 | 欲加入成员的数组变量.push_back(欲加入的成员数据); 37 | } 38 | template 39 | void 插入成员(std::vector& 欲插入成员的数组变量, intptr_t 欲插入的位置, const Type2& 欲插入的成员数据) 40 | { 41 | 欲插入成员的数组变量.insert(欲插入成员的数组变量.begin() + 欲插入的位置, 欲插入的成员数据); 42 | 43 | } 44 | //索引和易有些区别，从0开始 45 | template 46 | intptr_t 删除成员(std::vector& 欲删除成员的数组变量, intptr_t 欲删除的位置, intptr_t 欲删除的成员数目 = 1) { 47 | if (欲删除的位置 < 0 || 欲删除的成员数目 > 欲删除成员的数组变量.size()) { 48 | return 0; 49 | } 50 | intptr_t 数目 = 0; 51 | for (intptr_t i = 1; i <= 欲删除的成员数目; i++) 52 | { 53 | 欲删除成员的数组变量.erase(欲删除成员的数组变量.begin() + 欲删除的位置); 54 | if (欲删除成员的数组变量.size() < 欲删除的位置 - 1) { 55 | break; 56 | } 57 | 数目 = i; 58 | } 59 | 60 | return 数目; 61 | }; 62 | template 63 | void 清除数组(std::vector& 欲删除成员的数组变量) { 64 | std::vector ret; 65 | 欲删除成员的数组变量.swap(ret); 66 | }; 67 | template 68 | void 数组排序(std::vector& 数值数组变量, bool 排序方向是否为从小到大 = true) { 69 | if (std::is_same::value) { 70 | if (排序方向是否为从小到大) { 71 | std::sort(数值数组变量.begin(), 数值数组变量.end()); 72 | } 73 | else { 74 | std::sort(数值数组变量.rbegin(), 数值数组变量.rend()); 75 | } 76 | 77 | 78 | } 79 | 80 | }; 81 | //循环赋值效率没测试，应该不会很快，直接memsetvector数据的地址和长度也许会快一些，而且兼容非数值类数据类型,注意自定义结构体的对齐，别搞大了访问越界 82 | //其次注意容器和对象，尽量指针操作 83 | template 84 | void 数组清零(std::vector& 数值数组变量) { 85 | memset(&数值数组变量[0], 0, sizeof(Type) * 数值数组变量.size()); 86 | }; 87 | 88 | //字符串拼接重载运算符，也可使使用字符串拼接函数 89 | template 90 | std::vector operator+(const std::vector& 数组1, const std::vector& 数组2) { 91 | std::vector result; 92 | result.reserve(数组1.size() + 数组2.size()); 93 | result.insert(result.end(), 数组1.begin(), 数组1.end()); 94 | result.insert(result.end(), 数组2.begin(), 数组2.end()); 95 | return result; 96 | } 97 | //二分查找一定要确保数值类以及升序类型，返回数组下标，与易的下标不同注意区分 98 | template 99 | intptr_t 二分查找(std::vector& 有序数组变量, Type 要查找的值) { 100 | intptr_t left = 0; 101 | intptr_t right = 有序数组变量.size() - 1; 102 | while (left <= right) { 103 | intptr_t mid = left + (right - left) / 2; 104 | if (有序数组变量[mid] == 要查找的值) { 105 | return mid; 106 | } 107 | else if (有序数组变量[mid] < 要查找的值) { 108 | left = mid + 1; 109 | } 110 | else { 111 | right = mid - 1; 112 | } 113 | } 114 | return -1; 115 | } 116 | //用于非数值类的数组寻找,返回数组下标，与易的下标不同注意区分 117 | template 118 | intptr_t 数组查找(const std::vector& 数组, Type 要查找的值) { 119 | auto it = std::find(数组.begin(), 数组.end(), 要查找的值); 120 | if (it != 数组.end()) { 121 | return std::distance(数组.begin(), it); 122 | } 123 | else { 124 | return -1; 125 | } 126 | } 127 | #endif -------------------------------------------------------------------------------- /include/文件读写.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | enum class 内存文件操作命令 { 3 | 读入缓冲区, 4 | 写入缓冲区, 5 | 提交缓冲区, 6 | 检查缓冲区 7 | }; 8 | enum class 读写位置移动方向 9 | { 10 | 前 = 0, 11 | 后 = 1, 12 | }; 13 | enum class 文件读写位置 14 | { 15 | 文件首 = 1, 16 | 文件尾, 17 | 现行位置 18 | }; 19 | 20 | 21 | 22 | 23 | class 内存文件 24 | { 25 | private: 26 | std::vector 数据; // 储存文件数据 27 | size_t 当前位置; // 当前读写位置 28 | size_t 文件大小; // 文件长度 29 | // 改变缓冲区长度 30 | void 改变缓冲区长度(size_t 新长度); 31 | 32 | public: 33 | // 初始化内存文件，可以指定 vector 的初始容量 34 | 内存文件(size_t grow_bytes = 1024); 35 | 36 | ~内存文件(); 37 | // 38 | void 关闭(); 39 | // 读取数据 40 | std::vector 读(size_t 读入长度); 41 | //写入数据 42 | void 写(); 43 | void 写(const std::vector& data); 44 | void 写(const std::string& data); 45 | void 写(const std::wstring& data); 46 | void 写(char* data); 47 | void 写(wchar_t* data); 48 | void 写(const char* data); 49 | void 写(const wchar_t* data); 50 | template 51 | void 写(const T& data) { 52 | 写(vector((unsigned char*)&data, ((unsigned char*)&data + sizeof(T)))); 53 | } 54 | template 55 | void 写(const T& data, const Args&...args) { 56 | 写(data); 57 | 写(args...); 58 | } 59 | 60 | //插入数据 61 | bool 插入(std::vector data); 62 | 63 | // 移动读写位置 64 | bool 移动读写位置(long offset, 文件读写位置 origin = 文件读写位置::现行位置); 65 | 66 | // 移动到文件开头 67 | void 移到文件首(); 68 | 69 | // 移动到文件末尾 70 | void 移到文件尾(); 71 | 72 | // 设置文件长度 73 | void 置文件大小(size_t 新长度); 74 | // 获取文件长度 75 | size_t 获取长度() const; 76 | 77 | // 获取当前读写位置 78 | size_t 获取位置() const; 79 | 80 | 81 | }; -------------------------------------------------------------------------------- /include/文本转换.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | //因为核心库中部分W和A所以unicode与ansi转换很有必要 3 | //库中复用性较强，使用内联减少栈开辟消耗 4 | std::wstring 文本到宽文本(const std::string& 文本); 5 | std::string 宽文本到文本(const std::wstring& 宽文本); 6 | std::wstring UTF8到宽文本(const char* lpcszString); 7 | std::wstring UTF8到宽文本(const std::string& utf8string); 8 | std::string 宽文本到UTF8(const std::wstring& widestring); 9 | std::string 文本到UTF8(const std::string& 文本); 10 | -------------------------------------------------------------------------------- /include/时间操作.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #pragma region 到时间(WA码) 3 | std::tm 到时间(const std::string& 时间文本); 4 | std::tm 到时间(const std::wstring& 时间文本); 5 | #pragma endregion 6 | 7 | #pragma region 取对应时间 8 | int 取日(const std::tm& 时间); 9 | int 取分钟(const std::tm& 时间); 10 | int 取秒(const std::tm& 时间); 11 | int 取某月天数(int 年份, int 月份); 12 | int 取年份(const std::tm& 时间); 13 | std::tm 取日期(std::tm 时间); 14 | std::tm 取时间(std::tm 时间); 15 | #pragma endregion 16 | 17 | #pragma region 取时间部分 18 | //时间操作 - 取时间部分 19 | /* 20 | 调用格式： 〈整数型〉 取时间部分 （std::tm 欲取其部分的时间，整数型 欲取的时间部分） - 系统核心支持库->时间操作 21 | 英文名称：TimePart 22 | 返回一个包含已知时间指定部分的整数。本命令为初级命令。 23 | 参数<1>的名称为“欲取其部分的时间”，类型为“std::tm（std::tm）”。 24 | 参数<2>的名称为“欲取的时间部分”，类型为“整数型（int）”。参数值可以为以下常量： 25 | 1、#年份； 2、#季度； 3、#月份； 4、#自年首周数； 5、#日； 6、#小时； 7、#分钟； 8、#秒； 9、#星期几； 10、#自年首天数。其中：自年首周数、自年首天数均从 1 开始。 26 | */ 27 | int 取时间部分(const std::tm& 欲取其部分的时间, int 欲取的时间部分); 28 | #pragma endregion 29 | //时间操作 - 取时间间隔 30 | /* 31 | 调用格式： 〈双精度小数型〉 取时间间隔 （std::tm 时间1，std::tm 时间2，整数型 取间隔部分） - 系统核心支持库->时间操作 32 | 英文名称：TimeDiff 33 | 返回一个数值，表示“时间1”减去“时间2”之后的间隔数目。注意：每个星期以星期天为第一天。本命令为初级命令。 34 | 参数<1>的名称为“时间1”，类型为“std::tm（std::tm）”。 35 | 参数<2>的名称为“时间2”，类型为“std::tm（std::tm）”。 36 | 参数<3>的名称为“取间隔部分”，类型为“整数型（int）”。参数值指定取时间间隔的单位，可以为以下常量： 1、#年份； 2、#季度； 3、#月份； 4、#周； 5、#日； 6、#小时； 7、#分钟； 8、#秒。 37 | */ 38 | double 取时间间隔(const std::tm& 时间1, const std::tm& 时间2, int 取间隔部分); 39 | 40 | std::tm 取现行时间(); 41 | int 取小时(const std::tm& 时间); 42 | int 取星期几(const std::tm& 时间); 43 | int 取月份(const std::tm& 时间); 44 | 45 | 46 | //时间操作 - 时间到文本 47 | /* 48 | 调用格式： 〈文本型〉 时间到文本 （std::tm 欲转换到文本的时间，［整数型 转换部分］） - 系统核心支持库->时间操作 49 | 英文名称：TimeToText 50 | 将指定时间转换为文本并返回。本命令为初级命令。 51 | 参数<1>的名称为“欲转换到文本的时间”，类型为“std::tm（std::tm）”。 52 | 参数<2>的名称为“转换部分”，类型为“整数型（int）”，可以被省略。参数值可以为以下常量： 53 | 1、#全部转换； 2、#日期部分； 3、#时间部分。如果省略了本参数，默认为“#全部转换”。 54 | */ 55 | std::string 时间到文本A(const std::tm& 欲转换到文本的时间, int 转换部分 = 1, bool 是否为中文 = true); 56 | //时间操作 - 时间到文本 57 | /* 58 | 调用格式： 〈文本型〉 时间到文本 （std::tm 欲转换到文本的时间，［整数型 转换部分］） - 系统核心支持库->时间操作 59 | 英文名称：TimeToText 60 | 将指定时间转换为文本并返回。本命令为初级命令。 61 | 参数<1>的名称为“欲转换到文本的时间”，类型为“std::tm（std::tm）”。 62 | 参数<2>的名称为“转换部分”，类型为“整数型（int）”，可以被省略。参数值可以为以下常量： 63 | 1、#全部转换； 2、#日期部分； 3、#时间部分。如果省略了本参数，默认为“#全部转换”。 64 | */ 65 | std::wstring 时间到文本W(const std::tm& 欲转换到文本的时间, int 转换部分 = 1, bool 是否为中文 = true); 66 | 67 | 68 | //时间操作 - 增减时间 69 | /*void Getstd::tmPart(std::tm dt,INT& nYear,INT& nMonth,INT& nDay) 70 | 调用格式： 〈std::tm〉 增减时间 （std::tm 时间，整数型 被增加部分，整数型 增加值） - 系统核心支持库->时间操作 71 | 英文名称：TimeChg 72 | 返回一个时间，这一时间被加上或减去了一段间隔。如果改变后的时间无效，将自动靠近最近的有效时间。本命令为初级命令。 73 | 参数<1>的名称为“时间”，类型为“std::tm（std::tm）”。 74 | 参数<2>的名称为“被增加部分”，类型为“整数型（int）”。参数值指定增加或减少时间的哪一部分，可以为以下常量： 75 | 1、#年份； 2、#季度； 3、#月份； 4、#周； 5、#日； 6、#小时； 7、#分钟； 8、#秒。 76 | 参数<3>的名称为“增加值”，类型为“整数型（int）”。相对于被增加部分的增加或减少数值。 77 | */ 78 | std::tm 增减时间(const std::tm& 时间, int 被增加部分, int 增加值); 79 | std::tm 指定时间(int 年, int 月 = 1, int 日 = 1, int 小时 = 0, int 分钟 = 0, int 秒 = 0); 80 | bool 置现行时间(const std::tm& 欲设置的时间); 81 | -------------------------------------------------------------------------------- /include/流程控制.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | /****************************************************************************** 3 | * 流程控制 * 4 | *******************************************************************************/ 5 | 6 | //为很么使用"强制结束()"而不是"结束()",首先是因为结束宏的定义和其他函数中析构函数中文的成员函数有歧义，其二想让大家尽量减少使用，控制台程序跑完，或者加条件跳出，win sendmessage销毁主线程主窗口 7 | #define 强制结束() exit(0) 8 | #define 到循环尾() continue 9 | #define 跳出循环() break 10 | 11 | //从一开始计次，完成所有循环次数; 12 | #define 计次循环首(次数, 变量) for (size_t (变量) = 1; 变量 <= (次数); 变量++) 13 | 14 | 15 | #define 判断循环首(逻辑条件) while(逻辑条件) 16 | #define 判断循环尾() do 17 | 18 | #define 循环判断首() do 19 | #define 循环判断尾(逻辑条件) while(逻辑条件) 20 | 21 | #define 如果(逻辑条件) if(逻辑条件) 22 | #define 否则 else 23 | #define 如果真(逻辑条件) if(逻辑条件) 24 | #define 返回 return 25 | 26 | #define 判断(逻辑条件) if(逻辑条件) 27 | #define 变量循环首(变量起始值,变量目标值,变量递增值,循环变量) for ((循环变量) = (变量起始值); 循环变量 <= (变量目标值); 循环变量=循环变量+(变量递增值)) 28 | -------------------------------------------------------------------------------- /include/环境存取.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifdef _WIN32 3 | std::vector 枚举注册表项(HKEY 根类, const std::wstring& 父路径); 4 | std::vector 枚举注册表项(HKEY 根类, const std::string& 父路径); 5 | std::vector 取命令行W(); 6 | std::vector 取命令行A(); 7 | 8 | size_t 取命令行W(std::vector& saryArgs); 9 | size_t 取命令行A(std::vector& saryArgs); 10 | #ifdef _UNICODE 11 | #define 取命令行 取命令行W 12 | #else 13 | #define 取命令行 取命令行A 14 | #endif 15 | 16 | 17 | #endif 18 | #ifdef _UNICODE 19 | #define 取运行目录 取运行目录W 20 | #define 取执行文件名 取执行文件名W 21 | #else 22 | #define 取运行目录 取运行目录A 23 | #define 取执行文件名 取执行文件名A 24 | #endif 25 | 26 | 27 | std::string 取执行文件名A(); 28 | std::wstring 取执行文件名W(); 29 | 30 | std::string 读环境变量(const std::string& 环境变量名称); 31 | std::wstring 读环境变量(const std::wstring& 环境变量名称); 32 | 33 | 34 | 35 | //将目录中所有的"/"转为"\",所有的大写转小写 36 | std::string 规范化路径(const std::string& 路径); 37 | //将目录中所有的"/"转为"\",所有的大写转小写 38 | std::wstring 规范化路径(const std::wstring& 路径); 39 | std::wstring 取运行目录W(); 40 | std::string 取运行目录A(); 41 | 42 | bool 写环境变量(const std::string& 环境变量名称, const std::string& 欲写入内容); 43 | bool 写环境变量(const std::wstring& 环境变量名称, const std::wstring& 欲写入内容); 44 | 45 | 46 | 47 | 48 | /*目录为空则取当前路径*/ 49 | std::string 合并路径(const std::string& 文件名, const std::string& 目录 = ""); 50 | /*目录为空则取当前路径*/ 51 | std::wstring 合并路径(const std::wstring& 文件名, const std::wstring& 目录 = L""); -------------------------------------------------------------------------------- /include/磁盘操作.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlongsCode/LibKrnln/0a1f9aa06e10742469dacab29e94261a825f378b/include/磁盘操作.h -------------------------------------------------------------------------------- /include/程序进程.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | void 禁止重复运行(const std::string& identifier, void(*callback)()); 3 | void 禁止重复运行(const std::wstring& identifier, void(*callback)()); -------------------------------------------------------------------------------- /include/算术运算.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | int 取符号(double 数); 3 | 4 | double 取绝对值(double 数); 5 | 6 | /* 7 | 调用格式： 〈整数型〉 绝对取整 （双精度小数型 欲取整的小数） - 系统核心支持库->算术运算 8 | 英文名称：fix 9 | 返回一个小数的整数部分。本命令与“取整”命令不相同之处为： 10 | 如果给定小数为负数，则本命令返回大于或等于该小数的第一个负整数，而“取整”命令则会返回小于或等于该小数的第一个负整数。例如，本命令将 -7.8 转换成 -7，而“取整”命令将 -7.8 转换成 -8。本命令为初级命令。 11 | 参数<1>的名称为“欲取整的小数”，类型为“双精度小数型（double）”。 12 | 参数<1>的名称为“返回的小数部分绝对值”，小数容易精度缺失，类型为“双精度小数型指针（pdouble）”。 13 | */ 14 | int 绝对取整(double x); 15 | 16 | double 角度到弧度(double 欲转换的角度值); 17 | 18 | double 弧度到角度(double 欲转换的角度值); 19 | 20 | int 取整(double 数); 21 | 22 | double 求次方(double 欲求次方数值, int 次方数); 23 | 24 | double 四舍五入(double 欲被四舍五入的值, int 被舍入位置); 25 | 26 | double 求平方根(double 欲求其平方根的数值); 27 | 28 | double 求余弦(double 欲进行计算的角); 29 | 30 | double 求正弦(double 欲进行计算的角); 31 | 32 | double 求正切(double 欲进行计算的角); 33 | 34 | double 求自然对数(double 欲求其自然对数的数值); 35 | 36 | double 求反正切(double 欲进行计算的角); 37 | 38 | /* 39 | 调用格式： 〈双精度小数型〉 求反对数 （双精度小数型 欲求其反对数的数值） - 系统核心支持库->算术运算 40 | 英文名称：exp 41 | 返回 e（自然对数的底）的某次方。本命令为初级命令。 42 | 参数<1>的名称为“欲求其反对数的数值”，类型为“双精度小数型（double）”。如果参数值超过 709.782712893，将导致计算溢出。 43 | */ 44 | double 求反对数(double 欲求其反对数的数值); 45 | 46 | 47 | /* 48 | 调用格式： 〈逻辑型〉 是否运算正确 （双精度小数型 欲校验的计算结果） - 系统核心支持库->算术运算 49 | 英文名称：IsCalcOK 50 | 对乘、除、“求次方”、“求平方根”、“求正弦值”、“求余弦值”、“求正切值”、“求反正切值”、“求自然对数”、“求反对数”等等数学运算命令所计算出来的双精度结果数值进行校验，如果该数值正确有效，返回真。如果该数值是运算错误或运算溢出后的结果，返回假。本命令为初级命令。 51 | 参数<1>的名称为“欲校验的计算结果”，类型为“双精度小数型（double）”。 52 | 53 | */ 54 | bool 是否运算正确(double 欲校验的计算结果); 55 | 56 | ///* 57 | // 调用格式： 〈无返回值〉 置随机数种子 （［整数型 欲置入的种子数值］） - 系统核心支持库->算术运算 58 | // 英文名称：randomize 59 | // 为随机数生成器初始化一个种子值，不同的种子值将导致“取随机数”命令返回不同的随机数系列。本命令为初级命令。 60 | // 参数<1>的名称为“欲置入的种子数值”，类型为“整数型（int）”，可以被省略。如果省略本参数，将默认使用当前计算机系统的时钟值。 61 | //*/ 62 | //void 置随机数种子(unsigned int 欲置入的种子数值 = GetTickCount64()); 63 | 64 | /* 65 | 调用格式： 〈变整数〉 取随机数 （［变整数 欲取随机数的最小值］，［变整数 欲取随机数的最大值］） - 系统核心支持库->算术运算 66 | 英文名称：rnd 67 | 返回一个指定范围内大于0的随机数值。在使用本命令取一系列的随机数之前，应该先使用“置随机数种子”命令为随机数生成器初始化一个种子值。本命令为初级命令。 68 | 参数<1>的名称为“欲取随机数的最小值”，类型为“变整数（int）”，可以被省略。参数必须大于或等于零。本参数如果被省略，默认为 0 。 69 | 参数<2>的名称为“欲取随机数的最大值”，类型为“变整数（int）”，可以被省略。参数必须大于或等于零。本参数如果被省略，默认为无限。 70 | */ 71 | size_t 取随机数(size_t 欲取随机数的最小值 = 0, size_t 欲取随机数的最大值 = -1); 72 | 73 | 74 | std::wstring 阶乘(uint64_t 求阶乘数); 75 | 76 | std::wstring 双阶乘(uint64_t 求阶乘数); 77 | 78 | bool 是否素数(uint64_t 数值); 79 | 80 | 81 | int 取斐波那契数列项值(int n); 82 | 83 | 84 | bool 一阶微分(double(*一阶微分方程)(double, double), double 已知的x值, double 已知的y值, double 要求解的x值, double 允许的误差, double 初始步长, double 最小步长); 85 | 86 | int 数值积分计算(double(*函数)(double), int 样本区间, double 积分下限, double 积分上限); -------------------------------------------------------------------------------- /include/系统处理.h: -------------------------------------------------------------------------------- 1 | int 取屏幕高度(); 2 | int 取屏幕宽度(); 3 | void 延时(int 欲等待的时间); 4 | /*关闭方式：1:#关机;2:#重启;3:#注销;4:#休眠5:#冬眠。注意在Windows95/98/ME下冬眠等同于休眠。*|**/ 5 | bool 关闭系统(int 关闭方式 = 1, bool 是否强制执行 = false); 6 | bool 剪辑板可有文本(); 7 | //进程名称或窗口标题 8 | bool 终止进程(std::wstring process_name_or_window_title); 9 | //进程名称或窗口标题 10 | bool 终止进程(std::string process_name_or_window_title); 11 | //进程ID 12 | bool 终止进程(unsigned int process_id); -------------------------------------------------------------------------------- /include/线程操作.h: -------------------------------------------------------------------------------- 1 | bool 等待线程(void* 线程句柄, int 等待时间 = -1); 2 | void 退出许可区(void* 互斥体); 3 | void 进入许可区(void* 互斥体); 4 | bool 删除进入许可证(void* 互斥体); 5 | void* 创建进入许可证(); 6 | void* 启动线程(void(*函数)(void*), void* 参数); 7 | 8 | // 调用格式: bool 关闭线程句柄, 命令说明: "返回真表示已成功关闭线程句柄。在Linux下，如果线程已经结束，本命令可能返回假。" 9 | // 参数<1>: 线程句柄 void*, 参数说明: "可通过“启动线程”的第三个参数获取线程句柄。" 10 | bool 关闭线程句柄(void* 线程句柄); 11 | bool 强制结束线程(void* 线程句柄); 12 | #define 创建临界区(x) 创建进入许可证(x) 13 | #define 删除临界区(x) 删除进入许可证(x) 14 | 15 | 16 | #define 进入临界区(x) 进入许可区(x) 17 | #define 退出临界区(x) 退出许可区(x) 18 | -------------------------------------------------------------------------------- /include/网络通信.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | /*打开指定的url，或者是指定的文件夹*/ 3 | void 打开指定网址(const std::string& url); 4 | /*打开指定的url，或者是指定的文件夹*/ 5 | void 打开指定网址(const std::wstring& url); 6 | 7 | 8 | std::string 取本机名(); 9 | 10 | 11 | 12 | std::wstring 取本机IPW(); 13 | 14 | std::string 取本机IPA(); 15 | 16 | #ifdef _UNICODE 17 | #define 取本机IP 取本机IPW 18 | #else 19 | #define 取本机IP 取本机IPA 20 | #endif 21 | #pragma endregion 22 | -------------------------------------------------------------------------------- /include/逻辑比较.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #define 真 true 3 | #define 假 false 4 | #define 或 || 5 | #define 且 && 6 | #define 取反(x) !x 7 | 8 | bool 近似等于(std::wstring 被比较文本, std::wstring 比较文本); 9 | bool 近似等于(std::string 被比较文本, std::string 比较文本); 10 | bool 约等于(std::string 参1, std::string 参2); 11 | bool 约等于(std::wstring 参1, std::wstring 参2); 12 | bool 文本对比(std::string 文本1, std::string 文本2); 13 | bool 文本对比(std::string 文本1, std::string 文本2); -------------------------------------------------------------------------------- /src/位运算/位取反.cpp: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | /* 6 | 将指定数值每一个比特位的值取反后返回。 7 | 类型变量 <欲取反的数值> 8 | 9 | */ 10 | KrnlnApi int 位取反(int 欲取反的数值) { 11 | 12 | int n = ~欲取反的数值; 13 | return n; 14 | } -------------------------------------------------------------------------------- /src/位运算/取整数型某位.cpp: -------------------------------------------------------------------------------- 1 | //取整数型某一位的值，为1返回真，为0返回假 位号为0-31 2 | KrnlnApi bool 取整数型某位(int 整数, char 位号) 3 | { 4 | return (整数 & (unsigned int)(1 << 位号)) >> 位号; 5 | } -------------------------------------------------------------------------------- /src/位运算/取长整数高低位.cpp: -------------------------------------------------------------------------------- 1 | #include"windows.h" 2 | 3 | 4 | //void 取长整数高低位(long long 预取长整数,int* 高位, int* 低位) { 5 | // LARGE_INTEGER* lNum = (LARGE_INTEGER*)&预取长整数; 6 | // *高位 = (int)lNum->HighPart; 7 | // *低位 = (int)lNum->LowPart; 8 | //} 9 | 10 | KrnlnApi void 取长整数高低位(long long A, int* a3, int* a4) 11 | { 12 | int* pnum = (int*)&A; 13 | *a3 = pnum[1]; 14 | *a4 = pnum[0]; 15 | } -------------------------------------------------------------------------------- /src/位运算/右移.cpp: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | /* 7 | 将某整数的数据位右移指定位数，返回移动后的结果 8 | 类型变量 <欲移动的位数> 9 | 10 | */ 11 | KrnlnApi int 右移(int 欲移动的整数, int 欲移动的位数) { 12 | int n = 欲移动的整数 >> 欲移动的位数; 13 | 14 | return n; 15 | 16 | } -------------------------------------------------------------------------------- /src/位运算/合并整数.cpp: -------------------------------------------------------------------------------- 1 | #if defined(_WIN64) 2 | typedef __int64 INT_PTR, * PINT_PTR; 3 | typedef unsigned __int64 UINT_PTR, * PUINT_PTR; 4 | typedef __int64 LONG_PTR, * PLONG_PTR; 5 | typedef unsigned __int64 ULONG_PTR, * PULONG_PTR; 6 | #define __int3264 __int64 7 | #else 8 | typedef int INT_PTR, * PINT_PTR; 9 | typedef unsigned int UINT_PTR, * PUINT_PTR; 10 | typedef long LONG_PTR, * PLONG_PTR; 11 | typedef unsigned long ULONG_PTR, * PULONG_PTR; 12 | #define __int3264 __int32 13 | #endif 14 | typedef long LONG; 15 | typedef unsigned short WORD; typedef unsigned long DWORD; 16 | typedef ULONG_PTR DWORD_PTR, * PDWORD_PTR; 17 | #define MAKELONG(a, b) ((LONG)(((WORD)(((DWORD_PTR)(a)) & 0xffff)) | ((DWORD)((WORD)(((DWORD_PTR)(b)) & 0xffff))) << 16)) 18 | 19 | 20 | /* 21 | 将第一个整数的低16位放置到结果整数的低16位，将第二个整数的低16位放置到结果整数的高16位，以此合并成一个整数，并返回合并后的结果 22 | 类型变量 <用作合并的整数2> 23 | 24 | */ 25 | KrnlnApi int 合并整数(int 低位, int 高位) { 26 | int n = MAKELONG(低位, 高位); 27 | return n; 28 | } 29 | -------------------------------------------------------------------------------- /src/位运算/合并短整数.cpp: -------------------------------------------------------------------------------- 1 | #if defined(_WIN64) 2 | typedef __int64 INT_PTR, * PINT_PTR; 3 | typedef unsigned __int64 UINT_PTR, * PUINT_PTR; 4 | typedef __int64 LONG_PTR, * PLONG_PTR; 5 | typedef unsigned __int64 ULONG_PTR, * PULONG_PTR; 6 | #define __int3264 __int64 7 | #else 8 | typedef int INT_PTR, * PINT_PTR; 9 | typedef unsigned int UINT_PTR, * PUINT_PTR; 10 | typedef long LONG_PTR, * PLONG_PTR; 11 | typedef unsigned long ULONG_PTR, * PULONG_PTR; 12 | #define __int3264 __int32 13 | #endif 14 | 15 | typedef unsigned char BYTE; 16 | typedef unsigned short WORD; 17 | typedef ULONG_PTR DWORD_PTR, * PDWORD_PTR; 18 | #define MAKEWORD(a, b) ((WORD)(((BYTE)(((DWORD_PTR)(a)) & 0xff)) | ((WORD)((BYTE)(((DWORD_PTR)(b)) & 0xff))) << 8)) 19 | 20 | 21 | /* 22 | 将第一个整数的低8位放置到结果短整数的低8位，将第二个整数的低8位放置到结果短整数的高8位，以此合并成一个短整数，并返回合并后的结果 23 | 类型变量 <用作合并的整数2> 24 | 25 | */ 26 | 27 | KrnlnApi short 合并短整数(int 低位, int 高位) { 28 | int n = MAKEWORD(低位, 高位); 29 | return n; 30 | } 31 | 32 | 33 | KrnlnApi short 合并短整数(char 低位, char 高位) 34 | { 35 | char str[2] = { 低位, 高位 }; 36 | char* 字符 = str; 37 | return *(short*)字符; 38 | } -------------------------------------------------------------------------------- /src/位运算/左移.cpp: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | /* 7 | 将某整数的数据位左移指定位数，返回移动后的结果 8 | 类型变量 <欲移动的位数> 9 | 10 | */ 11 | KrnlnApi int 左移(int 欲移动的整数, int 欲移动的位数) { 12 | 13 | int n = 欲移动的整数 << 欲移动的位数; 14 | 15 | return n; 16 | } -------------------------------------------------------------------------------- /src/字节集操作/取字节集中间.cpp: -------------------------------------------------------------------------------- 1 | #include"vector" 2 | using namespace std; 3 | //vector 4 | /* 5 | 返回一个字节集，其中包含指定字节集中从指定位置算起指定数量的字节 6 | 类型变量 <欲取出字节的数目> 7 | 8 | */ 9 | KrnlnApi vector 取字节集中间(const vector& 欲取其部分的字节集, size_t 起始取出位置, size_t 欲取出字节的数目) { 10 | size_t nDataSize = 欲取其部分的字节集.size(); 11 | size_t nObjLen = 欲取出字节的数目; 12 | if (nDataSize == 0 || nObjLen <= 0) { 13 | return {}; 14 | } 15 | size_t nStart = 起始取出位置; 16 | if (nStart <= 0) { 17 | nStart = 1; 18 | } 19 | if (nStart - 1 > nDataSize) { 20 | return {}; 21 | } 22 | return vector(欲取其部分的字节集.data() + 起始取出位置 - 1, (欲取其部分的字节集.data() + 起始取出位置 - 1) + nDataSize); 23 | } -------------------------------------------------------------------------------- /src/字节集操作/取字节集内整数.cpp: -------------------------------------------------------------------------------- 1 | #include"vector" 2 | 3 | 4 | 5 | 6 | // 调用格式： 〈整数型〉 取字节集内整数 （字节集 待处理的字节集，整数型 欲获取整数所处偏移，［逻辑型 是否反转字节序］） - 系统核心支持库->字节集操作 7 | // 英文名称：GetIntInsideBin 8 | // 返回字节集中所指定位置处的整数。本命令为初级命令。 9 | // 参数<1>的名称为“待处理的字节集”，类型为“字节集（bin）”。提供待处理的字节集。 10 | // 参数<2>的名称为“欲获取整数所处偏移”，类型为“整数型（int）”。提供所欲获取的整数值在字节集中的偏移位置。 11 | // 参数<3>的名称为“是否反转字节序”，类型为“逻辑型（bool）”，可以被省略。指定是否将所获取整数值的字节序进行反转,譬如十六进制整数0x12345678,反转后将为0x78563412. 本功能在与类似Java这样的语言进行数据交互时很有用处. 如果参数被省略，默认值为假. 12 | // 13 | // 操作系统需求： Windows、Linux 14 | KrnlnApi int 取字节集内整数(const std::vector& 待处理的字节集, size_t 欲获取整数所处偏移, bool 是否反转字节序) { 15 | const unsigned char* pSrc = 待处理的字节集.data(); 16 | if (!pSrc) { 17 | return 0; 18 | } 19 | size_t nLen = 待处理的字节集.size(); 20 | size_t off = 欲获取整数所处偏移; 21 | if (nLen - off < 0) { 22 | return 0; 23 | } 24 | int nValue = *(int*)(pSrc + off); 25 | if (是否反转字节序) 26 | { 27 | unsigned int nTmp = (unsigned int)nValue; 28 | nValue = nTmp >> 24; 29 | nValue |= ((nTmp & 0x00FF0000) >> 8); 30 | nValue |= ((nTmp & 0x0000FF00) << 8); 31 | nValue |= ((nTmp & 0x000000FF) << 24); 32 | } 33 | return nValue; 34 | } -------------------------------------------------------------------------------- /src/字节集操作/取字节集右边.cpp: -------------------------------------------------------------------------------- 1 | #include"vector" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | 8 | /* 9 | 返回一个字节集，其中包含指定字节集中从右边算起指定数量的字节 10 | 类型变量 <欲取出字节的数目> 11 | */ 12 | KrnlnApi vector 取字节集右边(const vector& 欲取其部分的字节集, size_t 欲取出字节的数目) { 13 | if (欲取其部分的字节集.empty()) { 14 | return {}; 15 | } 16 | size_t nDataSize = 欲取其部分的字节集.size(); 17 | if (nDataSize == 0 || 欲取出字节的数目 <= 0) { 18 | return {}; 19 | } 20 | size_t nOffset = nDataSize - 欲取出字节的数目; 21 | if (nOffset < 0) { 22 | nOffset = 0; 23 | } 24 | nDataSize = 欲取出字节的数目; 25 | if (nDataSize > 欲取其部分的字节集.size()) { 26 | nDataSize = 欲取其部分的字节集.size(); 27 | } 28 | return vector((欲取其部分的字节集.data() + nOffset), (欲取其部分的字节集.data() + nOffset) + nDataSize); 29 | } 30 | -------------------------------------------------------------------------------- /src/字节集操作/取字节集左边.cpp: -------------------------------------------------------------------------------- 1 | #include"vector" 2 | using namespace std; 3 | //vector 4 | 5 | 6 | 7 | /* 8 | 返回一个字节集，其中包含指定字节集中从左边算起指定数量的字节 9 | 类型变量 <欲取出字节的数目> 10 | 11 | */ 12 | KrnlnApi vector 取字节集左边(const vector& 欲取其部分的字节集, size_t 欲取出字节的数目) { 13 | if (欲取其部分的字节集.size() == 0 || 欲取其部分的字节集.empty()) { 14 | return vector(); 15 | } 16 | if (欲取出字节的数目 <= 0) { 17 | 18 | return vector(); 19 | } 20 | if (欲取出字节的数目 > 欲取其部分的字节集.size()) { 21 | 欲取出字节的数目 = 欲取其部分的字节集.size(); 22 | 23 | } 24 | return vector(欲取其部分的字节集.data(), 欲取其部分的字节集.data() + 欲取出字节的数目); 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/字节集操作/取字节集长度.cpp: -------------------------------------------------------------------------------- 1 | #include"vector" 2 | using namespace std; 3 | 4 | 5 | 6 | //字节集操作 - 取字节集长度 7 | /* 8 | 调用格式： 〈整数型〉 取字节集长度 （字节集 字节集数据） - 系统核心支持库->字节集操作 9 | 英文名称：BinLen 10 | 取字节集型数据的长度。本命令为初级命令。 11 | 参数<1>的名称为“字节集数据”，类型为“字节集（bin）”。参数值指定欲检查其长度的字节集数据。 12 | */ 13 | KrnlnApi size_t 取字节集长度(const vector& 字节集数据) {//宏代替也可 14 | return 字节集数据.size(); 15 | } -------------------------------------------------------------------------------- /src/字节集操作/取空白字节集.cpp: -------------------------------------------------------------------------------- 1 | #include"vector" 2 | 3 | 4 | /* 5 | 返回具有特定数目 0 字节的字节集 6 | 类型变量 <零字节数目> 7 | */ 8 | KrnlnApi std::vector 取空白字节集(size_t 零字节数目) 9 | { 10 | if (零字节数目 == 0) { 11 | return std::vector(); 12 | } 13 | return std::vector(零字节数目, 0); 14 | } 15 | -------------------------------------------------------------------------------- /src/字节集操作/取重复字节集.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | KrnlnApi std::vector 取重复字节集(size_t 重复次数, const std::vector& 待重复的字节集) 4 | { 5 | if (重复次数 <= 0 || 待重复的字节集.empty()) 6 | { 7 | return {}; 8 | } 9 | std::vector buffer(待重复的字节集.size() * 重复次数); 10 | for (size_t i = 0; i < 重复次数; ++i) 11 | { 12 | std::copy(待重复的字节集.begin(), 待重复的字节集.end(), buffer.begin() + i * 待重复的字节集.size()); 13 | } 14 | return buffer; 15 | } 16 | 17 | //KrnlnApi std::vector 取重复字节集(size_t 重复次数, const std::vector& 待重复的字节集) { 18 | // 19 | // if (重复次数 <= 0 || 待重复的字节集.empty()) 20 | // return {}; 21 | // size_t nLen = 待重复的字节集.size(); 22 | // if (nLen == 0)return {}; 23 | // 24 | // const unsigned char* pSrc = 待重复的字节集.data(); 25 | // size_t nBuf = nLen * 重复次数; 26 | // unsigned char* pData = new unsigned char[nBuf]; 27 | // if (!pData) 28 | // { 29 | // return {}; 30 | // } 31 | // unsigned char* pDest = pData; 32 | // for (size_t i = 0; i < 重复次数; i++) 33 | // { 34 | // memcpy(pDest, pSrc, nLen);//pushaback不如原始数组操作速度快 35 | // pDest += nLen; 36 | // } 37 | // std::vector 返回值(pData, pData + nBuf); 38 | // delete[]pData; 39 | // return 返回值; 40 | //} -------------------------------------------------------------------------------- /src/字节集操作/字节集拼接.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | KrnlnApi std::vector 字节集拼接(std::vector 字节集1, const std::vector& 字节集2) { 4 | 字节集1.insert(字节集1.end(), 字节集2.begin(), 字节集2.end()); 5 | return 字节集1; 6 | } 7 | 8 | 9 | -------------------------------------------------------------------------------- /src/字节集操作/字节集替换.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | // 改自七号 5 | KrnlnApi vector 字节集替换(const vector& 欲替换其部分的字节集, size_t 起始替换位置, size_t 替换长度, const vector& 用作替换的字节集) 6 | { 7 | 8 | if (欲替换其部分的字节集.empty()) 9 | return {}; 10 | const unsigned char* pBin = 欲替换其部分的字节集.data(); 11 | const unsigned char* pSubBin = 用作替换的字节集.data(); 12 | vector ret; 13 | size_t nSubLen; 14 | size_t nLen = 欲替换其部分的字节集.size(); 15 | if (用作替换的字节集.empty()) 16 | nSubLen = 0; 17 | else 18 | nSubLen = 用作替换的字节集.size(); 19 | 20 | size_t nRpLen = 替换长度; 21 | if (nRpLen < 0) nRpLen = 0; 22 | 23 | size_t nStart = 起始替换位置 - 1; 24 | if (nStart < 0) 25 | nStart = 0; 26 | else if (nStart > nLen) 27 | nStart = nLen - 1; 28 | 29 | // 新长度 = 源长度 - 替换长度 + 子串长度 30 | // 起始点 + 替换长度 <= 源长度 31 | if (nStart + nRpLen > nLen) nRpLen = nLen - nStart; 32 | if (nLen - nRpLen + nSubLen <= 0) return {}; 33 | size_t nNewLen = nLen - nRpLen + nSubLen; 34 | 35 | 36 | unsigned char* pRetn; 37 | unsigned char* pTemp; 38 | if (nStart == 0) // 往前拼接 39 | { 40 | if (nSubLen == 0) // 子串为空 41 | return vector(pBin + nRpLen, pBin + nRpLen + nNewLen); 42 | 43 | pRetn = new unsigned char[nNewLen]; 44 | pTemp = pRetn; 45 | memcpy(pTemp, pSubBin, nSubLen); 46 | memcpy(pTemp + nSubLen, pBin + nRpLen, nLen - nRpLen); 47 | ret = vector(pRetn, pRetn + nNewLen); 48 | delete[]pRetn; 49 | return ret; 50 | } 51 | else if (nStart >= nLen) // 往后拼接 52 | { 53 | if (nSubLen == 0) // 子串为空 54 | return vector(pBin, pBin + nNewLen); 55 | 56 | pRetn = new unsigned char[nNewLen]; 57 | pTemp = pRetn; 58 | memcpy(pTemp, pBin, nLen); 59 | memcpy(pTemp + nLen, pSubBin, nSubLen); 60 | ret = vector(pRetn, pRetn + nNewLen); 61 | delete[]pRetn; 62 | return ret; 63 | } 64 | 65 | // 中间拼接 66 | pRetn = pRetn = new unsigned char[nNewLen]; 67 | pTemp = pRetn; 68 | 69 | 70 | memcpy(pTemp, pBin, nStart); 71 | pTemp += nStart; 72 | if (nSubLen > 0) 73 | { 74 | memcpy(pTemp, pSubBin, nSubLen); 75 | pTemp += nSubLen; 76 | } 77 | if (nStart + nSubLen < nNewLen) 78 | memcpy(pTemp, pBin + nStart + nRpLen, nLen - nStart - nRpLen); 79 | 80 | ret = vector(pRetn, pRetn + nNewLen); 81 | delete[]pRetn; 82 | return ret; 83 | } -------------------------------------------------------------------------------- /src/字节集操作/字节集重载运算符.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | KrnlnApi std::vector operator+(const std::vector& 字节集1, const std::vector& 字节集2) { 3 | std::vector result; 4 | result.reserve(字节集1.size() + 字节集2.size()); 5 | result.insert(result.end(), 字节集1.begin(), 字节集1.end()); 6 | result.insert(result.end(), 字节集2.begin(), 字节集2.end()); 7 | return result; 8 | } -------------------------------------------------------------------------------- /src/字节集操作/指针到字节集.cpp: -------------------------------------------------------------------------------- 1 | #include"vector" 2 | using namespace std; 3 | //vector 4 | 5 | 6 | 7 | 8 | 9 | 10 | /* 11 | 返回指定内存指针所指向地址处的一段数据，注意调用本命令前一定要确保所提供的内存地址段真实有效。本命令的最佳使用场合就是在易语言回调子程序和易语言DLL公开子程序用作获取外部数据 12 | 类型变量 <内存数据长度> 本参数提供该内存地址处所需获取的数据长度 13 | 14 | */ 15 | KrnlnApi vector 指针到字节集(void* 内存数据指针, size_t 内存数据长度) { 16 | return std::vector((unsigned char*)内存数据指针, (unsigned char*)内存数据指针 + 内存数据长度); 17 | } -------------------------------------------------------------------------------- /src/字节集操作/置字节集内整数.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include"vector" 3 | using namespace std; 4 | //vector 5 | 6 | 7 | /* 8 | 设置字节集中所指定位置处的整数值 9 | 类型变量 <是否反转字节序> 指定是否将所设置整数的字节序进行反转,譬如十六进制整数0x12345678,反转后将为0x78563412. 本功能在与类似Java这样的语言进行数据交互时很有用处. 如果参数被省略，默认值为假. 10 | 11 | */ 12 | KrnlnApi void 置字节集内整数(vector 待处理的字节集, size_t 欲设置整数所处偏移, int 欲设置的整数值, bool 是否反转字节序) { 13 | 14 | 15 | unsigned char* pSrc = 待处理的字节集.data(); 16 | if (!pSrc) return; 17 | 18 | size_t nLen = 待处理的字节集.size(); 19 | size_t off = 欲设置整数所处偏移; 20 | if (nLen - off < 0) return; 21 | 22 | int nValue = 欲设置的整数值; 23 | if (是否反转字节序) 24 | { 25 | int nTmp = nValue; 26 | nValue = nTmp >> 24; 27 | nValue |= ((nTmp & 0x00FF0000) >> 8); 28 | nValue |= ((nTmp & 0x0000FF00) << 8); 29 | nValue |= ((nTmp & 0x000000FF) << 24); 30 | } 31 | *(unsigned char*)(pSrc + off) = nValue; 32 | } -------------------------------------------------------------------------------- /src/控制台操作/打开控制台.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | KrnlnApi void 打开终端() 4 | { 5 | #ifdef _WIN32 6 | if (AllocConsole()) { 7 | freopen("CONOUT$", "w", stdout); 8 | } 9 | #else 10 | freopen("/dev/tty", "w", stdout); 11 | #endif 12 | } 13 | -------------------------------------------------------------------------------- /src/控制台操作/标准输入.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #ifdef _WIN32 4 | #include 5 | #else 6 | #include 7 | #endif // _WIN32 8 | 9 | 10 | /* 在标准输入设备上请求输入一行文本，返回用户所输入的内容。注意本命令只能在控制台程序中使用。 11 | 参数<1>的名称为“是否回显”，类型为“逻辑型（bool）”，可以被省略,默认为真。本参数决定输入时是否显示所输入字符，为假不显示，为真显示。如果被省略，默认值为真，即回显。可以通过将本参数设置为假以输入密码等特殊信息。*/ 12 | KrnlnApi std::string 标准输入A(bool 是否回显) 13 | { 14 | std::string result; 15 | if (是否回显) { 16 | // 使用 std::getline 从标准输入流读取一行字符串 17 | std::getline(std::cin, result); 18 | } 19 | else { 20 | #ifdef _WIN32 21 | char c; 22 | while ((c = (char)_getch()) != '\r' && c != '\0' && c != '\n') { 23 | result.push_back(c); 24 | } 25 | #else 26 | char* c = getpass(nullptr); 27 | result = c ? c : ""; 28 | #endif // _WIN32 29 | 30 | } 31 | return result; 32 | } 33 | 34 | KrnlnApi std::wstring 标准输入W(bool 是否回显, std::string 编码格式) 35 | { 36 | 37 | std::wcin.imbue(std::locale(编码格式)); 38 | std::wstring result; 39 | if (是否回显) { 40 | // 使用 std::getline 从标准输入流读取一行字符串 41 | std::getline(std::wcin, result); 42 | } 43 | else { 44 | #ifdef _WIN32 45 | wchar_t c; 46 | while ((c = (wchar_t)_getch()) != L'\r' && c != L'\0' && c != L'\n') { 47 | result.push_back(c); 48 | } 49 | #else 50 | wchar_t* c = _wgetpass(nullptr); 51 | result = c ? c : L""; 52 | #endif // _WIN32 53 | 54 | } 55 | return result; 56 | } 57 | 58 | 59 | -------------------------------------------------------------------------------- /src/控制台操作/标准输出.cpp: -------------------------------------------------------------------------------- 1 | KrnlnApi void 标准输出(int 输出方向) { 2 | // 函数出口 3 | } -------------------------------------------------------------------------------- /src/控制台操作/置控制台标题.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #include 3 | #else 4 | #include 5 | #endif 6 | 7 | #include 8 | #include 9 | 10 | 11 | /* 在标准输入设备上请求输入一行文本，返回用户所输入的内容。注意本命令只能在控制台程序中使用。 12 | 参数<1>的名称为“是否回显”，类型为“逻辑型（bool）”，可以被省略,默认为真。本参数决定输入时是否显示所输入字符，为假不显示，为真显示。如果被省略，默认值为真，即回显。可以通过将本参数设置为假以输入密码等特殊信息。*/ 13 | KrnlnApi bool 置控制台标题(const std::string& title) 14 | { 15 | #ifdef _WIN32 16 | return SetConsoleTitleA(title.c_str()); 17 | #else 18 | std::string command = "title " + title; 19 | return !system(command.c_str()); 20 | #endif 21 | } 22 | 23 | KrnlnApi bool 置控制台标题(const std::wstring& title) 24 | { 25 | #ifdef _WIN32 26 | return SetConsoleTitleW(title.c_str()); 27 | #else 28 | std::wstring_convert> conv; 29 | std::string command = "title " + conv.to_bytes(title); 30 | return !system(command.c_str()); 31 | #endif 32 | } 33 | 34 | -------------------------------------------------------------------------------- /src/操作系统/信息框.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #include 3 | #include 4 | using namespace std; 5 | EXTERN_C{ 6 | int WINAPI MessageBoxTimeoutA(IN HWND hWnd, IN LPCSTR lpText, IN LPCSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); 7 | int WINAPI MessageBoxTimeoutW(IN HWND hWnd, IN LPCWSTR lpText, IN LPCWSTR lpCaption, IN UINT uType, IN WORD wLanguageId, IN DWORD dwMilliseconds); 8 | } 9 | 10 | KrnlnApi int 信息框(const wstring& 提示信息, int 按钮, const wstring& 窗口标题, HWND 父窗口, DWORD 留存时长) { 11 | const HWND hOldFocusWnd = ::GetFocus(); 12 | INT nResult = 1; 13 | if (留存时长 > 0) 14 | { 15 | nResult = ::MessageBoxTimeoutW((HWND)父窗口, 提示信息.c_str(), 窗口标题.c_str(), 按钮, 0, 留存时长); 16 | } 17 | else 18 | { 19 | nResult = ::MessageBoxW((HWND)父窗口, 提示信息.c_str(), 窗口标题.c_str(), 按钮); 20 | } 21 | 22 | if (hOldFocusWnd != NULL && ::IsWindow(hOldFocusWnd)) { 23 | ::SetFocus(hOldFocusWnd); 24 | } 25 | return nResult - 1; 26 | } 27 | 28 | 29 | KrnlnApi int 信息框(const string& 提示信息, int 按钮, const string& 窗口标题, HWND 父窗口, DWORD 留存时长) { 30 | const HWND hOldFocusWnd = ::GetFocus(); 31 | INT nResult = 1; 32 | if (留存时长 > 0) 33 | { 34 | nResult = ::MessageBoxTimeoutA((HWND)父窗口, 提示信息.c_str(), 窗口标题.c_str(), 按钮, 0, 留存时长); 35 | } 36 | else 37 | { 38 | nResult = ::MessageBoxA((HWND)父窗口, 提示信息.c_str(), 窗口标题.c_str(), 按钮); 39 | } 40 | 41 | if (hOldFocusWnd != NULL && ::IsWindow(hOldFocusWnd)) { 42 | ::SetFocus(hOldFocusWnd); 43 | } 44 | return nResult - 1; 45 | } 46 | #endif 47 | 48 | 49 | -------------------------------------------------------------------------------- /src/操作系统/安装与卸载字体.cpp: -------------------------------------------------------------------------------- 1 |  2 | #ifdef _WIN32 3 | #include 4 | #include 5 | #include 6 | #include 7 | #pragma comment(lib,"shlwapi.lib") 8 | using namespace std; 9 | KrnlnApi HANDLE 安装字体(const vector& FontData) 10 | { 11 | DWORD dwFonts = 0; 12 | return AddFontMemResourceEx((void*)FontData.data(), (DWORD)FontData.size(), 0, &dwFonts); 13 | } 14 | KrnlnApi BOOL 安装字体(const std::string& 字体文件) 15 | { 16 | char pszPath[MAX_PATH] = { 0 }; 17 | BOOL result = FALSE; 18 | if (SHGetSpecialFolderPathA(0, pszPath, 20, 0)) 19 | { 20 | if (PathFileExistsA(字体文件.c_str())) 21 | { 22 | string::size_type iPos = 字体文件.find_last_of('\\'); 23 | string filename = 字体文件.substr(iPos, 字体文件.length() - iPos); 24 | filename = pszPath + filename; 25 | 26 | if (CopyFileA(字体文件.c_str(), filename.c_str(), TRUE)) 27 | { 28 | BOOL Ret = AddFontResourceA(字体文件.c_str()); 29 | 30 | result = Ret; 31 | if (Ret) { 32 | SendMessageA(HWND_BROADCAST, 0x1Du, 0, 0); 33 | } 34 | } 35 | } 36 | } 37 | return result; 38 | } 39 | KrnlnApi BOOL 安装字体(const std::wstring& 字体文件) 40 | { 41 | wchar_t pszPath[MAX_PATH] = { 0 }; 42 | BOOL result = FALSE; 43 | if (SHGetSpecialFolderPathW(0, pszPath, 20, 0)) 44 | { 45 | 46 | if (PathFileExistsW(字体文件.c_str())) 47 | { 48 | wstring::size_type iPos = 字体文件.find_last_of('\\'); 49 | wstring filename = 字体文件.substr(iPos, 字体文件.length() - iPos); 50 | filename = pszPath + filename; 51 | if (CopyFileW(字体文件.c_str(), filename.c_str(), TRUE)) 52 | { 53 | 54 | BOOL Ret = AddFontResourceW(字体文件.c_str()); 55 | result = Ret; 56 | if (Ret) { 57 | SendMessageW(HWND_BROADCAST, 0x1Du, 0, 0); 58 | } 59 | } 60 | } 61 | } 62 | return result; 63 | } 64 | KrnlnApi BOOL 卸载字体(HANDLE 字体句柄) 65 | { 66 | 67 | return RemoveFontMemResourceEx(字体句柄); 68 | } 69 | KrnlnApi BOOL 卸载字体(const string& lpFileName) 70 | { 71 | BOOL Ret = FALSE; 72 | 73 | Ret = RemoveFontResourceA(lpFileName.c_str()); 74 | if (Ret) 75 | SendMessageA(HWND_BROADCAST, 0x1Du, 0, 0); 76 | return Ret; 77 | } 78 | KrnlnApi bool 卸载字体(const std::wstring& lpFileName) 79 | { 80 | BOOL Ret = FALSE; 81 | 82 | Ret = RemoveFontResourceW(lpFileName.c_str()); 83 | if (Ret) 84 | SendMessageW(HWND_BROADCAST, 0x1Du, 0, 0); 85 | return Ret; 86 | } 87 | #endif 88 | 89 | 90 | 91 | 92 | -------------------------------------------------------------------------------- /src/操作系统/延迟.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #include 3 | 4 | KrnlnApi BOOL 延迟(INT64 millisecond) { 5 | LARGE_INTEGER liDueTime = { 0 }; 6 | liDueTime.QuadPart = -10 * millisecond * 1000 * 1; 7 | HANDLE hTimer = NULL; 8 | hTimer = ::CreateWaitableTimerW(0, FALSE, 0); 9 | if (NULL == hTimer) 10 | return FALSE; 11 | SetWaitableTimer(hTimer, &liDueTime, 0, NULL, NULL, 0); 12 | while (MsgWaitForMultipleObjects(1, &hTimer, FALSE, 1, QS_TIMER) != WAIT_OBJECT_0) { 13 | MSG msg; 14 | while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) { //处理事件 15 | TranslateMessage(&msg); 16 | DispatchMessageW(&msg); 17 | } 18 | } 19 | CloseHandle(hTimer); 20 | return TRUE; 21 | } 22 | #endif 23 | -------------------------------------------------------------------------------- /src/操作系统/播放音乐.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | #pragma comment(lib,"winmm.lib") 7 | 8 | 9 | KrnlnApi BOOL 播放音乐(const vector& 欲播放的音乐, bool 是否循环播放, bool 是否同步播放) { 10 | return ::PlaySoundW(wstring((wchar_t*)欲播放的音乐.data(), 欲播放的音乐.size()).c_str(), 0, (SND_MEMORY | (是否循环播放 ? SND_LOOP : 0) | (是否同步播放 ? SND_SYNC : SND_ASYNC))); 11 | } 12 | KrnlnApi BOOL 播放音乐(const wstring& 欲播放的音乐, bool 是否循环播放, bool 是否同步播放) { 13 | 14 | 15 | return ::PlaySoundW(欲播放的音乐.c_str(), 0, (SND_FILENAME | (是否循环播放 ? SND_LOOP : 0) | (是否同步播放 ? SND_SYNC : SND_ASYNC))); 16 | } 17 | KrnlnApi BOOL 播放音乐(const string& 欲播放的音乐, bool 是否循环播放, bool 是否同步播放) { 18 | return ::PlaySoundA(欲播放的音乐.c_str(), 0, (SND_FILENAME | (是否循环播放 ? SND_LOOP : 0) | (是否同步播放 ? SND_SYNC : SND_ASYNC))); 19 | } 20 | KrnlnApi BOOL 停止播放() { 21 | return PlaySound(NULL, NULL, SND_PURGE); 22 | } 23 | #endif -------------------------------------------------------------------------------- /src/操作系统/注册项是否存在.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #pragma warning(disable:4996) 3 | #include 4 | #include 5 | 6 | enum class 注册表根目录 7 | { 8 | 根类 = 1, 9 | 现行设置, 10 | 现行用户, 11 | 本地机器, 12 | 所有用户 13 | }; 14 | //此处inlie并不是内联，而是防止函数重定义. 15 | inline HKEY GetRegRootVal(注册表根目录 rootDirectory) 16 | { 17 | switch (rootDirectory) 18 | { 19 | case 注册表根目录::根类: 20 | return HKEY_CLASSES_ROOT; 21 | case 注册表根目录::现行设置: 22 | return HKEY_CURRENT_CONFIG; 23 | case 注册表根目录::现行用户: 24 | return HKEY_CURRENT_USER; 25 | case 注册表根目录::本地机器: 26 | return HKEY_LOCAL_MACHINE; 27 | case 注册表根目录::所有用户: 28 | return HKEY_USERS; 29 | } 30 | 31 | return nullptr; 32 | } 33 | 34 | KrnlnApi bool 注册项是否存在(注册表根目录 rootDirectory, const std::string& fullPathKeyName) 35 | { 36 | const HKEY hRootKey = GetRegRootVal(rootDirectory); 37 | if (hRootKey == nullptr) 38 | { 39 | return false; 40 | } 41 | 42 | const size_t keyNameLength = fullPathKeyName.size(); 43 | if (keyNameLength == 0) 44 | { 45 | return false; 46 | } 47 | 48 | char* pSubkey = new char[keyNameLength + 1]; 49 | strcpy(pSubkey, fullPathKeyName.c_str()); 50 | char* pKeyName = strrchr(pSubkey, '\\'); 51 | if (pKeyName != nullptr) 52 | { 53 | *pKeyName = '\0'; 54 | pKeyName++; 55 | } 56 | HKEY hKey; 57 | const LONG openKeyResult = RegOpenKeyA(hRootKey, pSubkey, &hKey); 58 | delete[] pSubkey; 59 | 60 | if (openKeyResult != ERROR_SUCCESS) 61 | { 62 | return false; 63 | } 64 | DWORD valueNameLength = MAX_PATH; 65 | DWORD valueType; 66 | char value[MAX_PATH]; 67 | const LONG queryValueResult = RegQueryValueExA(hKey, pKeyName, nullptr, &valueType, reinterpret_cast(value), &valueNameLength); 68 | RegCloseKey(hKey); 69 | return queryValueResult == ERROR_SUCCESS || queryValueResult == ERROR_MORE_DATA; 70 | } 71 | 72 | 73 | KrnlnApi bool 注册项是否存在(注册表根目录 rootDirectory, const std::wstring& fullPathKeyName) 74 | { 75 | const HKEY hRootKey = GetRegRootVal(rootDirectory); 76 | if (hRootKey == nullptr) 77 | { 78 | return false; 79 | } 80 | const size_t keyNameLength = fullPathKeyName.size(); 81 | if (keyNameLength == 0) 82 | { 83 | return false; 84 | } 85 | 86 | wchar_t* pSubkey = new wchar_t[keyNameLength + 1]; 87 | wcscpy(pSubkey, fullPathKeyName.c_str()); 88 | wchar_t* pKeyName = wcsrchr(pSubkey, L'\\'); 89 | if (pKeyName != nullptr) 90 | { 91 | *pKeyName = L'\0'; 92 | pKeyName++; 93 | } 94 | HKEY hKey; 95 | const LONG openKeyResult = RegOpenKeyW(hRootKey, pSubkey, &hKey); 96 | delete[] pSubkey; 97 | 98 | if (openKeyResult != ERROR_SUCCESS) 99 | { 100 | return false; 101 | } 102 | DWORD valueNameLength = MAX_PATH; 103 | DWORD valueType; 104 | wchar_t value[MAX_PATH]; 105 | const LONG queryValueResult = RegQueryValueExW(hKey, pKeyName, nullptr, &valueType, reinterpret_cast(value), &valueNameLength); 106 | RegCloseKey(hKey); 107 | return queryValueResult == ERROR_SUCCESS || queryValueResult == ERROR_MORE_DATA; 108 | } 109 | #endif -------------------------------------------------------------------------------- /src/操作系统/高级信息框.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #include 3 | #include 4 | #include 5 | #pragma comment(lib, "comctl32.lib") 6 | #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") 7 | 8 | using namespace std; 9 | enum class 高级信息框按钮 { 10 | 确认 = 1, 11 | 是 = 2, 12 | 否 = 4, 13 | 取消 = 8, 14 | 重试 = 16, 15 | 关闭 = 32, 16 | 失败 = 0 17 | }; 18 | KrnlnApi 高级信息框按钮 operator| (高级信息框按钮 lhs, 高级信息框按钮 rhs) 19 | { 20 | return static_cast<高级信息框按钮> (static_cast(lhs) | static_cast(rhs)); 21 | } 22 | KrnlnApi 高级信息框按钮 高级信息框(const wstring& 信息, const wstring& 标题, const wstring& 窗口标题, 高级信息框按钮 按钮, HWND parent, int 图标) 23 | { 24 | const PWSTR icon[] = { nullptr,TD_ERROR_ICON,TD_INFORMATION_ICON,TD_SHIELD_ICON,TD_WARNING_ICON , MAKEINTRESOURCEW(-8),MAKEINTRESOURCEW(-7) }; 25 | TASKDIALOGCONFIG config = { sizeof(TASKDIALOGCONFIG) }; 26 | config.hwndParent = parent; 27 | config.pszWindowTitle = 窗口标题.c_str(); 28 | config.pszMainInstruction = 标题.c_str(); 29 | config.pszContent = 信息.c_str(); 30 | config.dwCommonButtons = static_cast(按钮); 31 | if (图标 > 0 && 图标 <= 6) 32 | { 33 | config.pszMainIcon = icon[图标]; 34 | } 35 | 36 | int buttonPressed; 37 | HRESULT hr = TaskDialogIndirect(&config, &buttonPressed, NULL, NULL); 38 | if (SUCCEEDED(hr)) 39 | { 40 | switch (buttonPressed) { 41 | case IDOK: 42 | return 高级信息框按钮::确认; 43 | case IDCANCEL: 44 | return 高级信息框按钮::取消; 45 | case IDRETRY: 46 | return 高级信息框按钮::重试; 47 | case IDYES: 48 | return 高级信息框按钮::是; 49 | case IDNO: 50 | return 高级信息框按钮::否; 51 | case IDCLOSE: 52 | return 高级信息框按钮::关闭; 53 | default: 54 | break; 55 | } 56 | } 57 | return 高级信息框按钮::失败; 58 | } 59 | 60 | 61 | 62 | #endif -------------------------------------------------------------------------------- /src/数值转换/二进制.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include 3 | 4 | 5 | KrnlnApi long 二进制(const std::string& 二进制文本常量) { 6 | return strtol(二进制文本常量.c_str(), NULL, 2); 7 | 8 | } 9 | 10 | KrnlnApi long 二进制(const std::wstring& 二进制文本常量) { 11 | return wcstol(二进制文本常量.c_str(), NULL, 2); 12 | 13 | } -------------------------------------------------------------------------------- /src/数值转换/到字节.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | KrnlnApi unsigned char 到字节(const std::string& 待转换的文本或数值) { 3 | 4 | if (待转换的文本或数值.empty()) return 0; 5 | return *(unsigned char*)待转换的文本或数值.c_str(); 6 | } 7 | 8 | KrnlnApi unsigned char 到字节(const std::wstring& 待转换的文本或数值) { 9 | 10 | if (待转换的文本或数值.empty()) return 0; 11 | return *(unsigned char*)待转换的文本或数值.c_str(); 12 | } 13 | //unsigned char 到字节(int 待转换的文本或数值) { 14 | // return (unsigned char)待转换的文本或数值; 15 | //} 16 | //unsigned char 到字节(double 待转换的文本或数值) { 17 | // return (unsigned char)到整数(待转换的文本或数值); 18 | //} 19 | //unsigned char 到字节(float 待转换的文本或数值) { 20 | // return (unsigned char)到整数(待转换的文本或数值); 21 | //} 22 | //byte 到字节(unsigned char 待转换的文本或数值) { 23 | // return 待转换的文本或数值; 24 | //} 25 | //byte 到字节(bool 待转换的文本或数值) { 26 | // if (待转换的文本或数值) { 27 | // return 1; 28 | // } 29 | // return 0; 30 | //} 31 | //byte 到字节(short 待转换的文本或数值) { 32 | // return (unsigned char)待转换的文本或数值; 33 | //} 34 | //byte 到字节(INT64 待转换的文本或数值) { 35 | // return (unsigned char)待转换的文本或数值; 36 | //} -------------------------------------------------------------------------------- /src/数值转换/到小数.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | //float 到小数(bool 待转换的文本或数值) { 6 | // if (待转换的文本或数值) { 7 | // return 1; 8 | // } 9 | // return 0; 10 | //} 11 | //float 到小数(INT 待转换的文本或数值) { 12 | // float nRet = 0; 13 | // nRet = 待转换的文本或数值; 14 | // return nRet; 15 | // 16 | //} 17 | //float 到小数(SHORT 待转换的文本或数值) { 18 | // float nRet = 0; 19 | // nRet = 待转换的文本或数值; 20 | // return nRet; 21 | // 22 | //} 23 | //float 到小数(unsigned char 待转换的文本或数值) { 24 | // float nRet = 0; 25 | // nRet = 待转换的文本或数值; 26 | // return nRet; 27 | // 28 | //} 29 | //float 到小数(FLOAT 待转换的文本或数值) { 30 | // float nRet = 0; 31 | // nRet = 待转换的文本或数值; 32 | // return nRet; 33 | // 34 | //} 35 | //float 到小数(double 待转换的文本或数值) { 36 | // float nRet = 0; 37 | // nRet = (float)待转换的文本或数值; 38 | // return nRet; 39 | //} 40 | //float 到小数(INT64 待转换的文本或数值) { 41 | // float nRet = 0; 42 | // nRet = (float)待转换的文本或数值; 43 | // return nRet; 44 | //} 45 | KrnlnApi float 到小数(const std::string& 待转换的文本或数值) { 46 | if (待转换的文本或数值.empty()) 47 | { 48 | return 0.0f; 49 | } 50 | return strtof(待转换的文本或数值.c_str(), nullptr);//std::stof(待转换的文本或数值.c_str());stl老是出毛病 51 | } 52 | 53 | KrnlnApi float 到小数(const std::wstring& 待转换的文本或数值) { 54 | if (待转换的文本或数值.empty()) 55 | { 56 | return 0.0f; 57 | } 58 | return wcstof(待转换的文本或数值.c_str(), nullptr); 59 | } 60 | 61 | -------------------------------------------------------------------------------- /src/数值转换/到数值.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | 6 | //double 到数值 (unsigned char 待转换的文本或数值) { 7 | // INT nVal = 待转换的文本或数值; 8 | // return nVal; 9 | //} 10 | //double 到数值(SHORT 待转换的文本或数值) { 11 | // INT nVal = 待转换的文本或数值; 12 | // return nVal; 13 | //} 14 | //double 到数值(double 待转换的文本或数值) { 15 | // 16 | // 17 | // return 待转换的文本或数值; 18 | // //ArgInf.m_double = strtod(ArgInf.m_pText,NULL); 19 | //} 20 | //double 到数值(FLOAT 待转换的文本或数值) { 21 | // FLOAT floatval = 待转换的文本或数值; 22 | // double ret; 23 | // ret = floatval; 24 | // return ret; 25 | //} 26 | //double 到数值(INT64 待转换的文本或数值) { 27 | // INT64 int64 = 待转换的文本或数值; 28 | // double ret; 29 | // ret = (DOUBLE)int64; 30 | // return ret; 31 | //} 32 | KrnlnApi double 到数值(const std::string& 待转换的文本或数值) { 33 | if (待转换的文本或数值.empty()) 34 | { 35 | return 0; 36 | } 37 | return strtod(待转换的文本或数值.c_str(), NULL); 38 | } 39 | 40 | 41 | KrnlnApi double 到数值(const std::wstring& 待转换的文本或数值) { 42 | if (待转换的文本或数值.empty()) 43 | { 44 | return 0; 45 | } 46 | return wcstod(待转换的文本或数值.c_str(), NULL); 47 | } -------------------------------------------------------------------------------- /src/数值转换/到整数.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | //INT 到整数(int 待转换的文本或数值) { 5 | // INT nRet = 0; 6 | // nRet = 待转换的文本或数值; 7 | // return nRet; 8 | // 9 | //} 10 | //INT 到整数(SHORT 待转换的文本或数值) { 11 | // INT nRet = 0; 12 | // nRet = 待转换的文本或数值; 13 | // return nRet; 14 | // 15 | //} 16 | //INT 到整数(BYTE 待转换的文本或数值) { 17 | // INT nRet = 0; 18 | // nRet = 待转换的文本或数值; 19 | // return nRet; 20 | // 21 | //} 22 | //INT 到整数(FLOAT 待转换的文本或数值) { 23 | // INT nRet = 0; 24 | // nRet = (INT)待转换的文本或数值; 25 | // return nRet; 26 | // 27 | //} 28 | //INT 到整数(double 待转换的文本或数值) { 29 | // INT nRet = 0; 30 | // nRet = (INT)待转换的文本或数值; 31 | // return nRet; 32 | //} 33 | //INT 到整数(INT64 待转换的文本或数值) { 34 | // INT nRet = 0; 35 | // nRet = (INT)待转换的文本或数值; 36 | // return nRet; 37 | //} 38 | //INT 到整数(bool 待转换的文本或数值) { 39 | // return int(待转换的文本或数值); 40 | //} 41 | //INT 到整数(void* 待转换的文本或数值) { 42 | // 43 | // INT nRet = 0; 44 | // nRet = (INT)待转换的文本或数值; 45 | // return nRet; 46 | // 47 | //}; 48 | KrnlnApi int 到整数(const std::wstring& 待转换的文本或数值) { 49 | if (待转换的文本或数值.empty()) 50 | { 51 | return 0; 52 | } 53 | return _wtoi(待转换的文本或数值.c_str()); 54 | } 55 | 56 | 57 | KrnlnApi int 到整数(const std::string& 待转换的文本或数值) { 58 | if (待转换的文本或数值.empty()) 59 | { 60 | return 0; 61 | } 62 | return atoi(待转换的文本或数值.c_str()); 63 | } 64 | -------------------------------------------------------------------------------- /src/数值转换/到短整数.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include 3 | // 4 | // 5 | //short 到短整数(int 待转换的文本或数值) { 6 | // short nRet = 0; 7 | // nRet = (short)待转换的文本或数值; 8 | // return nRet; 9 | // 10 | //} 11 | //short 到短整数(short 待转换的文本或数值) { 12 | // 13 | // return 待转换的文本或数值; 14 | // 15 | //} 16 | //short 到短整数(unsigned char 待转换的文本或数值) { 17 | // return (short)待转换的文本或数值; 18 | //} 19 | //short 到短整数(float 待转换的文本或数值) { 20 | // 21 | // return (short)待转换的文本或数值; 22 | // 23 | //} 24 | //short 到短整数(double 待转换的文本或数值) { 25 | // return (short)待转换的文本或数值; 26 | //} 27 | //short 到短整数(long long 待转换的文本或数值) { 28 | // 29 | // return (short)待转换的文本或数值; 30 | //} 31 | // 32 | 33 | KrnlnApi short 到短整数(const std::string& 待转换的文本或数值) { 34 | if (待转换的文本或数值.empty()) 35 | { 36 | return 0; 37 | } 38 | return (short)atoi(待转换的文本或数值.c_str()); 39 | } 40 | 41 | KrnlnApi short 到短整数(const std::wstring& 待转换的文本或数值) { 42 | if (待转换的文本或数值.empty()) 43 | { 44 | return 0; 45 | } 46 | return (short)_wtoi(待转换的文本或数值.c_str()); 47 | } 48 | -------------------------------------------------------------------------------- /src/数值转换/到长整数.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | ////INT64 到长整数(int 待转换的文本或数值) { 6 | //// INT64 nRet = 0; 7 | //// nRet = 待转换的文本或数值; 8 | //// return nRet; 9 | //// 10 | ////} 11 | ////INT64 到长整数(SHORT 待转换的文本或数值) { 12 | //// INT64 nRet = 0; 13 | //// nRet = 待转换的文本或数值; 14 | //// return nRet; 15 | //// 16 | ////} 17 | ////INT64 到长整数(BYTE 待转换的文本或数值) { 18 | //// INT64 nRet = 0; 19 | //// nRet = 待转换的文本或数值; 20 | //// return nRet; 21 | //// 22 | ////} 23 | ////INT64 到长整数(FLOAT 待转换的文本或数值) { 24 | //// INT64 nRet = 0; 25 | //// nRet = (INT64)待转换的文本或数值; 26 | //// return nRet; 27 | //// 28 | ////} 29 | ////INT64 到长整数(double 待转换的文本或数值) { 30 | //// INT64 nRet = 0; 31 | //// nRet = (INT64)待转换的文本或数值; 32 | //// return nRet; 33 | ////} 34 | ////INT64 到长整数(INT64 待转换的文本或数值) { 35 | //// INT64 nRet = 0; 36 | //// nRet = 待转换的文本或数值; 37 | //// return nRet; 38 | ////} 39 | // 40 | //#define IS_NUMBER_CHAR(ch) ((intptr_t)(ch) >= (intptr_t)'0' && (intptr_t)(ch) <= (intptr_t)'9') 41 | //INT64 StrToN64(const wchar_t* ps) 42 | //{ 43 | // 44 | // 45 | // // 跳过空白 46 | // while (*ps != '\0' && (DWORD)*ps <= (DWORD)' ') 47 | // ps++; 48 | // 49 | // // 跳过空白后遇到了文本结束符? 50 | // if (*ps == '\0') 51 | // return 0; 52 | // 53 | // // 获取数值符号 54 | // bool blpNeg; // 记录是否为负数 55 | // if (*ps == '-') 56 | // { 57 | // blpNeg = TRUE; 58 | // ps++; 59 | // } 60 | // else 61 | // { 62 | // blpNeg = FALSE; 63 | // 64 | // if (*ps == '+') 65 | // ps++; 66 | // } 67 | // 68 | // // 用作计算是否溢出时使用 69 | // const UINT64 c_ui64Cutoff = UINT64_MAX / (UINT64)10; 70 | // const DWORD c_dwCutlim = (DWORD)(UINT64_MAX % (UINT64)10); 71 | // 72 | // // 用作记录所获得的值 73 | // UINT64 u64Value = 0; 74 | // 75 | // // 转换每个字符 76 | // DWORD c = (DWORD)*ps; 77 | // while (IS_NUMBER_CHAR(c)) // 为数字? 78 | // { 79 | // c -= '0'; 80 | // 81 | // if (u64Value > c_ui64Cutoff || (u64Value == c_ui64Cutoff && c > c_dwCutlim)) // 检查是否会导致溢出UINT64 82 | // return (blpNeg ? INT64_MIN : INT64_MAX); // 如果溢出则直接返回 83 | // 84 | // // 加入该数值 85 | // u64Value *= (UINT64)10; 86 | // u64Value += (UINT64)c; 87 | // 88 | // // 去处理下一个数字 89 | // ps++; 90 | // c = *ps; 91 | // } 92 | // 93 | // if (blpNeg) 94 | // return (((INT64)u64Value) < 0 ? INT64_MIN : -((INT64)u64Value)); 95 | // else 96 | // return (u64Value > INT64_MAX ? INT64_MAX : ((INT64)u64Value)); 97 | //} 98 | // 99 | // 100 | // 101 | //INT64 到长整数(const char* 待转换的文本或数值) { 102 | // INT64 nRet = 0; 103 | // 104 | // if (待转换的文本或数值) 105 | // { 106 | // nRet = _atoi64(待转换的文本或数值); 107 | // 108 | // } 109 | // return nRet; 110 | //} 111 | // 112 | //INT64 到长整数(const wchar_t* 待转换的文本或数值) { 113 | // INT64 nRet = 0; 114 | // 115 | // if (待转换的文本或数值) 116 | // { 117 | // std::wstring num(待转换的文本或数值); 118 | // 119 | // nRet = _wtoi64(num.c_str()); 120 | // 121 | // } 122 | // return nRet; 123 | //} 124 | // 125 | //INT64 到长整数(bool 待转换的文本或数值) { 126 | // if (待转换的文本或数值) { 127 | // return 1; 128 | // } 129 | // return 0; 130 | //} 131 | // 132 | //INT64 到长整数(void* 待转换的文本或数值) { 133 | // INT64 nRet = 0; 134 | // nRet = (INT64)待转换的文本或数值; 135 | // return nRet; 136 | //} 137 | 138 | 139 | 140 | KrnlnApi long long 到长整数(const std::wstring& 待转换的文本或数值) { 141 | if (待转换的文本或数值.empty()) 142 | { 143 | return 0; 144 | } 145 | return _wtoi64(待转换的文本或数值.c_str()); 146 | } 147 | KrnlnApi long long 到长整数(const std::string& 待转换的文本或数值) { 148 | if (待转换的文本或数值.empty()) 149 | { 150 | return 0; 151 | } 152 | return _atoi64(待转换的文本或数值.c_str()); 153 | } -------------------------------------------------------------------------------- /src/数值转换/十六进制.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | 3 | using namespace std; 4 | 5 | 6 | KrnlnApi long 十六进制(const wstring& 十六进制文本常量) { 7 | 8 | return wcstol(十六进制文本常量.c_str(), NULL, 16); 9 | 10 | 11 | 12 | } 13 | 14 | 15 | KrnlnApi long 十六进制(const string& 十六进制文本常量) { 16 | 17 | return strtol(十六进制文本常量.c_str(), NULL, 16); 18 | } -------------------------------------------------------------------------------- /src/数值转换/反转整数字节序.cpp: -------------------------------------------------------------------------------- 1 |  2 | KrnlnApi int 反转整数字节序(int 待反转的整数值) 3 | { 4 | unsigned int nRes = 待反转的整数值 >> 24; 5 | nRes |= ((待反转的整数值 & 0x00FF0000) >> 8); 6 | nRes |= ((待反转的整数值 & 0x0000FF00) << 8); 7 | nRes |= ((待反转的整数值 & 0x000000FF) << 24); 8 | return nRes; 9 | } 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/数值转换/取八进制文本.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | KrnlnApi string 取八进制文本A(int 欲取进制文本的数值) { 5 | 6 | char pText[256] = { 0 }; 7 | sprintf_s(pText, 256, "%o", 欲取进制文本的数值); 8 | 9 | return pText; 10 | } 11 | 12 | 13 | KrnlnApi wstring 取八进制文本W(int 欲取进制文本的数值) { 14 | 15 | wchar_t pText[256] = { 0 }; 16 | swprintf_s(pText, 256, L"%o", 欲取进制文本的数值); 17 | return pText; 18 | } -------------------------------------------------------------------------------- /src/数值转换/取十六进制文本.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | #pragma warning(disable:4996) 4 | #define MIN(a, b) ((a) < (b) ? (a) : (b)) 5 | 6 | 7 | 8 | KrnlnApi string 取十六进制文本A(int 欲取进制文本的数值) { 9 | char pText[16] = { 0 }; 10 | sprintf_s(pText, 16, "%X", 欲取进制文本的数值); 11 | return pText; 12 | } 13 | 14 | 15 | KrnlnApi wstring 取十六进制文本W(int 欲取进制文本的数值) 16 | { 17 | int npReqMinWidth = 0; 18 | wchar_t psBuf[64] = {}; 19 | const int npBufLength = 64; 20 | if (npBufLength < sizeof(int) * 8 / 4 + 1) // 此为缓冲区最小需求尺寸 21 | { 22 | 23 | return L""; 24 | } 25 | 26 | 27 | wchar_t buf[32] = {}; 28 | wchar_t* ps = buf; 29 | const wchar_t* psFirstNotZero = NULL; // 用作记录首个非'0'字符,为NULL表示全部为'0'. 30 | 31 | size_t npShiftBits = sizeof(int) * 8 - 4; 32 | 33 | for (size_t npIndex = 0; npIndex < sizeof(int) * 8 / 4; npIndex++) 34 | { 35 | const static wchar_t cs_hex[] = 36 | { 37 | '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 38 | }; 39 | 40 | 41 | // 获得对应的字符索引 42 | const size_t npCharIndex = (size_t)((欲取进制文本的数值 >> npShiftBits) & 0x0F); 43 | 44 | // 记录第一个非'0'字符位置 45 | if (psFirstNotZero == NULL && npCharIndex != 0) 46 | psFirstNotZero = ps; 47 | 48 | *ps++ = cs_hex[npCharIndex]; 49 | npShiftBits -= 4; 50 | } 51 | *ps = '\0'; 52 | 53 | const wchar_t* szResult; 54 | if (npReqMinWidth > 0) // 设定了最小需求宽度? 55 | { 56 | ps -= npReqMinWidth; 57 | 58 | if (ps < buf) 59 | { 60 | szResult = buf; 61 | } 62 | else if (psFirstNotZero == NULL) 63 | { 64 | szResult = ps; 65 | } 66 | else 67 | szResult = MIN(psFirstNotZero, ps); 68 | } 69 | else 70 | { 71 | if (psFirstNotZero == NULL) 72 | { 73 | szResult = L"0"; 74 | } 75 | else 76 | szResult = psFirstNotZero; // 跳过前面所有的'0'字符 77 | } 78 | wcscpy(psBuf, szResult); 79 | return psBuf; 80 | } 81 | 82 | 83 | -------------------------------------------------------------------------------- /src/数值转换/数值到大写.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include"文本转换.h" 3 | #pragma warning(disable:4996) 4 | using namespace std; 5 | 6 | 7 | 8 | 9 | 10 | 11 | #define IsDoubleEqualZero(db) (db >= -1e-6 && db <= 1e-6f) 12 | 13 | inline const wchar_t* N64ToStr(long long n64, wchar_t* psBuf, const int npBufLength) 14 | { 15 | 16 | 17 | if (npBufLength < 26) // 26为最小需求尺寸(可能能更小,但是无需太精确) 18 | return (L""); 19 | 20 | if (n64 == 0) 21 | { 22 | psBuf[0] = '0'; 23 | psBuf[1] = '\0'; 24 | return psBuf; 25 | } 26 | 27 | if (n64 == INT64_MIN) // 此值在下面转换为正数时会失败 28 | return (L"-9223372036854775808"); 29 | 30 | //---------------------------------------------------- 31 | 32 | wchar_t buf[32]; 33 | wchar_t* ps = &buf[31]; 34 | *ps-- = '\0'; 35 | 36 | const bool blpIsNeg = (n64 < 0); // 获得是否为负数 37 | if (blpIsNeg) 38 | n64 = -n64; // 将负数转换为正数 39 | 40 | 41 | while (n64 > 0) 42 | { 43 | 44 | *ps-- = (n64 % 10) + '0'; 45 | n64 /= 10; 46 | } 47 | 48 | 49 | if (blpIsNeg) 50 | *ps = '-'; 51 | else 52 | ps++; 53 | 54 | wcscpy(psBuf, ps); 55 | return psBuf; 56 | } 57 | 58 | KrnlnApi wstring 数值到大写W(double 欲转换形式的数值, bool 是否转换为简体) 59 | { 60 | wstring strConvertResult; 61 | const wchar_t* szNumber; 62 | const wchar_t* szUnit; 63 | if (是否转换为简体) 64 | { 65 | szNumber = L"零一二三四五六七八九"; 66 | szUnit = L"十百千万十百千亿十百千万"; 67 | } 68 | else 69 | { 70 | szNumber = L"零壹贰叁肆伍陆柒捌玖"; 71 | szUnit = L"拾佰仟万拾佰仟亿拾佰仟万"; 72 | } 73 | 74 | wchar_t buf[128] = { 0 }; 75 | wchar_t* psBuf = buf; 76 | 77 | const bool blpNeg = (欲转换形式的数值 < 0); 78 | if (blpNeg) 79 | 欲转换形式的数值 = -欲转换形式的数值; 80 | 81 | if (IsDoubleEqualZero(欲转换形式的数值)) 82 | { 83 | *psBuf = szNumber[0]; 84 | psBuf[1] = '\0'; 85 | } 86 | else if (欲转换形式的数值 > 9999999999999.0) 87 | { 88 | wcscpy(psBuf, L"溢出"); 89 | } 90 | else 91 | { 92 | psBuf = &buf[127]; 93 | *psBuf = '\0'; 94 | 95 | double dbMod = modf(欲转换形式的数值, &欲转换形式的数值); 96 | dbMod *= 100; 97 | if (modf(dbMod + 1e-6, &dbMod) >= 0.5) 98 | dbMod++; 99 | 100 | long long n64 = (long long)欲转换形式的数值; 101 | long long npMod = (long long)dbMod; 102 | 103 | if (npMod >= 100) 104 | { 105 | n64++; 106 | } 107 | else if (npMod != 0) 108 | { 109 | wchar_t buf1[32], buf2[32]; 110 | wchar_t* psNumber = (wchar_t*)N64ToStr(npMod + 100, buf1, 32); 111 | 112 | wchar_t* ps = psNumber + wcslen(psNumber) - 1; 113 | psNumber[0] = '\0'; 114 | while (*ps == '0') 115 | *ps-- = '\0'; 116 | 117 | ps = psNumber + 1; 118 | size_t npIndex = 0; 119 | while ((size_t)*ps >= (size_t)'0' && (size_t)*ps <= (size_t)'9') 120 | { 121 | buf2[npIndex] = szNumber[(size_t)*ps - (size_t)'0']; 122 | npIndex++; 123 | ps++; 124 | } 125 | 126 | psBuf -= npIndex; 127 | memcpy(psBuf, buf2, npIndex * sizeof(wchar_t)); 128 | psBuf--; 129 | *psBuf = L'点'; 130 | } 131 | 132 | if (n64 == 0) 133 | { 134 | psBuf--; 135 | *psBuf = szNumber[0]; 136 | } 137 | else 138 | { 139 | int npZeroType = 0; // 0:还没有任何数字; 1:最近一个是零; 2:最近一个是数字 140 | int npIndex = 0, npMod; 141 | bool blpHaveUnit = false; 142 | 143 | while (n64 > 0) 144 | { 145 | npMod = (intptr_t)(n64 % 10); 146 | n64 /= 10; 147 | 148 | if (npIndex == 4 || npIndex == 8) 149 | blpHaveUnit = false; 150 | 151 | if (npMod == 0) 152 | { 153 | if (npZeroType == 2) 154 | { 155 | psBuf--; 156 | *psBuf = szNumber[0]; 157 | npZeroType = 1; 158 | } 159 | } 160 | else 161 | { 162 | npZeroType = 2; 163 | 164 | if (npIndex > 0) 165 | { 166 | if (blpHaveUnit == false && npIndex >= 4) 167 | { 168 | if (npIndex < 8) 169 | { 170 | if (npIndex > 4) 171 | { 172 | psBuf--; 173 | *psBuf = szUnit[3]; 174 | } 175 | 176 | blpHaveUnit = true; 177 | } 178 | else 179 | { 180 | if (npIndex > 8) 181 | { 182 | psBuf--; 183 | *psBuf = szUnit[7]; 184 | } 185 | 186 | blpHaveUnit = true; 187 | } 188 | } 189 | 190 | psBuf--; 191 | *psBuf = szUnit[npIndex - 1]; 192 | } 193 | 194 | psBuf--; 195 | *psBuf = szNumber[npMod]; 196 | } 197 | 198 | npIndex++; 199 | } 200 | } 201 | 202 | if (blpNeg) 203 | { 204 | psBuf--; 205 | *psBuf = L'负'; 206 | } 207 | } 208 | 209 | 210 | return psBuf; 211 | } 212 | 213 | 214 | KrnlnApi string 数值到大写A(double 欲转换形式的数值, bool 是否转换为简体) { 215 | return 宽文本到文本(数值到大写W(欲转换形式的数值, 是否转换为简体)); 216 | } 217 | -------------------------------------------------------------------------------- /src/数值转换/数值到格式文本.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #pragma warning(disable:4996) 4 | using namespace std; 5 | 6 | #pragma region 宽字符辅助 7 | 8 | #define NERAZERO(db) (db >= -1e-6 && db <= 1e-6) 9 | static inline double RoundDouble(double db, const int npRound) 10 | { 11 | if (NERAZERO(db)) 12 | return db; 13 | 14 | const bool blpNegative = (db < 0); 15 | if (blpNegative) 16 | db = -db; 17 | 18 | if (npRound < 0) 19 | { 20 | double n = pow(10.0, (double)-npRound); 21 | db /= n; 22 | if (modf(db + 1e-6, &db) >= 0.5) 23 | db = db + 1; 24 | db *= n; 25 | } 26 | else if (npRound == 0) 27 | { 28 | if (modf(db + 1e-6, &db) >= 0.5) 29 | db = db + 1; 30 | } 31 | else 32 | { 33 | double n = pow(10.0, (double)npRound); 34 | db *= n; 35 | if (modf(db + 1e-6, &db) >= 0.5) 36 | db = db + 1; 37 | db /= n; 38 | } 39 | 40 | return (blpNegative ? -db : db); 41 | } 42 | 43 | #pragma endregion 44 | 45 | 46 | 47 | KrnlnApi wstring 数值到格式文本W(double 欲转换为文本的数值, int 小数保留位数, bool 是否进行千分位分隔) 48 | { 49 | if (小数保留位数 != INT_MAX) 50 | 欲转换为文本的数值 = RoundDouble(欲转换为文本的数值, 小数保留位数); 51 | 52 | wchar_t buf[128] = { 0 }; 53 | _swprintf(buf, L"%.15G", 欲转换为文本的数值); 54 | 55 | if (小数保留位数 != INT_MAX && 小数保留位数 > 0) 56 | { 57 | wchar_t* ps = wcschr(buf, '.'); 58 | 59 | if (ps == NULL) 60 | { 61 | ps = &buf[wcslen(buf)]; 62 | *ps++ = '.'; 63 | for (int npIndex = 0; npIndex < 小数保留位数; npIndex++) 64 | *ps++ = '0'; 65 | *ps = '\0'; 66 | } 67 | else 68 | { 69 | ps++; 70 | 71 | int npFracNumber = 0; 72 | while (*ps != '\0') 73 | { 74 | npFracNumber++; 75 | ps++; 76 | } 77 | 78 | npFracNumber = 小数保留位数 - npFracNumber; 79 | if (npFracNumber > 0) 80 | { 81 | for (int npIndex = 0; npIndex < npFracNumber; npIndex++) 82 | *ps++ = '0'; 83 | *ps = '\0'; 84 | } 85 | } 86 | } 87 | 88 | if (是否进行千分位分隔) 89 | { 90 | wchar_t* psBegin = buf; 91 | if (*psBegin == '-') 92 | psBegin++; 93 | 94 | wchar_t* ps = psBegin; 95 | while (*ps != '\0') 96 | { 97 | const wchar_t ch = *ps++; 98 | if (ch != '.' && ((size_t)ch < (size_t)'0' || (size_t)ch >(size_t)'9')) 99 | break; 100 | } 101 | 102 | if (*ps == '\0') 103 | { 104 | wchar_t* psDot = wcschr(buf, '.'); 105 | if (psDot == NULL) 106 | ps = buf + wcslen(buf); 107 | else 108 | ps = psDot; 109 | 110 | while (1) 111 | { 112 | ps -= 3; 113 | if (ps <= psBegin) 114 | break; 115 | memmove((void*)(ps + 1), ps, (wcslen(ps) + 1) * sizeof(wchar_t)); 116 | *ps = ','; 117 | } 118 | } 119 | } 120 | 121 | return buf; 122 | } 123 | 124 | 125 | 126 | KrnlnApi string 数值到格式文本A(double 欲转换为文本的数值, int 小数保留位数, bool 是否进行千分位分隔) { 127 | 128 | char str[260] = { 0 }; 129 | char strFomar[260] = { 0 }; 130 | if (!欲转换为文本的数值) 131 | { 132 | strcpy(strFomar, "%lf"); 133 | 134 | } 135 | else 136 | { 137 | int nNum = 小数保留位数; 138 | if (nNum < 0) 139 | nNum = 0; 140 | if (nNum > 8) 141 | nNum = 8; 142 | sprintf_s(&strFomar[1], 259, ".%dlf", nNum); 143 | strFomar[0] = '%'; 144 | } 145 | 146 | sprintf_s(str, strFomar, 欲转换为文本的数值); 147 | 148 | if (是否进行千分位分隔) 149 | { 150 | strcpy_s(strFomar, str); 151 | char* pStr = strFomar; 152 | while (*pStr != 0 && *pStr != '.') 153 | pStr++; 154 | intptr_t nNum = pStr - strFomar; 155 | pStr = strFomar; 156 | if (strFomar[0] == '-') 157 | { 158 | nNum--; 159 | pStr++; 160 | } 161 | if (nNum > 3) 162 | { 163 | intptr_t nMax = nNum / 3; 164 | intptr_t nMod = nNum % 3; 165 | if (nMod) 166 | nMax++; 167 | intptr_t i = 0; 168 | char* pSrc = strFomar; 169 | char* pDest = str; 170 | 171 | while (i < nMax) 172 | { 173 | if (i == 0 && nMod) 174 | pStr += nMod; 175 | else 176 | pStr += 3; 177 | nNum = pStr - pSrc; 178 | 179 | if (i == nMax - 1) 180 | { 181 | strcat_s(pDest, sizeof(pSrc), pSrc); 182 | break; 183 | } 184 | strncpy_s(pDest, sizeof(pSrc), pSrc, nNum); 185 | pDest += nNum; 186 | *pDest = ','; 187 | pDest++; 188 | *pDest = 0; 189 | 190 | pSrc += nNum; 191 | pStr = pSrc; 192 | i++; 193 | 194 | } 195 | } 196 | } 197 | 198 | 199 | return str; 200 | 201 | } 202 | 203 | 204 | 205 | 206 | -------------------------------------------------------------------------------- /src/数值转换/数值到金额.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include"文本转换.h" 3 | using namespace std; 4 | 5 | 6 | #define NERAZERO(db) (db >= -1e-6 && db <= 1e-6) 7 | KrnlnApi wstring 数值到金额W(double 欲转换形式的数值, bool 是否转换为简体) 8 | { 9 | const wchar_t* szNumber; 10 | const wchar_t* szUnit; 11 | if (是否转换为简体) 12 | { 13 | szNumber = L"零一二三四五六七八九"; 14 | szUnit = L"十百千万十百千亿十百千万"; 15 | } 16 | else 17 | { 18 | szNumber = L"零壹贰叁肆伍陆柒捌玖"; 19 | szUnit = L"拾佰仟万拾佰仟亿拾佰仟万"; 20 | } 21 | 22 | wchar_t buf[128] = { 0 }; 23 | wchar_t* psBuf = buf; 24 | 25 | const bool blpNeg = (欲转换形式的数值 < 0); 26 | if (blpNeg) 27 | 欲转换形式的数值 = -欲转换形式的数值; 28 | 29 | if (NERAZERO(欲转换形式的数值)) 30 | { 31 | *psBuf = szNumber[0]; 32 | psBuf[1] = L'\0'; 33 | } 34 | else if (欲转换形式的数值 > 9999999999999.0) 35 | { 36 | wcscpy_s(psBuf, 3, L"溢出"); 37 | } 38 | else 39 | { 40 | psBuf = &buf[sizeof(buf) / sizeof(buf[0])]; 41 | *psBuf = L'\0'; 42 | 43 | 欲转换形式的数值 *= 100; 44 | if (modf(欲转换形式的数值 + 1e-6, &欲转换形式的数值) >= 0.5) 45 | 欲转换形式的数值++; 46 | long long n64 = (long long)欲转换形式的数值; 47 | 48 | if ((n64 % 10) == 0) 49 | { 50 | psBuf--; 51 | *psBuf = L'整'; 52 | } 53 | 54 | int npZeroType = 0; // 0:还没有任何数字; 1:最近一个是零; 2:最近一个是数字 55 | int npIndex = 0, npMod; 56 | bool blpHaveUnit = false, blpHaveYuan = false; 57 | 58 | while (n64 > 0) 59 | { 60 | npMod = n64 % 10; 61 | n64 /= 10; 62 | 63 | if (npIndex == 6 || npIndex == 10) 64 | blpHaveUnit = false; 65 | 66 | if (npMod == 0) 67 | { 68 | if (npZeroType == 2) 69 | { 70 | psBuf--; 71 | *psBuf = szNumber[0]; 72 | npZeroType = 1; 73 | } 74 | } 75 | else 76 | { 77 | npZeroType = 2; 78 | 79 | if (npIndex < 2) 80 | { 81 | psBuf--; 82 | *psBuf = (npIndex == 0 ? L'分' : L'角'); 83 | } 84 | else 85 | { 86 | if (blpHaveYuan == false) 87 | { 88 | psBuf--; 89 | *psBuf = L'元'; 90 | blpHaveYuan = true; 91 | } 92 | 93 | if (blpHaveUnit == false && npIndex >= 6) 94 | { 95 | if (npIndex < 10) 96 | { 97 | if (npIndex > 6) 98 | { 99 | psBuf--; 100 | *psBuf = szUnit[3]; 101 | } 102 | 103 | blpHaveUnit = true; 104 | } 105 | else 106 | { 107 | if (npIndex > 10) 108 | { 109 | psBuf--; 110 | *psBuf = szUnit[7]; 111 | } 112 | 113 | blpHaveUnit = true; 114 | } 115 | } 116 | 117 | if (npIndex > 2) 118 | { 119 | psBuf--; 120 | *psBuf = szUnit[npIndex - 3]; 121 | } 122 | } 123 | 124 | psBuf--; 125 | *psBuf = szNumber[npMod]; 126 | } 127 | 128 | npIndex++; 129 | } 130 | 131 | if (blpNeg) 132 | { 133 | psBuf--; 134 | *psBuf = L'负'; 135 | } 136 | } 137 | 138 | return psBuf; 139 | } 140 | 141 | 142 | 143 | 144 | KrnlnApi string 数值到金额A(double 欲转换形式的数值, bool 是否转换为简体) { 145 | 146 | return 宽文本到文本(数值到金额W(欲转换形式的数值, 是否转换为简体)); 147 | 148 | } 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | -------------------------------------------------------------------------------- /src/文本操作/倒找文本.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | #include 3 | using namespace std; 4 | 5 | 6 | string 到大写(const string& 欲变换的文本); 7 | 8 | wstring 到大写(const wstring& 欲变换的文本); 9 | /* 10 | 拷贝，因为中间会有一次到大写，还是需要拷贝一次，无所谓了。 11 | */ 12 | KrnlnApi intptr_t 倒找文本(wstring 被搜寻的文本, wstring 欲寻找的文本, intptr_t 起始搜寻位置, bool 是否不区分大小写) { 13 | size_t Ret = 0; 14 | 15 | if (是否不区分大小写) 16 | { 17 | 被搜寻的文本 = 到大写(被搜寻的文本); 18 | 欲寻找的文本 = 到大写(欲寻找的文本); 19 | } 20 | if (起始搜寻位置 == -1) 21 | { 22 | Ret = 被搜寻的文本.rfind(欲寻找的文本.c_str()); 23 | } 24 | else 25 | { 26 | Ret = 被搜寻的文本.rfind(欲寻找的文本.c_str(), 起始搜寻位置 - 2); 27 | } 28 | 29 | if (Ret == 被搜寻的文本.npos) 30 | { 31 | return -1; 32 | } 33 | 34 | return Ret + 1; 35 | 36 | 37 | } 38 | KrnlnApi intptr_t 倒找文本(string 被搜寻的文本, string 欲寻找的文本, intptr_t 起始搜寻位置, bool 是否不区分大小写) { 39 | size_t Ret = 0; 40 | if (是否不区分大小写) 41 | { 42 | 被搜寻的文本 = 到大写(被搜寻的文本); 43 | 欲寻找的文本 = 到大写(欲寻找的文本); 44 | } 45 | if (起始搜寻位置 == -1) 46 | { 47 | Ret = 被搜寻的文本.rfind(欲寻找的文本.c_str()); 48 | } 49 | else 50 | { 51 | Ret = 被搜寻的文本.rfind(欲寻找的文本.c_str(), 起始搜寻位置 - 2); 52 | } 53 | 54 | if (Ret == 被搜寻的文本.npos) 55 | { 56 | return -1; 57 | } 58 | return Ret + 1; 59 | 60 | } -------------------------------------------------------------------------------- /src/文本操作/分割文本.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | #include 3 | using namespace std; 4 | 5 | 6 | 7 | 8 | /* 9 | 将指定文本进行分割，返回分割后的一维文本数组 10 | 类型变量 <要返回的子文本数目> 如果被省略，则默认返回所有的子文本 11 | 12 | */ 13 | KrnlnApi std::vector 分割文本(const string& 待分割文本, const string& 用作分割的文本, size_t 要返回的子文本数目) { 14 | std::vector 返回文本; 15 | if (用作分割的文本.empty() || 待分割文本 == "") 16 | { 17 | 返回文本.push_back(待分割文本); 18 | return 返回文本; 19 | } 20 | size_t start = 0, index = 待分割文本.find_first_of(用作分割的文本, 0); 21 | while (index != 待分割文本.npos) 22 | { 23 | if (start != index) 24 | 返回文本.push_back(待分割文本.substr(start, index - start)); 25 | start = index + 1; 26 | index = 待分割文本.find_first_of(用作分割的文本, start); 27 | } 28 | if (待分割文本.substr(start) != "") 29 | { 30 | 返回文本.push_back(待分割文本.substr(start)); 31 | } 32 | if (要返回的子文本数目 != -1 && 要返回的子文本数目 <= 返回文本.size()) 33 | { 34 | 返回文本.resize(要返回的子文本数目); 35 | } 36 | return 返回文本; 37 | } 38 | 39 | KrnlnApi std::vector 分割文本(const wstring& 待分割文本, const wstring& 用作分割的文本, size_t 要返回的子文本数目) { 40 | std::vector 返回文本; 41 | if (用作分割的文本.empty() || 待分割文本 == L"") 42 | { 43 | 返回文本.push_back(待分割文本); 44 | return 返回文本; 45 | } 46 | size_t start = 0, index = 待分割文本.find_first_of(用作分割的文本, 0); 47 | while (index != 待分割文本.npos) 48 | { 49 | if (start != index) 50 | 返回文本.push_back(待分割文本.substr(start, index - start)); 51 | start = index + 1; 52 | index = 待分割文本.find_first_of(用作分割的文本, start); 53 | } 54 | if (待分割文本.substr(start) != L"") 55 | { 56 | 返回文本.push_back(待分割文本.substr(start)); 57 | } 58 | if (要返回的子文本数目 != -1 && 要返回的子文本数目 <= 返回文本.size()) 59 | { 60 | 返回文本.resize(要返回的子文本数目); 61 | } 62 | return 返回文本; 63 | } 64 | 65 | -------------------------------------------------------------------------------- /src/文本操作/删全部空.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | KrnlnApi wstring 删全部空(wstring 欲删除空格的文本) 5 | { 6 | wstring mark = L" "; 7 | size_t nSize = mark.size(); 8 | if (欲删除空格的文本.empty() || 欲删除空格的文本 == L"") { 9 | return L""; 10 | } 11 | while (1) 12 | { 13 | size_t pos = 欲删除空格的文本.find(mark); // 尤其是这里 14 | if (pos == wstring::npos) 15 | { 16 | return 欲删除空格的文本; 17 | } 18 | 19 | 欲删除空格的文本.erase(pos, nSize); 20 | } 21 | } 22 | KrnlnApi string 删全部空(string 欲删除空格的文本) 23 | { 24 | string mark = " "; 25 | size_t nSize = mark.size(); 26 | if (欲删除空格的文本.empty() || 欲删除空格的文本 == "") { 27 | return ""; 28 | } 29 | while (1) 30 | { 31 | size_t pos = 欲删除空格的文本.find(mark); // 尤其是这里 32 | if (pos == string::npos) 33 | { 34 | return 欲删除空格的文本; 35 | } 36 | 37 | 欲删除空格的文本.erase(pos, nSize); 38 | } 39 | } -------------------------------------------------------------------------------- /src/文本操作/删尾空.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | /* 5 | 返回一个文本，其中包含被删除了尾部全角或半角空格的指定文本 6 | 类型变量 <欲删除空格的文本> 7 | 8 | */ 9 | KrnlnApi string 删尾空(string 欲删除空格的文本) 10 | { 11 | if (欲删除空格的文本.empty()) 12 | { 13 | return 欲删除空格的文本; 14 | } 15 | 欲删除空格的文本.erase(欲删除空格的文本.find_last_not_of(" ") + 1); 16 | return 欲删除空格的文本; 17 | } 18 | KrnlnApi wstring 删尾空(wstring 欲删除空格的文本) 19 | { 20 | if (欲删除空格的文本.empty()) 21 | { 22 | return 欲删除空格的文本; 23 | } 24 | 欲删除空格的文本.erase(欲删除空格的文本.find_last_not_of(L" ") + 1); 25 | return 欲删除空格的文本; 26 | } 27 | -------------------------------------------------------------------------------- /src/文本操作/删首尾空.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | KrnlnApi string 删首尾空(string 欲删除空格的文本) 8 | { 9 | if (欲删除空格的文本.empty()) 10 | { 11 | return 欲删除空格的文本; 12 | } 13 | 14 | 欲删除空格的文本.erase(0, 欲删除空格的文本.find_first_not_of(" ")); 15 | 欲删除空格的文本.erase(欲删除空格的文本.find_last_not_of(" ") + 1); 16 | return 欲删除空格的文本; 17 | } 18 | 19 | KrnlnApi wstring 删首尾空(wstring 欲删除空格的文本) 20 | { 21 | if (欲删除空格的文本.empty()) 22 | { 23 | return 欲删除空格的文本; 24 | } 25 | 26 | 欲删除空格的文本.erase(0, 欲删除空格的文本.find_first_not_of(L" ")); 27 | 欲删除空格的文本.erase(欲删除空格的文本.find_last_not_of(L" ") + 1); 28 | return 欲删除空格的文本; 29 | } -------------------------------------------------------------------------------- /src/文本操作/删首空.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | /* 6 | 返回一个文本，其中包含被删除了首部全角或半角空格的指定文本 7 | 类型变量 <欲删除空格的文本> 8 | 9 | */ 10 | KrnlnApi wstring 删首空(wstring 欲删除空格的文本) 11 | { 12 | if (欲删除空格的文本.empty()) 13 | { 14 | return 欲删除空格的文本; 15 | } 16 | 欲删除空格的文本.erase(0, 欲删除空格的文本.find_first_not_of(L" ")); 17 | return 欲删除空格的文本; 18 | } 19 | KrnlnApi string 删首空(string 欲删除空格的文本) 20 | { 21 | if (欲删除空格的文本.empty()) 22 | { 23 | return 欲删除空格的文本; 24 | } 25 | 欲删除空格的文本.erase(0, 欲删除空格的文本.find_first_not_of(" ")); 26 | return 欲删除空格的文本; 27 | } 28 | -------------------------------------------------------------------------------- /src/文本操作/到全角.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | KrnlnApi string 到全角(const std::string& s) { 6 | string ret; 7 | if (!s.empty()) { 8 | for (size_t i = 0; i < s.size(); i++)//对于ansi处理，中文要判断前后字符，尽量不要使用迭代器。 9 | { 10 | if (s[i] == '~') { 11 | ret += "～"; 12 | } 13 | else if (std::isspace(s[i])) { 14 | ret += "　"; 15 | } 16 | else if (s[i] <= 0x20 || s[i] >= 0x7F) { 17 | if (s[i] & 0x80) { // 中文字符 18 | if (!s[i + 1]) { // 结束符截断 19 | ret += '\0'; 20 | return ret; 21 | } 22 | ret += s.substr(i, 2); 23 | i++; 24 | } 25 | else { // 常规字符 26 | ret += s[i]; 27 | } 28 | } 29 | else { 30 | ret += (char)163; // 中文两个字符中的高位 31 | ret += s[i] | (char)0x80; // 低位 32 | } 33 | } 34 | 35 | } 36 | return ret; 37 | } 38 | KrnlnApi std::wstring 到全角(const std::wstring& s) 39 | { 40 | std::wstring result; 41 | if (!s.empty()) { 42 | result.reserve(s.size());//宽字符win下2，linux3为固定，可以提前申请，防止每次拼接时申请内存,string不可以是因为汉字为两字符 43 | for (const auto& c : s) 44 | { 45 | if (c == ' ') 46 | { 47 | result += (wchar_t)0x3000; 48 | } 49 | else if (c >= 33 && c <= 126) 50 | { 51 | result += (wchar_t)(c + 65248); 52 | } 53 | else 54 | { 55 | result += c; 56 | } 57 | } 58 | } 59 | return result; 60 | } -------------------------------------------------------------------------------- /src/文本操作/到半角.cpp: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include 3 | using namespace std; 4 | /*是否需要??*/ 5 | //KrnlnApi bool 是否为全角字符(wchar_t c) 6 | //{ 7 | // return c >= 0xFF00 && c <= 0xFFEF; 8 | //} 9 | KrnlnApi string 到半角(const std::string& str) { 10 | std::string result; 11 | unsigned char fc; 12 | unsigned char lc; 13 | for (std::string::size_type i = 0; i < str.size(); i++) { 14 | fc = str[i]; 15 | lc = str[i + 1]; 16 | if (fc == 163) 17 | { 18 | result += (unsigned char)str[i + 1] - 128; 19 | i++; 20 | continue; 21 | } 22 | else if (fc > 163) //汉字 23 | { 24 | result += str.substr(i, 2); 25 | i++; 26 | continue; 27 | } 28 | else if (fc == 161 && lc == 161) ///处理全角空格 29 | { 30 | result += ""; 31 | i++; 32 | } 33 | else { 34 | result += str.substr(i, 1); 35 | } 36 | 37 | } 38 | return result; 39 | } 40 | 41 | KrnlnApi std::wstring 到半角(const std::wstring& text) 42 | { 43 | if (text.empty()) 44 | return std::wstring(); 45 | 46 | std::wstring result; 47 | result.reserve(text.size()); 48 | 49 | for (auto it = text.begin(); it != text.end(); ++it) 50 | { 51 | const size_t upChar = (size_t)*it; 52 | 53 | if (upChar == 0x3000) 54 | { 55 | result += L' '; 56 | } 57 | else if (upChar >= 65281 && upChar <= 65374) 58 | { 59 | result += (wchar_t)(upChar - 65248); 60 | } 61 | else 62 | { 63 | result += *it; 64 | } 65 | } 66 | 67 | return result; 68 | } 69 | 70 | -------------------------------------------------------------------------------- /src/文本操作/到大写.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | KrnlnApi string 到大写(const string& 欲变换的文本) { 5 | string 返回文本(欲变换的文本); 6 | std::transform(欲变换的文本.begin(), 欲变换的文本.end(), 返回文本.begin(), toupper); 7 | return 返回文本; 8 | } 9 | 10 | KrnlnApi wstring 到大写(const wstring& 欲变换的文本) { 11 | wstring 返回文本(欲变换的文本); 12 | transform(欲变换的文本.begin(), 欲变换的文本.end(), 返回文本.begin(), toupper); 13 | return 返回文本; 14 | } -------------------------------------------------------------------------------- /src/文本操作/到小写.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | #include 3 | using namespace std; 4 | KrnlnApi string 到小写(const string& 欲变换的文本) { 5 | string Ret(欲变换的文本); 6 | std::transform(欲变换的文本.begin(), 欲变换的文本.end(), Ret.begin(), tolower); 7 | return Ret; 8 | } 9 | KrnlnApi wstring 到小写(const wstring& 欲变换的文本) { 10 | wstring Ret(欲变换的文本); 11 | std::transform(欲变换的文本.begin(), 欲变换的文本.end(), Ret.begin(), tolower); 12 | return Ret; 13 | } -------------------------------------------------------------------------------- /src/文本操作/到文本.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include"文本转换.h" 7 | using namespace std; 8 | 9 | void formatDate(std::string& strValue, const std::tm& dt, bool bOnlyDatePart = false) 10 | { 11 | std::tm st = dt; 12 | 13 | std::stringstream strFormat; 14 | strFormat.imbue(std::locale("zh_CN.UTF-8")); 15 | strFormat << std::put_time(&st, "%Y年%m月%d日"); 16 | 17 | if (!bOnlyDatePart) { 18 | if (st.tm_sec) 19 | strFormat << std::put_time(&st, "%H时%M分%S秒"); 20 | else if (st.tm_min && st.tm_sec == 0) 21 | strFormat << std::put_time(&st, "%H时%M分"); 22 | else if (st.tm_hour && st.tm_min == 0 && st.tm_sec == 0) 23 | strFormat << std::put_time(&st, "%H时"); 24 | } 25 | 26 | strValue = strFormat.str(); 27 | } 28 | 29 | void formatDate(std::wstring& strValue, const std::tm& dt, bool bOnlyDatePart = false) 30 | { 31 | std::tm st = dt; 32 | std::wstringstream strFormat; 33 | strFormat << std::put_time(&st, L"%Y年%m月%d日"); 34 | if (!bOnlyDatePart) { 35 | if (st.tm_sec) 36 | strFormat << std::put_time(&st, L"%H时%M分%S秒"); 37 | else if (st.tm_min && st.tm_sec == 0) 38 | strFormat << std::put_time(&st, L"%H时%M分"); 39 | else if (st.tm_hour && st.tm_min == 0 && st.tm_sec == 0) 40 | strFormat << std::put_time(&st, L"%H时"); 41 | } 42 | strValue = strFormat.str(); 43 | } 44 | 45 | 46 | 47 | 48 | 49 | 50 | #pragma region A码处理部分 51 | //基础编码转换w2a 52 | KrnlnApi string to_string(const wstring& 待转换的数据) { 53 | if (待转换的数据.empty()) 54 | { 55 | return ""; 56 | } 57 | return 宽文本到文本(待转换的数据); 58 | } 59 | 60 | //char数组,末尾添加结束符后本质与string相同 61 | KrnlnApi string to_string(const vector & 待转换的数据) { 62 | if (待转换的数据.empty()) 63 | { 64 | return ""; 65 | } 66 | string ret(待转换的数据.data()); 67 | return ret; 68 | } 69 | 70 | //wchar数组,末尾添加结束符后本质与wstring相同到string用winApi转换即可 71 | KrnlnApi string to_string(const vector & 待转换的数据) { 72 | if (待转换的数据.empty()) 73 | { 74 | return ""; 75 | } 76 | wstring ret(待转换的数据.data()); 77 | return 宽文本到文本(ret); 78 | } 79 | 80 | //构造函数数组 81 | KrnlnApi string to_string(const char* 待转换的数据) { 82 | if (待转换的数据) 83 | { 84 | return string(); 85 | } 86 | return 待转换的数据; 87 | } 88 | 89 | //编码转换 90 | KrnlnApi string to_string(const wchar_t* 待转换的数据) { 91 | if (待转换的数据) 92 | { 93 | return 宽文本到文本(待转换的数据); 94 | } 95 | return string(); 96 | } 97 | 98 | 99 | 100 | 101 | //字节集 102 | KrnlnApi string to_string(const vector& 待转换的数据) { 103 | if (待转换的数据.size() == 0) { 104 | return ""; 105 | } 106 | string 返回文本; 107 | 返回文本.append((char*)待转换的数据.data(), 待转换的数据.size() / sizeof(char)); 108 | return 返回文本.c_str(); 109 | } 110 | KrnlnApi std::string to_string(const string& 待转换的数据) { 111 | return 待转换的数据; 112 | }; 113 | //std::tm 114 | KrnlnApi std::string to_string(const std::tm& dt) { 115 | std::string strValue; 116 | formatDate(strValue, dt); 117 | return strValue; 118 | } 119 | #pragma endregion A码处理部分 120 | 121 | 122 | #pragma region W码处理部分 123 | //基础编码转换A2W 124 | KrnlnApi wstring to_wstring(const string& 待转换的数据) { 125 | if (待转换的数据.empty()) 126 | { 127 | return L""; 128 | } 129 | return 文本到宽文本(待转换的数据); 130 | } 131 | KrnlnApi wstring to_wstring(const wstring& 待转换的数据) { 132 | 133 | return 待转换的数据; 134 | } 135 | //char数组,末尾添加结束符后本质与string相同 136 | KrnlnApi wstring to_wstring(const vector & 待转换的数据) { 137 | if (待转换的数据.empty()) 138 | { 139 | return L""; 140 | } 141 | string ret(待转换的数据.data()); 142 | return 文本到宽文本(ret); 143 | } 144 | 145 | //wchar数组,末尾添加结束符后本质与wstring相同到string用winApi转换即可 146 | KrnlnApi wstring to_wstring(const vector & 待转换的数据) { 147 | if (待转换的数据.empty()) 148 | { 149 | return L""; 150 | } 151 | wstring ret(待转换的数据.data()); 152 | return ret; 153 | } 154 | 155 | //构造函数数组 156 | KrnlnApi wstring to_wstring(const char* 待转换的数据) { 157 | if (!待转换的数据) 158 | { 159 | return wstring(); 160 | } 161 | 162 | return 文本到宽文本(待转换的数据); 163 | } 164 | 165 | //编码转换 166 | KrnlnApi wstring to_wstring(const wchar_t* 待转换的数据) { 167 | if (!待转换的数据) 168 | { 169 | return wstring(); 170 | } 171 | return 待转换的数据; 172 | } 173 | 174 | 175 | //字节集 176 | KrnlnApi wstring to_wstring(const vector& 待转换的数据) { 177 | if (待转换的数据.size() == 0) { 178 | return L""; 179 | } 180 | wstring 返回文本; 181 | 返回文本.append((wchar_t*)待转换的数据.data(), 待转换的数据.size() / sizeof(wchar_t)); 182 | return 返回文本.c_str(); 183 | } 184 | 185 | // 186 | KrnlnApi std::wstring to_wstring(const std::tm& dt) { 187 | std::wstring strValue; 188 | formatDate(strValue, dt); 189 | return strValue; 190 | } 191 | 192 | #pragma endregion W码处理部分 -------------------------------------------------------------------------------- /src/文本操作/取代码.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | 3 | 4 | 5 | 6 | /* 7 | 返回文本中指定位置处字符的代码。如果指定位置超出文本长度，返回0 8 | 类型变量 <欲取其代码的字符位置> 1为首位置，2为第2个位置，如此类推。如果本参数被省略，默认为首位置 9 | 10 | */ 11 | KrnlnApi int 取代码(const std::string& text, size_t idx) { 12 | if (text.empty()) { 13 | return 0; 14 | } 15 | if (idx < 1) { 16 | idx = 1; 17 | } 18 | if (idx > text.size()) { 19 | return 0; 20 | } 21 | return (int)text.at(idx - 1); 22 | } 23 | 24 | 25 | KrnlnApi short 取代码(const std::wstring& text, size_t idx) { 26 | if (text.empty()) { 27 | return 0; 28 | } 29 | if (idx < 1) { 30 | idx = 1; 31 | } 32 | if (idx > text.size()) { 33 | return 0; 34 | } 35 | return text.at(idx - 1); 36 | } 37 | -------------------------------------------------------------------------------- /src/文本操作/取文本中间.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | /* 8 | 返回一个文本，其中包含指定文本中从指定位置算起指定数量的字符 9 | 类型变量 <欲取出字符的数目> 10 | 11 | */ 12 | KrnlnApi string 取文本中间(const std::string& 欲取其部分的文本, size_t 起始取出位置, size_t 欲取出字符的数目) { 13 | return (欲取其部分的文本.substr(起始取出位置 - 1, 欲取出字符的数目)); 14 | } 15 | 16 | KrnlnApi wstring 取文本中间(const wstring& 欲取其部分的文本, size_t 起始取出位置, size_t 欲取出字符的数目) { 17 | return (欲取其部分的文本.substr(起始取出位置 - 1, 欲取出字符的数目)); 18 | } -------------------------------------------------------------------------------- /src/文本操作/取文本右边.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | /* 8 | 返回一个文本，其中包含指定文本中从右边算起指定数量的字符 9 | 类型变量 <欲取出字符的数目> 10 | 11 | */ 12 | KrnlnApi string 取文本右边(const std::string& 欲取其部分的文本, size_t 欲取出字符的数目) { 13 | 14 | if (欲取其部分的文本.empty()) { 15 | return ""; 16 | } 17 | if (欲取出字符的数目 >= 欲取其部分的文本.size()) { 18 | return 欲取其部分的文本; 19 | } 20 | return (欲取其部分的文本.substr(欲取其部分的文本.length() - 欲取出字符的数目)); 21 | 22 | } 23 | 24 | KrnlnApi wstring 取文本右边(const wstring& 欲取其部分的文本, size_t 欲取出字符的数目) { 25 | 26 | if (欲取其部分的文本.empty()) { 27 | return L""; 28 | } 29 | if (欲取出字符的数目 >= 欲取其部分的文本.size()) { 30 | return 欲取其部分的文本; 31 | } 32 | return (欲取其部分的文本.substr(欲取其部分的文本.length() - 欲取出字符的数目)); 33 | } 34 | -------------------------------------------------------------------------------- /src/文本操作/取文本左边.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | /* 8 | 返回一个文本，其中包含指定文本中从左边算起指定数量的字符 9 | 类型变量 <欲取出字符的数目> 10 | 11 | */ 12 | KrnlnApi string 取文本左边(const std::string& 欲取其部分的文本, size_t 欲取出字符的数目) { 13 | return (欲取其部分的文本.substr(0, 欲取出字符的数目)); 14 | } 15 | 16 | KrnlnApi wstring 取文本左边(const wstring& 欲取其部分的文本, size_t 欲取出字符的数目) { 17 | return (欲取其部分的文本.substr(0, 欲取出字符的数目)); 18 | } 19 | -------------------------------------------------------------------------------- /src/文本操作/取文本长度.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | /* 5 | 取文本型数据的长度，不包含结束0 6 | 类型变量 <文本数据> 参数值指定欲检查其长度的文本数据 7 | */ 8 | 9 | KrnlnApi size_t 取文本长度(const string& 文本数据) { 10 | return 文本数据.size(); 11 | } 12 | KrnlnApi size_t 取文本长度(const wstring& 文本数据) { 13 | return 文本数据.size(); 14 | } -------------------------------------------------------------------------------- /src/文本操作/取空白文本.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | /* 8 | 返回具有指定数目半角空格的文本 9 | 类型变量 <重复次数> 10 | 11 | */ 12 | KrnlnApi string 取空白文本A(size_t 重复次数) { 13 | size_t size = 重复次数; 14 | std::string blanks(size, ' '); 15 | return blanks; 16 | } 17 | 18 | KrnlnApi wstring 取空白文本W(size_t 重复次数) { 19 | size_t size = 重复次数; 20 | std::wstring blanks(size, L' '); 21 | return blanks; 22 | } -------------------------------------------------------------------------------- /src/文本操作/取统一拓展名.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | KrnlnApi string 取统一拓展名(const std::string& str) 5 | { 6 | string result(str); 7 | std::transform(str.begin(), str.end(), result.begin(), tolower); 8 | if (!result.empty()) 9 | { 10 | result = result.substr(result.rfind(".") + 1); 11 | } 12 | return result; 13 | } 14 | KrnlnApi wstring 取统一拓展名(const wstring& str) 15 | { 16 | wstring result(str); 17 | std::transform(str.begin(), str.end(), result.begin(), tolower); 18 | if (!result.empty()) 19 | { 20 | result = result.substr(result.rfind(L".") + 1); 21 | } 22 | return result; 23 | } -------------------------------------------------------------------------------- /src/文本操作/取重复文本.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | 8 | /* 9 | 返回一个文本，其中包含指定次数的文本重复结果 10 | 类型变量 <待重复文本> 该文本将用于建立返回的文本。如果为空，将返回一个空文本 11 | 12 | */ 13 | KrnlnApi string 取重复文本(size_t 重复次数, const std::string& 待重复文本) { 14 | 15 | size_t nLen = 待重复文本.size(); 16 | if (待重复文本.empty()) 17 | { 18 | return ""; 19 | } 20 | if (nLen == 0 || 重复次数 <= 0) { 21 | return ""; 22 | } 23 | size_t nBuf = nLen * 重复次数; 24 | string str; 25 | for (size_t i = 0; i < 重复次数; i++) 26 | { 27 | str.append(待重复文本); 28 | } 29 | 30 | return str; 31 | } 32 | 33 | 34 | KrnlnApi wstring 取重复文本(size_t 重复次数, const wstring& 待重复文本) { 35 | 36 | size_t nLen = 待重复文本.size(); 37 | if (待重复文本.empty()) 38 | { 39 | return L""; 40 | } 41 | if (nLen == 0 || 重复次数 <= 0) { 42 | return L""; 43 | } 44 | size_t nBuf = nLen * 重复次数; 45 | wstring str; 46 | for (size_t i = 0; i < 重复次数; i++) 47 | { 48 | str.append(待重复文本); 49 | } 50 | 51 | return str; 52 | } -------------------------------------------------------------------------------- /src/文本操作/字符.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | KrnlnApi string 字符A(char 欲取其字符的字符代码) { 8 | 9 | if (欲取其字符的字符代码 == 0) 10 | return ""; 11 | char a[2] = { 欲取其字符的字符代码 ,'\0' }; 12 | string Ret; 13 | Ret.append(a); 14 | return Ret; 15 | } 16 | 17 | KrnlnApi wstring 字符W(wchar_t code) { 18 | if (code == 0) 19 | return L""; 20 | return std::wstring(1, code); 21 | } -------------------------------------------------------------------------------- /src/文本操作/寻找文本.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | KrnlnApi intptr_t 寻找文本(const std::string& text, const std::string& search, size_t start_pos, bool ignore_case) 6 | { 7 | if (ignore_case) { 8 | std::string formatted_text = text; 9 | std::string formatted_search = search; 10 | std::transform(text.begin(), text.end(), formatted_text.begin(), std::toupper); 11 | std::transform(search.begin(), search.end(), formatted_search.begin(), std::toupper); 12 | intptr_t ret = formatted_text.find(formatted_search.c_str(), start_pos); 13 | if (ret != text.npos) { 14 | return ret + 1; 15 | } 16 | return -1; 17 | } 18 | else { 19 | intptr_t ret = text.find(search.c_str(), start_pos); 20 | if (ret != text.npos) { 21 | return ret + 1; 22 | } 23 | return -1; 24 | } 25 | } 26 | 27 | 28 | KrnlnApi intptr_t 寻找文本(const std::wstring& text, const std::wstring& search, size_t start_pos, bool ignore_case) 29 | { 30 | if (ignore_case) { 31 | std::wstring formatted_text = text; 32 | std::wstring formatted_search = search; 33 | std::transform(text.begin(), text.end(), formatted_text.begin(), std::toupper); 34 | std::transform(search.begin(), search.end(), formatted_search.begin(), std::toupper); 35 | intptr_t ret = formatted_text.find(formatted_search.c_str(), start_pos); 36 | if (ret != text.npos) { 37 | return ret + 1; 38 | } 39 | return -1; 40 | } 41 | else { 42 | intptr_t ret = text.find(search.c_str(), start_pos); 43 | if (ret != text.npos) { 44 | return ret + 1; 45 | } 46 | return -1; 47 | } 48 | } 49 | 50 | 51 | 52 | 53 | KrnlnApi intptr_t 寻找文本下标(const std::string& text, const std::string& search, size_t start_pos, bool ignore_case) 54 | { 55 | if (ignore_case) { 56 | std::string formatted_text = text; 57 | std::string formatted_search = search; 58 | std::transform(text.begin(), text.end(), formatted_text.begin(), std::toupper); 59 | std::transform(search.begin(), search.end(), formatted_search.begin(), std::toupper); 60 | intptr_t ret = formatted_text.find(formatted_search.c_str(), start_pos); 61 | if (ret != text.npos) { 62 | return ret; 63 | } 64 | return -1; 65 | } 66 | else { 67 | intptr_t ret = text.find(search.c_str(), start_pos); 68 | if (ret != text.npos) { 69 | return ret; 70 | } 71 | return -1; 72 | } 73 | } 74 | 75 | 76 | KrnlnApi intptr_t 寻找文本下标(const std::wstring& text, const std::wstring& search, size_t start_pos, bool ignore_case) 77 | { 78 | if (ignore_case) { 79 | std::wstring formatted_text = text; 80 | std::wstring formatted_search = search; 81 | std::transform(text.begin(), text.end(), formatted_text.begin(), std::toupper); 82 | std::transform(search.begin(), search.end(), formatted_search.begin(), std::toupper); 83 | intptr_t ret = formatted_text.find(formatted_search.c_str(), start_pos); 84 | if (ret != text.npos) { 85 | return ret; 86 | } 87 | return -1; 88 | } 89 | else { 90 | intptr_t ret = text.find(search.c_str(), start_pos); 91 | if (ret != text.npos) { 92 | return ret; 93 | } 94 | return -1; 95 | } 96 | } 97 | 98 | 99 | 100 | -------------------------------------------------------------------------------- /src/文本操作/指针到文本.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | /* 7 | 返回指定内存指针所指向地址处的文本，注意调用本命令前一定要确保所提供的内存指针真实有效，且指向一个以零字符结束的文本串。本命令的最佳使用场合就是在易语言回调子程序和易语言DLL公开子程序用作获取外部数据 8 | 类型变量 <内存文本指针> 本参数提供指向一个以零字符结束的文本串内存指针值 9 | 10 | */ 11 | KrnlnApi string 指针到文本A(void* 内存文本指针) { 12 | if (!内存文本指针 || strlen((char*)(内存文本指针)) == 0) 13 | { 14 | return ""; 15 | } 16 | return (char*)(内存文本指针); 17 | } 18 | 19 | KrnlnApi wstring 指针到文本W(void* 内存文本指针) { 20 | if (!内存文本指针 || wcslen((wchar_t*)(内存文本指针)) == 0) 21 | { 22 | return L""; 23 | } 24 | return (wchar_t*)(内存文本指针); 25 | } 26 | 27 | -------------------------------------------------------------------------------- /src/文本操作/文本替换.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | KrnlnApi string 文本替换(const string& 欲被替换的文本, size_t 起始替换位置, size_t 替换长度, const string& 用作替换的文本) { 5 | 6 | if (欲被替换的文本.empty()) { 7 | return ""; 8 | } 9 | if (替换长度 < 1) { 10 | return 欲被替换的文本; 11 | } 12 | size_t len_x = 欲被替换的文本.size(); 13 | if (起始替换位置 < 1) { 14 | 起始替换位置 = 1; 15 | } 16 | if (起始替换位置 > len_x) { 17 | return 欲被替换的文本; 18 | } 19 | string temp1 = 欲被替换的文本.substr(0, 起始替换位置 - 1); 20 | string temp2 = 欲被替换的文本.substr(欲被替换的文本.size() - (len_x - (起始替换位置 + 替换长度) + 1)); 21 | return temp1 + 用作替换的文本 + temp2; 22 | } 23 | 24 | KrnlnApi string 文本替换下标(const string& 欲被替换的文本, size_t 起始替换位置, size_t 替换长度, const string& 用作替换的文本) { 25 | 26 | if (欲被替换的文本.empty()) { 27 | return ""; 28 | } 29 | if (替换长度 < 1) { 30 | return 欲被替换的文本; 31 | } 32 | size_t len_x = 欲被替换的文本.size(); 33 | if (起始替换位置 < 0) { 34 | 起始替换位置 = 0; 35 | } 36 | if (起始替换位置 > len_x - 1) { 37 | return 欲被替换的文本; 38 | } 39 | string temp1 = 欲被替换的文本.substr(0, 起始替换位置); 40 | string temp2 = 欲被替换的文本.substr(欲被替换的文本.size() - (len_x - (起始替换位置 + 替换长度))); 41 | return temp1 + 用作替换的文本 + temp2; 42 | } 43 | KrnlnApi wstring 文本替换下标(const wstring& 欲被替换的文本, size_t 起始替换位置, size_t 替换长度, const wstring& 用作替换的文本) { 44 | 45 | if (欲被替换的文本.empty()) { 46 | return L""; 47 | } 48 | if (替换长度 < 1) { 49 | return 欲被替换的文本; 50 | } 51 | size_t len_x = 欲被替换的文本.size(); 52 | if (起始替换位置 < 0) { 53 | 起始替换位置 = 0; 54 | } 55 | if (起始替换位置 > len_x - 1) { 56 | return 欲被替换的文本; 57 | } 58 | wstring temp1 = 欲被替换的文本.substr(0, 起始替换位置); 59 | wstring temp2 = 欲被替换的文本.substr(欲被替换的文本.size() - (len_x - (起始替换位置 + 替换长度))); 60 | return temp1 + 用作替换的文本 + temp2; 61 | } 62 | KrnlnApi wstring 文本替换(const std::wstring& 欲被替换的文本, size_t 起始替换位置, size_t 替换长度, const std::wstring& 用作替换的文本) { 63 | 64 | if (欲被替换的文本.empty()) { 65 | return L""; 66 | } 67 | if (替换长度 < 1) { 68 | return 欲被替换的文本; 69 | } 70 | size_t len_x = 欲被替换的文本.size(); 71 | if (起始替换位置 < 1) { 72 | 起始替换位置 = 1; 73 | } 74 | if (起始替换位置 > len_x) { 75 | return 欲被替换的文本; 76 | } 77 | wstring temp1 = 欲被替换的文本.substr(0, 起始替换位置 - 1); 78 | wstring temp2 = 欲被替换的文本.substr(欲被替换的文本.size() - (len_x - (起始替换位置 + 替换长度) + 1)); 79 | return temp1 + 用作替换的文本 + temp2; 80 | } 81 | -------------------------------------------------------------------------------- /src/文本操作/文本比较.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | /* 8 | 如果返回值小于0，表示文本一小于文本二；如果等于0，表示文本一等于文本二；如果大于0，表示文本一大于文本二。如果比较时区分大小写，也可以使用比较运算符进行同样的操作 9 | 类型变量 <是否区分大小写> 为真区分大小写，为假不区分 10 | 11 | */ 12 | KrnlnApi int 文本比较(const string& 待比较文本一, const string& 待比较文本二, bool 是否区分大小写) { 13 | 14 | if (是否区分大小写) {//区分大小写 15 | return strcmp(待比较文本一.c_str(), 待比较文本二.c_str()); 16 | 17 | } 18 | return _stricmp(待比较文本一.c_str(), 待比较文本二.c_str()); 19 | } 20 | KrnlnApi int 文本比较(const wstring& 待比较文本一, const wstring& 待比较文本二, bool 是否区分大小写) { 21 | 22 | if (是否区分大小写) {//区分大小写 23 | return wcscmp(待比较文本一.c_str(), 待比较文本二.c_str()); 24 | } 25 | return _wcsicmp(待比较文本一.c_str(), 待比较文本二.c_str()); 26 | } -------------------------------------------------------------------------------- /src/文本操作/是否以文本开头.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | 4 | #pragma warning(disable:4996)//不加也行，看着烦得慌 5 | 6 | inline bool txet_isLeadOf(const char* szTest, const char* szLeadOf) 7 | { 8 | return (strncmp(szTest, szLeadOf, strlen(szLeadOf)) == 0); 9 | } 10 | inline bool txet_isLeadOf(const wchar_t* szTest, const wchar_t* szLeadOf) 11 | { 12 | return (wcsncmp(szTest, szLeadOf, wcslen(szLeadOf)) == 0); 13 | } 14 | 15 | 16 | inline bool txet_isnLeadOf(const char* szTest, const char* szLeadOf) 17 | { 18 | return (strnicmp(szTest, szLeadOf, strlen(szLeadOf)) == 0); 19 | } 20 | inline bool txet_isnLeadOf(const wchar_t* szTest, const wchar_t* szLeadOf) 21 | { 22 | return (wcsnicmp(szTest, szLeadOf, wcslen(szLeadOf)) == 0); 23 | } 24 | KrnlnApi bool 是否以文本开头(const string& 所欲操作的文本, const string& 搜索字符, bool 是否区分大小写) 25 | { 26 | if (!是否区分大小写) 27 | { 28 | return txet_isnLeadOf(所欲操作的文本.c_str(), 搜索字符.c_str()); 29 | } 30 | return txet_isLeadOf(所欲操作的文本.c_str(), 搜索字符.c_str()); 31 | } 32 | KrnlnApi bool 是否以文本开头(const wstring& 所欲操作的文本, const wstring& 搜索字符, bool 是否区分大小写) 33 | { 34 | if (!是否区分大小写) 35 | { 36 | return txet_isnLeadOf(所欲操作的文本.c_str(), 搜索字符.c_str()); 37 | } 38 | return txet_isLeadOf(所欲操作的文本.c_str(), 搜索字符.c_str()); 39 | } -------------------------------------------------------------------------------- /src/文本操作/是否以文本结尾.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | #include 3 | using namespace std; 4 | #pragma warning(disable:4996)//不加也行，看着烦得慌 5 | 6 | inline bool text_isend(const char* szTest, const char* szEndOf) 7 | { 8 | const size_t npTestStrLen = strlen(szTest); 9 | const size_t npEndStrLen = strlen(szEndOf); 10 | return (npEndStrLen == 0 || (npTestStrLen >= npEndStrLen && strcmp(szTest + npTestStrLen - npEndStrLen, szEndOf) == 0)); 11 | } 12 | 13 | inline bool text_isend(const wchar_t* szTest, const wchar_t* szEndOf) 14 | { 15 | const size_t npTestStrLen = wcslen(szTest); 16 | const size_t npEndStrLen = wcslen(szEndOf); 17 | return (npEndStrLen == 0 || (npTestStrLen >= npEndStrLen && wcscmp(szTest + npTestStrLen - npEndStrLen, szEndOf) == 0)); 18 | } 19 | inline bool text_isendn(const wchar_t* szTest, const wchar_t* szEndOf) 20 | { 21 | const size_t npTestStrLen = wcslen(szTest); 22 | const size_t npEndStrLen = wcslen(szEndOf); 23 | return (npEndStrLen == 0 || (npTestStrLen >= npEndStrLen && wcsicmp(szTest + npTestStrLen - npEndStrLen, szEndOf) == 0)); 24 | } 25 | inline bool text_isendn(const char* szTest, const char* szEndOf) 26 | { 27 | const size_t npTestStrLen = strlen(szTest); 28 | const size_t npEndStrLen = strlen(szEndOf); 29 | return (npEndStrLen == 0 || (npTestStrLen >= npEndStrLen && stricmp(szTest + npTestStrLen - npEndStrLen, szEndOf) == 0)); 30 | } 31 | 32 | KrnlnApi bool 是否以文本结尾(const wstring& 所欲操作的文本, const wstring& 搜索字符, bool 是否区分大小写) 33 | { 34 | if (!是否区分大小写) 35 | { 36 | return text_isendn(所欲操作的文本.c_str(), 搜索字符.c_str()); 37 | } 38 | return text_isend(所欲操作的文本.c_str(), 搜索字符.c_str()); 39 | } 40 | KrnlnApi bool 是否以文本结尾(const string& 所欲操作的文本, const string& 搜索字符, bool 是否区分大小写) 41 | { 42 | if (!是否区分大小写) 43 | { 44 | return text_isendn(所欲操作的文本.c_str(), 搜索字符.c_str()); 45 | } 46 | return text_isend(所欲操作的文本.c_str(), 搜索字符.c_str()); 47 | } -------------------------------------------------------------------------------- /src/时间操作/到时间.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | KrnlnApi std::tm 到时间(const std::string& s) { 6 | // 默认时间值 7 | std::tm default_time{}; 8 | default_time.tm_year = 100; 9 | default_time.tm_mon = 1; 10 | default_time.tm_mday = 1; 11 | 12 | // 如果参数本身就是时间数据，直接返回 13 | std::tm time{}; 14 | std::istringstream input(s); 15 | input >> std::get_time(&time, "%Y年%m月%d日%H时%M分%S秒"); 16 | if (!input.fail()) { 17 | return time; 18 | } 19 | input.clear(); 20 | input.str(s); 21 | input >> std::get_time(&time, "%Y/%m/%d %H:%M:%S"); 22 | if (!input.fail()) { 23 | return time; 24 | } 25 | input.clear(); 26 | input.str(s); 27 | input >> std::get_time(&time, "%Y/%m/%d/%H/%M/%S"); 28 | if (!input.fail()) { 29 | return time; 30 | } 31 | input.clear(); 32 | input.str(s); 33 | input >> std::get_time(&time, "%Y/%m/%d/%H:%M:%S"); 34 | if (!input.fail()) { 35 | return time; 36 | } 37 | input.clear(); 38 | input.str(s); 39 | input >> std::get_time(&time, "%Y-%m-%d-%H-%M-%S"); 40 | if (!input.fail()) { 41 | return time; 42 | } 43 | input.clear(); 44 | input.str(s); 45 | input >> std::get_time(&time, "%Y-%m-%d-%H:%M:%S"); 46 | if (!input.fail()) { 47 | return time; 48 | } 49 | input.clear(); 50 | input.str(s); 51 | input >> std::get_time(&time, "%Y.%m.%d %H:%M:%S"); 52 | if (!input.fail()) { 53 | return time; 54 | } 55 | input.clear(); 56 | input.str(s); 57 | input >> std::get_time(&time, "%Y%m%d%H%M%S"); 58 | if (!input.fail()) { 59 | return time; 60 | } 61 | 62 | // 如果文本不符合格式要求或者时间值错误，返回默认时间值 63 | return default_time; 64 | } 65 | KrnlnApi std::tm 到时间(const std::wstring& s) { 66 | // 默认时间值 67 | std::tm default_time{}; 68 | default_time.tm_year = 100; 69 | default_time.tm_mon = 1; 70 | default_time.tm_mday = 1; 71 | 72 | // 如果参数本身就是时间数据，直接返回 73 | std::tm time{}; 74 | std::wistringstream input(s); 75 | input >> std::get_time(&time, L"%Y年%m月%d日%H时%M分%S秒"); 76 | if (!input.fail()) { 77 | return time; 78 | } 79 | 80 | input.clear(); 81 | input.str(s); 82 | input >> std::get_time(&time, L"%Y/%m/%d %H:%M:%S"); 83 | if (!input.fail()) { 84 | return time; 85 | } 86 | input.clear(); 87 | input.str(s); 88 | input >> std::get_time(&time, L"%Y/%m/%d/%H/%M/%S"); 89 | if (!input.fail()) { 90 | return time; 91 | } 92 | 93 | input.clear(); 94 | input.str(s); 95 | input >> std::get_time(&time, L"%Y/%m/%d/%H:%M:%S"); 96 | if (!input.fail()) { 97 | return time; 98 | } 99 | input.clear(); 100 | input.str(s); 101 | input >> std::get_time(&time, L"%Y-%m-%d-%H-%M-%S"); 102 | if (!input.fail()) { 103 | return time; 104 | } 105 | input.clear(); 106 | input.str(s); 107 | input >> std::get_time(&time, L"%Y-%m-%d-%H:%M:%S"); 108 | if (!input.fail()) { 109 | return time; 110 | } 111 | 112 | input.clear(); 113 | input.str(s); 114 | input >> std::get_time(&time, L"%Y.%m.%d %H:%M:%S"); 115 | if (!input.fail()) { 116 | return time; 117 | } 118 | 119 | input.clear(); 120 | input.str(s); 121 | input >> std::get_time(&time, L"%Y%m%d%H%M%S"); 122 | if (!input.fail()) { 123 | return time; 124 | } 125 | input.clear(); 126 | input.str(s); 127 | 128 | input >> std::get_time(&time, L"%Y%m%d%H%M%S"); 129 | if (!input.fail()) { 130 | return time; 131 | } 132 | // 如果文本不符合格式要求或者时间值错误，返回默认时间值 133 | return default_time; 134 | } 135 | 136 | 137 | -------------------------------------------------------------------------------- /src/时间操作/取分钟.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | KrnlnApi int 取分钟(const std::tm& 时间) { 3 | return 时间.tm_min; 4 | } -------------------------------------------------------------------------------- /src/时间操作/取小时.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | KrnlnApi int 取小时(const std::tm& 时间) { 5 | // 使用 std::tm 结构体中的 tm_hour 字段来获取小时 6 | return 时间.tm_hour; 7 | } 8 | -------------------------------------------------------------------------------- /src/时间操作/取年份.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | KrnlnApi int 取年份(const std::tm& 时间) { 6 | return 时间.tm_year + 1900; 7 | } -------------------------------------------------------------------------------- /src/时间操作/取日.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | KrnlnApi int 取日(const std::tm& 时间) { 3 | return 时间.tm_mday; 4 | } -------------------------------------------------------------------------------- /src/时间操作/取日期.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | KrnlnApi std::tm 取日期(std::tm 时间) { 4 | 时间.tm_hour = 0; 5 | 时间.tm_min = 0; 6 | 时间.tm_sec = 0; 7 | return 时间; 8 | } -------------------------------------------------------------------------------- /src/时间操作/取时间.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | KrnlnApi std::tm 取时间(std::tm 时间) { 4 | 时间.tm_year = 100; 5 | 时间.tm_mon = 0; 6 | 时间.tm_mday = 1; 7 | return 时间; 8 | } 9 | -------------------------------------------------------------------------------- /src/时间操作/取时间部分.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | KrnlnApi int 取时间部分(const std::tm& 欲取其部分的时间, int 欲取的时间部分) { 4 | int ret = 0; 5 | switch (欲取的时间部分) { 6 | case 1: // 年份 7 | ret = 欲取其部分的时间.tm_year + 1900; // tm_year 存储的是年份减去 1900 的值 8 | break; 9 | case 2: // 季度 10 | ret = (欲取其部分的时间.tm_mon + 1) / 3; // tm_mon 存储的是月份减去 1 的值 11 | break; 12 | case 3: // 月份 13 | ret = 欲取其部分的时间.tm_mon + 1; // tm_mon 存储的是月份减去 1 的值 14 | break; 15 | case 4: // 自年首周数 16 | ret = 欲取其部分的时间.tm_yday / 7 + 1; // tm_yday 存储的是当前日期是从一年开始的第几天 17 | break; 18 | case 5: // 日 19 | ret = 欲取其部分的时间.tm_mday; 20 | break; 21 | case 6: // 小时 22 | ret = 欲取其部分的时间.tm_hour; 23 | break; 24 | case 7: // 分钟 25 | ret = 欲取其部分的时间.tm_min; 26 | break; 27 | case 8: // 秒 28 | ret = 欲取其部分的时间.tm_sec; 29 | break; 30 | case 9: // 星期几 31 | ret = 欲取其部分的时间.tm_wday + 1; // tm_wday 存储的是星期几减去 1 的值 32 | break; 33 | case 10: // 自年首天数 34 | ret = 欲取其部分的时间.tm_yday + 1; // tm_yday 存储的是当前日期是从一年开始的第几天 35 | break; 36 | } 37 | return ret; 38 | } -------------------------------------------------------------------------------- /src/时间操作/取时间间隔.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include 3 | #include 4 | #include 5 | 6 | // 计算两个时间之间的秒数 7 | double secondsBetween(const std::tm& time1, const std::tm& time2) { 8 | double seconds = std::difftime(std::mktime(const_cast(&time1)), std::mktime(const_cast(&time2))); 9 | return seconds < 0 ? -seconds : seconds; 10 | } 11 | 12 | // 计算两个时间之间的年份 13 | int yearsBetween(const std::tm& time1, const std::tm& time2) { 14 | // 检查日期是否合法 15 | if (time1.tm_mon < 1 || time1.tm_mon > 12 || 16 | time1.tm_mday < 1 || time1.tm_mday > 31 || 17 | time2.tm_mon < 1 || time2.tm_mon > 12 || 18 | time2.tm_mday < 1 || time2.tm_mday > 31) { 19 | return 0; // 返回0 20 | } 21 | const int START_YEAR = 1900; 22 | int ygap = 0; 23 | if (time1.tm_year > time2.tm_year) { 24 | // 计算 time1 到 time2 的年数差 25 | ygap = time1.tm_year - time2.tm_year; 26 | 27 | // 计算 time1 到 time2 的天数差 28 | int days1 = 0; 29 | for (int i = time2.tm_year; i < time1.tm_year; i++) { 30 | if (i % 4 == 0 && (i % 100 != 0 || i % 400 == 0)) { 31 | // 闰年 32 | days1 += 366; 33 | } 34 | else { 35 | // 平年 36 | days1 += 365; 37 | } 38 | } 39 | days1 += time1.tm_yday - time2.tm_yday; 40 | 41 | // 如果天数差小于一年，则减少一年 42 | if (days1 < 365) { 43 | ygap--; 44 | } 45 | } 46 | else if (time1.tm_year < time2.tm_year) { 47 | // 计算 time2 到 time1 的年数差 48 | ygap = time2.tm_year - time1.tm_year; 49 | 50 | // 计算 time2 到 time1 的天数差 51 | int days2 = 0; 52 | for (int i = time1.tm_year; i < time2.tm_year; i++) { 53 | if (i % 4 == 0 && (i % 100 != 0 || i % 400 == 0)) { 54 | // 闰年 55 | days2 += 366; 56 | } 57 | else { 58 | // 平年 59 | days2 += 365; 60 | } 61 | } 62 | days2 += time2.tm_yday - time1.tm_yday; 63 | // 如果天数差小于一年，则减少一年 64 | if (days2 < 365) { 65 | ygap--; 66 | } 67 | } 68 | 69 | return ygap; 70 | } 71 | 72 | // 计算两个时间之间的季度 73 | double quartersBetween(const std::tm& time1, const std::tm& time2) { 74 | int gap = 12 * (time1.tm_year - time2.tm_year) + time1.tm_mon - time2.tm_mon; 75 | gap = gap < 0 ? -gap : gap; 76 | return std::ceil(gap / 3.0); 77 | } 78 | 79 | // 计算两个时间之间的月份 80 | int monthsBetween(const std::tm& time1, const std::tm& time2) { 81 | int gap = 12 * (time1.tm_year - time2.tm_year) + time1.tm_mon - time2.tm_mon; 82 | if (gap < 0) { 83 | gap *= -1; // 将秒数取为正数 84 | } 85 | // 判断时间差距是否足一个月份 86 | if (time1.tm_mday < time2.tm_mday) { 87 | gap--; 88 | } 89 | return gap; 90 | } 91 | 92 | // 计算两个时间之间的周数 93 | double weeksBetween(const std::tm& time1, const std::tm& time2) { 94 | double seconds = secondsBetween(time1, time2); 95 | return std::floor(seconds / (604800.0)); 96 | } 97 | 98 | // 计算两个时间之间的天数 99 | double daysBetween(const std::tm& time1, const std::tm& time2) { 100 | double seconds = secondsBetween(time1, time2); 101 | return std::floor(seconds / 86400.0); 102 | } 103 | 104 | // 计算两个时间之间的小时数 105 | double hoursBetween(const std::tm& time1, const std::tm& time2) { 106 | double seconds = secondsBetween(time1, time2); 107 | return std::floor(seconds / 3600.0); 108 | } 109 | 110 | // 计算两个时间之间的分钟数 111 | double minutesBetween(const std::tm& time1, const std::tm& time2) { 112 | double seconds = secondsBetween(time1, time2); 113 | return std::floor(seconds / 60.0); 114 | } 115 | 116 | 117 | // 计算两个时间之间的间隔 118 | KrnlnApi double 取时间间隔(const std::tm& time1, const std::tm& time2, int interval) { 119 | switch (interval) { 120 | case 1: return yearsBetween(time1, time2); 121 | case 2: return quartersBetween(time1, time2); 122 | case 3: return monthsBetween(time1, time2); 123 | case 4: return weeksBetween(time1, time2); 124 | case 5: return daysBetween(time1, time2); 125 | case 6: return hoursBetween(time1, time2); 126 | case 7: return minutesBetween(time1, time2); 127 | default: return secondsBetween(time1, time2);//其余情况默认返回秒数 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /src/时间操作/取星期几.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | KrnlnApi int 取星期几(const std::tm& 时间) { 5 | return 时间.tm_wday + 1; 6 | } -------------------------------------------------------------------------------- /src/时间操作/取月份.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | 6 | /* 7 | 返回一个值为 1 到 12 之间的整数，表示指定时间中的月份 8 | 类型变量 <时间> 9 | 10 | */ 11 | KrnlnApi int 取月份(const std::tm& 时间) { 12 | // 使用 std::tm 结构体中的 tm_mon 字段来获取月份 13 | return 时间.tm_mon + 1; 14 | } -------------------------------------------------------------------------------- /src/时间操作/取某月天数.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | KrnlnApi int 取某月天数(int 年份, int 月份) { 5 | std::tm time_in = { 0 }; 6 | time_in.tm_year = 年份 - 1900; 7 | time_in.tm_mon = 月份 - 1; 8 | // 使用 mktime 计算日期是否有效，从而确定月份的天数 9 | if (std::mktime(&time_in) == -1) { 10 | return 0; 11 | } 12 | return time_in.tm_mday; 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /src/时间操作/取现行时间.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | KrnlnApi std::tm 取现行时间() { 6 | // 获取当前时间 7 | auto now = std::chrono::system_clock::now(); 8 | // 将时间转换为本地时间，并舍入到最接近的秒 9 | auto localTime = std::chrono::floor(now); 10 | // 将时间点转换为 time_t 对象 11 | auto time = std::chrono::system_clock::to_time_t(localTime); 12 | // 将 time_t 对象转换为 std::tm 对象 13 | std::tm tm; 14 | localtime_s(&tm, &time); 15 | return tm; 16 | } 17 | -------------------------------------------------------------------------------- /src/时间操作/取秒.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | KrnlnApi int 取秒(const std::tm& 时间) { 3 | return 时间.tm_sec; 4 | } -------------------------------------------------------------------------------- /src/时间操作/增减时间.cpp: -------------------------------------------------------------------------------- 1 | //宏定义仅仅是方便维护，编译器不支持utf8或unicode可以去掉 2 | #define 年份 1 3 | #define 季度 2 4 | #define 月份 3 5 | #define 周 4 6 | #define 日 5 7 | #define 小时 6 8 | #define 分钟 7 9 | #define 秒 8 10 | #include 11 | int GetDaysOfSpecMonth(int year, int month) 12 | { 13 | //定义一个数组，包含每个月的天数 14 | const int daysPerMonth[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 15 | 16 | // 如果是闰年，二月份的天数为 29 天 17 | if (((year % 400 == 0) || (year % 100 != 0) && (year % 4 == 0)) && month == 2) 18 | { 19 | return 29; 20 | } 21 | 22 | // 返回月份的天数 23 | return daysPerMonth[month - 1]; 24 | } 25 | KrnlnApi std::tm 增减时间(const std::tm& 时间, int 被增加部分, int 增加值) 26 | { 27 | std::tm newTime = 时间; 28 | switch (被增加部分) 29 | { 30 | case 年份: // 年份 31 | { 32 | newTime.tm_year += 增加值; 33 | if (newTime.tm_mon == 2 && newTime.tm_mday == 29) 34 | newTime.tm_mday = GetDaysOfSpecMonth(newTime.tm_year, 2); 35 | break; 36 | } 37 | case 季度: // 季度 38 | { 39 | int nMonth = newTime.tm_mon + (增加值 * 3); 40 | if (nMonth > 0) 41 | { 42 | newTime.tm_year += (nMonth / 12); 43 | nMonth %= 12; 44 | } 45 | else 46 | { 47 | int decYear = nMonth / 12; 48 | if (nMonth % 12 != 0) 49 | decYear--; 50 | newTime.tm_year += decYear; 51 | nMonth = 12 + (nMonth % 12); 52 | } 53 | newTime.tm_mon = nMonth; 54 | 55 | int nMaxDay = GetDaysOfSpecMonth(newTime.tm_year, nMonth); 56 | if (newTime.tm_mday > nMaxDay) 57 | newTime.tm_mday = nMaxDay; 58 | break; 59 | } 60 | case 月份: // 月份 61 | { 62 | int nMonth = newTime.tm_mon + 增加值; 63 | if (nMonth > 0) 64 | { 65 | newTime.tm_year += (nMonth / 12); 66 | nMonth %= 12; 67 | } 68 | else 69 | { 70 | int decYear = nMonth / 12; 71 | if (nMonth % 12 != 0) 72 | decYear--; 73 | newTime.tm_year += decYear; 74 | nMonth = 12 + (nMonth % 12); 75 | } 76 | newTime.tm_mon = nMonth; 77 | int nMaxDay = GetDaysOfSpecMonth(newTime.tm_year, nMonth); 78 | if (newTime.tm_mday > nMaxDay) 79 | newTime.tm_mday = nMaxDay; 80 | break; 81 | } 82 | case 周: // 周 83 | { 84 | int nDay = newTime.tm_mday + (增加值 * 7); 85 | int nMaxDay = GetDaysOfSpecMonth(newTime.tm_year, newTime.tm_mon); 86 | if (nDay > nMaxDay) 87 | { 88 | nDay -= nMaxDay; 89 | newTime = 增减时间(newTime, 月份, 1); 90 | } 91 | newTime.tm_mday = nDay; 92 | break; 93 | } 94 | case 日: // 日 95 | { 96 | newTime.tm_mday += 增加值; 97 | int nMaxDay = GetDaysOfSpecMonth(newTime.tm_year, newTime.tm_mon); 98 | if (newTime.tm_mday > nMaxDay) 99 | { 100 | newTime.tm_mday -= nMaxDay; 101 | newTime = 增减时间(newTime, 月份, 1); 102 | } 103 | break; 104 | } 105 | case 小时: // 小时 106 | { 107 | newTime.tm_hour += 增加值; 108 | if (newTime.tm_hour >= 24) 109 | { 110 | newTime.tm_hour -= 24; 111 | newTime = 增减时间(newTime, 日, 1); 112 | } 113 | break; 114 | } 115 | case 分钟: // 分钟 116 | { 117 | newTime.tm_min += 增加值; 118 | if (newTime.tm_min >= 60) 119 | { 120 | newTime.tm_min -= 60; 121 | newTime = 增减时间(newTime, 小时, 1); 122 | } 123 | break; 124 | } 125 | default://其他情况都为秒 126 | newTime.tm_sec += 增加值; 127 | if (newTime.tm_sec >= 60) 128 | { 129 | newTime.tm_sec -= 60; 130 | newTime = 增减时间(newTime, 分钟, 1); 131 | } 132 | break; 133 | } 134 | return newTime; 135 | } 136 | 137 | 138 | -------------------------------------------------------------------------------- /src/时间操作/指定时间.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include 3 | #include 4 | KrnlnApi std::tm 指定时间(int year, int month, int day, int hour, int minute, int second) 5 | { 6 | // Set the year 7 | year = std::clamp(year, 100, 9999); 8 | // 设置月份 9 | month = std::clamp(month, 1, 12); 10 | 11 | // 计算当前月份的天数 12 | int max_day = 0; 13 | if (month == 2) 14 | { 15 | // 二月 16 | bool is_leap_year = (year % 400 == 0) || (year % 100 != 0 && year % 4 == 0); 17 | max_day = is_leap_year ? 29 : 28; 18 | } 19 | else if (month == 4 || month == 6 || month == 9 || month == 11) 20 | { 21 | // 四月、六月、九月、十一月 22 | max_day = 30; 23 | } 24 | else 25 | { 26 | // 其他月份都是31天 27 | max_day = 31; 28 | } 29 | 30 | // 设置日期 31 | day = std::clamp(day, 1, max_day); 32 | 33 | // 设置小时 34 | hour = std::clamp(hour, 0, 23); 35 | 36 | // 设置分钟 37 | minute = std::clamp(minute, 0, 59); 38 | 39 | // 设置秒钟 40 | second = std::clamp(second, 0, 59); 41 | 42 | // 创建std::tm对象 43 | std::tm time; 44 | time.tm_year = year - 1900; 45 | time.tm_mon = month - 1; 46 | time.tm_mday = day; 47 | time.tm_hour = hour; 48 | time.tm_min = minute; 49 | time.tm_sec = second; 50 | 51 | return time; 52 | } -------------------------------------------------------------------------------- /src/时间操作/时间到文本.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include 3 | #include 4 | #include 5 | #include 6 | KrnlnApi std::wstring 时间到文本W(const std::tm& 欲转换到文本的时间, int 转换部分, bool 是否中文) 7 | { 8 | std::wstringstream ss; 9 | if (转换部分 == 1) { // 转换日期部分 10 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? L"%Y年%m月%d日" : L"%m/%d/%Y"); 11 | } 12 | else if (转换部分 == 2) { // 转换时间部分 13 | if (转换部分 == 0) { 14 | ss << (是否中文 ? L" " : L" "); 15 | } 16 | if (欲转换到文本的时间.tm_sec != 0) { 17 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? L"%H时%M分%S秒" : L"%I:%M:%S %p"); 18 | } 19 | else if (欲转换到文本的时间.tm_min != 0) { 20 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? L"%H时%M分" : L"%I:%M %p"); 21 | } 22 | else if (欲转换到文本的时间.tm_hour != 0) { 23 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? L"%H时" : L"%I %p"); 24 | } 25 | } 26 | else {//全部转换 27 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? L"%Y年%m月%d日 %H时%M分%S秒" : L"%m/%d/%Y %I:%M:%S %p"); 28 | } 29 | return ss.str(); 30 | } 31 | 32 | 33 | KrnlnApi std::string 时间到文本A(const std::tm& 欲转换到文本的时间, int 转换部分, bool 是否中文) 34 | { 35 | std::stringstream ss; 36 | ss.imbue(std::locale("zh_CN.UTF-8")); 37 | if (转换部分 == 1) { // Convert date part 38 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? "%Y年%m月%d日" : "%m/%d/%Y"); 39 | } 40 | else if (转换部分 == 2) { // Convert time part 41 | if (转换部分 == 0) { 42 | ss << (是否中文 ? " " : " "); 43 | } 44 | if (欲转换到文本的时间.tm_sec != 0) { 45 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? "%H时%M分%S秒" : "%I:%M:%S %p"); 46 | } 47 | else if (欲转换到文本的时间.tm_min != 0) { 48 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? "%H时%M分" : "%I:%M %p"); 49 | } 50 | else if (欲转换到文本的时间.tm_hour != 0) { 51 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? "%H时" : "%I %p"); 52 | } 53 | } 54 | else {// Convert all 55 | ss << std::put_time(&欲转换到文本的时间, 是否中文 ? "%Y年%m月%d日 %H时%M分%S秒" : "%m/%d/%Y %I:%M:%S %p"); 56 | } 57 | ss.imbue(std::locale("zh_CN.UTF-8")); 58 | return ss.str(); 59 | } -------------------------------------------------------------------------------- /src/时间操作/置现行时间.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #ifdef _WIN32 5 | #include 6 | #else 7 | #include 8 | #endif // _WIN32 9 | 10 | 11 | 12 | KrnlnApi bool 置现行时间(const std::tm& tm) 13 | { 14 | 15 | #ifdef _WIN32 16 | SYSTEMTIME now = { 0 }; 17 | now.wYear = tm.tm_year + 1900; 18 | now.wMonth = tm.tm_mon + 1; 19 | now.wDay = tm.tm_mday; 20 | now.wHour = tm.tm_hour; 21 | now.wMinute = tm.tm_min; 22 | now.wSecond = tm.tm_sec; 23 | now.wMilliseconds = 0; 24 | return SetLocalTime(&now); 25 | #else 26 | std::time_t time = std::mktime(const_cast(&tm)); 27 | 28 | if (time == -1) { 29 | // mktime failed 30 | return false; 31 | } 32 | std::time_t result = stime(&time); 33 | if (result == -1) { 34 | // stime failed 35 | return false; 36 | } 37 | 38 | return true; 39 | #endif // _WIN32 40 | 41 | } 42 | -------------------------------------------------------------------------------- /src/环境存取/写环境变量.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | 3 | 4 | 5 | #ifdef _WIN32 6 | #include 7 | using namespace std; 8 | KrnlnApi bool 写环境变量(const string& 环境变量名称, const string& 欲写入内容) 9 | { 10 | return SetEnvironmentVariableA(环境变量名称.c_str(), 欲写入内容.c_str()) == TRUE; 11 | } 12 | 13 | KrnlnApi bool 写环境变量(const wstring& 环境变量名称, const wstring& 欲写入内容) 14 | { 15 | return SetEnvironmentVariableW(环境变量名称.c_str(), 欲写入内容.c_str()) == TRUE; 16 | } 17 | #else 18 | /*linux*/ 19 | KrnlnApi bool 写环境变量(string 环境变量名称, string 欲写入内容) 20 | { 21 | return _putenv_s(环境变量名称.c_str(), 欲写入内容.c_str()) == 0; 22 | } 23 | KrnlnApi bool 写环境变量W(wstring 环境变量名称, wstring 欲写入内容) 24 | { 25 | return _wputenv_s(环境变量名称.c_str(), 欲写入内容.c_str()) == 0; 26 | } 27 | #endif 28 | 29 | 30 | -------------------------------------------------------------------------------- /src/环境存取/取完整目录.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include 3 | #include 4 | 5 | 6 | using namespace std; 7 | inline int MyStrcmp(const wchar_t* szSource, const wchar_t* szDest) 8 | { 9 | if (szSource == NULL) szSource = L""; 10 | if (szDest == NULL) szDest = L""; 11 | 12 | int nResult = 0; 13 | while (!(nResult = (int)(*szSource - *szDest)) && *szDest) 14 | { 15 | szSource++; 16 | szDest++; 17 | } 18 | 19 | return nResult; 20 | } 21 | inline int MyStrcmp(const char* szSource, const char* szDest) 22 | { 23 | if (szSource == NULL) szSource = ""; 24 | if (szDest == NULL) szDest = ""; 25 | 26 | int nResult = 0; 27 | while (!(nResult = (int)(*szSource - *szDest)) && *szDest) 28 | { 29 | szSource++; 30 | szDest++; 31 | } 32 | 33 | return nResult; 34 | } 35 | KrnlnApi wstring 合并路径(const wstring& 文件名, const wstring& 目录) 36 | { 37 | // 取当前目录 38 | wstring strCurrentDir; 39 | if (目录.empty()) 40 | { 41 | strCurrentDir = std::filesystem::current_path().wstring(); 42 | } 43 | else 44 | { 45 | strCurrentDir = 目录; 46 | } 47 | 48 | // 按'/'或'\\'分割 49 | vector tokens; 50 | 51 | wstring strPath = strCurrentDir; 52 | strPath += L"/"; 53 | strPath += 文件名; 54 | const wchar_t* szPrevToken = strPath.c_str(); 55 | for (const wchar_t* p = szPrevToken; *p; ++p) 56 | { 57 | if (*p == L'\\' || *p == L'/') 58 | { 59 | tokens.push_back(wstring(szPrevToken, p - szPrevToken)); 60 | szPrevToken = p + 1; 61 | } 62 | } 63 | if (*szPrevToken) 64 | { 65 | tokens.push_back(szPrevToken); 66 | } 67 | 68 | // 处理 "." 和 ".." 69 | vector tempArray; 70 | for (size_t n = 0; n < tokens.size(); ++n) 71 | { 72 | wstring szTok = tokens[n]; 73 | if (szTok.empty()) { 74 | continue; 75 | } 76 | else if (MyStrcmp(L".", szTok.c_str()) == 0) { 77 | continue; 78 | } 79 | else if (MyStrcmp(L"..", szTok.c_str()) == 0) 80 | { 81 | size_t nTempArrayCount = tempArray.size(); 82 | if (nTempArrayCount > 1) 83 | { 84 | tempArray.pop_back(); 85 | } 86 | } 87 | else 88 | { 89 | tempArray.push_back(szTok); 90 | } 91 | } 92 | // 生成最终文本 93 | size_t nCount = tempArray.size(); 94 | wstring strReturn; 95 | for (size_t n2 = 0; n2 < nCount; ++n2) 96 | { 97 | strReturn += tempArray[n2]; 98 | if (n2 != nCount - 1) 99 | { 100 | strReturn += L"/"; 101 | } 102 | } 103 | return strReturn; 104 | } 105 | 106 | KrnlnApi string 合并路径(const string& 文件名, const string& 目录) 107 | { 108 | // 取当前目录 109 | string strCurrentDir; 110 | if (目录.empty()) 111 | { 112 | strCurrentDir = std::filesystem::current_path().string(); 113 | 114 | } 115 | else 116 | { 117 | strCurrentDir = 目录; 118 | } 119 | 120 | // 按'/'或'\\'分割 121 | vector tokens; 122 | 123 | string strPath = strCurrentDir; 124 | strPath += "/"; 125 | strPath += 文件名; 126 | const char* szPrevToken = strPath.c_str(); 127 | for (const char* p = szPrevToken; *p; ++p) 128 | { 129 | if (*p == L'\\' || *p == L'/') 130 | { 131 | tokens.push_back(string(szPrevToken, p - szPrevToken)); 132 | szPrevToken = p + 1; 133 | } 134 | } 135 | if (*szPrevToken) 136 | { 137 | tokens.push_back(szPrevToken); 138 | } 139 | 140 | // 处理 "." 和 ".." 141 | vector tempArray; 142 | for (size_t n = 0; n < tokens.size(); ++n) 143 | { 144 | string szTok = tokens[n]; 145 | if (szTok.empty()) 146 | continue; 147 | else if (MyStrcmp(".", szTok.c_str()) == 0) 148 | continue; 149 | else if (MyStrcmp("..", szTok.c_str()) == 0) 150 | { 151 | size_t nTempArrayCount = tempArray.size(); 152 | if (nTempArrayCount > 1) 153 | { 154 | tempArray.pop_back(); 155 | } 156 | } 157 | else 158 | { 159 | tempArray.push_back(szTok); 160 | } 161 | } 162 | 163 | // 生成最终文本 164 | size_t nCount = tempArray.size(); 165 | string strReturn; 166 | for (size_t n2 = 0; n2 < nCount; ++n2) 167 | { 168 | strReturn += tempArray[n2]; 169 | if (n2 != nCount - 1) 170 | { 171 | strReturn += "/"; 172 | } 173 | } 174 | 175 | return strReturn; 176 | 177 | } -------------------------------------------------------------------------------- /src/环境存取/取执行文件名.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #ifdef _WIN32 3 | #include 4 | #else//仅考虑linux 5 | #include 6 | #endif 7 | 8 | 9 | KrnlnApi std::string 取执行文件名A() 10 | { 11 | std::error_code ec; 12 | //尝试使用标准库获取 13 | std::filesystem::path exec_path = std::filesystem::read_symlink("/proc/self/exe", ec); 14 | if (ec) 15 | { 16 | if (ec.value() == ENOENT)//不存在?? 17 | { 18 | return {}; 19 | } 20 | else 21 | { 22 | #ifdef _WIN32 23 | std::string Path = ""; 24 | char szModule[MAX_PATH + 1] = { 0 }; 25 | szModule[0] = '\0'; 26 | if (::GetModuleFileNameA(NULL, szModule, MAX_PATH)) { 27 | 28 | Path = szModule; 29 | Path = Path.substr(1 + Path.find_last_of("\\")); 30 | 31 | } 32 | return Path; 33 | #else//仅考虑Linux 34 | pid_t pid = getpid(); 35 | std::vector path(1024); 36 | int result = readlink(("/proc/" + std::to_string(pid) + "/exe").c_str(), path.data(), path.size()); 37 | if (result == -1) { 38 | return ""; 39 | } 40 | std::string exec_path(path.begin(), path.begin() + result); 41 | return exec_path.substr(exec_path.find_last_of("/") + 1); 42 | 43 | #endif // _WIN32 44 | } 45 | } 46 | return exec_path.filename().string(); 47 | } 48 | 49 | KrnlnApi std::wstring 取执行文件名W() 50 | { 51 | std::error_code ec; 52 | //尝试使用标准库获取 53 | std::filesystem::path exec_path = std::filesystem::read_symlink(L"/proc/self/exe", ec); 54 | if (ec) 55 | { 56 | if (ec.value() == ENOENT)//不存在? 57 | { 58 | return {}; 59 | } 60 | else 61 | { 62 | #ifdef _WIN32 63 | std::wstring Path = L""; 64 | wchar_t szModule[MAX_PATH + 1] = { 0 }; 65 | szModule[0] = L'\0'; 66 | if (::GetModuleFileNameW(NULL, szModule, MAX_PATH)) { 67 | 68 | Path = szModule; 69 | Path = Path.substr(1 + Path.find_last_of(L"\\")); 70 | 71 | } 72 | return Path; 73 | #else //仅考虑Linux 74 | pid_t pid = getpid(); 75 | std::vector path(1024); 76 | int result = readlink(L("/proc/" + std::to_wstring(pid) + L"/exe").c_str(), path.data(), path.size()); 77 | if (result == -1) { 78 | return L""; 79 | } 80 | std::wstring exec_path(path.begin(), path.begin() + result); 81 | return exec_path.substr(exec_path.find_last_of(L"/") + 1); 82 | #endif 83 | } 84 | } 85 | return exec_path.filename().wstring(); 86 | } 87 | -------------------------------------------------------------------------------- /src/环境存取/取运行目录.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | KrnlnApi std::string 取运行目录A() { 3 | return std::filesystem::current_path().string(); 4 | } 5 | KrnlnApi std::wstring 取运行目录W() { 6 | return std::filesystem::current_path().wstring(); 7 | } 8 | -------------------------------------------------------------------------------- /src/环境存取/枚举注册表.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32//注册表仅在win环境下可用 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | 8 | KrnlnApi vector 枚举注册表项(HKEY 根类, const string& 父路径) 9 | { 10 | REGSAM Type; 11 | HKEY pHkey; 12 | SYSTEM_INFO INFO; 13 | std::vector ret; 14 | pHkey = 0; 15 | GetNativeSystemInfo(&INFO); 16 | if (INFO.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 || (Type = KEY_WOW64_32KEY | KEY_ALL_ACCESS, INFO.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)) { 17 | 18 | Type = KEY_WOW64_64KEY | KEY_ALL_ACCESS; 19 | } 20 | 21 | RegOpenKeyExA(根类, 父路径.c_str(), 1, Type, &pHkey); 22 | char name[MAX_PATH] = {}; 23 | if (!RegEnumKeyA(pHkey, 0, name, MAX_PATH)) 24 | { 25 | ret.push_back(name); 26 | if (!RegEnumKeyA(pHkey, 1, name, MAX_PATH)) 27 | { 28 | DWORD i = 2; 29 | do { 30 | ret.push_back(name); 31 | } while (!RegEnumKeyA(pHkey, i++, name, MAX_PATH)); 32 | } 33 | RegCloseKey(pHkey); 34 | } 35 | return ret; 36 | } 37 | KrnlnApi vector 枚举注册表项(HKEY 根类, const wstring& 父路径) 38 | { 39 | REGSAM Type; 40 | HKEY pHkey; 41 | SYSTEM_INFO INFO; 42 | std::vector ret; 43 | pHkey = 0; 44 | GetNativeSystemInfo(&INFO); 45 | if (INFO.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 || (Type = KEY_WOW64_32KEY | KEY_ALL_ACCESS, INFO.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)) { 46 | 47 | Type = KEY_WOW64_64KEY | KEY_ALL_ACCESS; 48 | } 49 | RegOpenKeyExW(根类, 父路径.c_str(), 1, Type, &pHkey); 50 | wchar_t name[MAX_PATH] = {}; 51 | if (!RegEnumKeyW(pHkey, 0, name, MAX_PATH)) 52 | { 53 | ret.push_back(name); 54 | if (!RegEnumKeyW(pHkey, 1, name, MAX_PATH)) 55 | { 56 | DWORD i = 2; 57 | do { 58 | ret.push_back(name); 59 | } while (!RegEnumKeyW(pHkey, i++, name, MAX_PATH)); 60 | } 61 | RegCloseKey(pHkey); 62 | } 63 | return ret; 64 | } 65 | #endif // _WIN32 66 | 67 | -------------------------------------------------------------------------------- /src/环境存取/规范化路径.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | 6 | 7 | 8 | KrnlnApi string 规范化路径(const string& szPath) 9 | { 10 | if (szPath.empty()) 11 | { 12 | return {}; 13 | } 14 | char* str = new char[szPath.size() + 1]; 15 | memset(str, 0, sizeof(char) * (szPath.size() + 1)); 16 | 17 | strcpy_s(str, szPath.size(), szPath.c_str()); 18 | 19 | for (char* p = str; *p != 0; ++p) 20 | { 21 | if (*p >= 'A' && *p <= 'Z') 22 | *p += ('a' - 'A'); 23 | if (*p == '\\') 24 | *p = '/'; 25 | } 26 | string ret(str); 27 | delete[]str; 28 | return ret; 29 | } 30 | KrnlnApi wstring 规范化路径(const wstring& szPath) 31 | { 32 | if (szPath.empty()) 33 | { 34 | return {}; 35 | } 36 | wchar_t* str = new wchar_t[szPath.size() + 1]; 37 | memset(str, 0, sizeof(wchar_t) * (szPath.size() + 1)); 38 | wcscpy_s(str, szPath.size(), szPath.c_str()); 39 | for (wchar_t* p = str; *p != 0; ++p) 40 | { 41 | if (*p >= L'A' && *p <= L'Z') { 42 | *p += (L'a' - L'A'); 43 | } 44 | if (*p == L'\\') { 45 | *p = L'/'; 46 | } 47 | } 48 | wstring ret(str); 49 | delete[]str; 50 | return ret; 51 | } -------------------------------------------------------------------------------- /src/环境存取/读环境变量.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | #ifdef _WIN32 5 | #include 6 | using namespace std; 7 | KrnlnApi string 读环境变量(const string& 环境变量名称) { 8 | char* pBuf = new char[MAX_PATH]; 9 | UINT nRet = GetEnvironmentVariableA(环境变量名称.c_str(), pBuf, MAX_PATH); 10 | if (nRet > MAX_PATH)//缓冲区不够 11 | { 12 | delete[]pBuf;//释放再申请 13 | pBuf = new char[nRet]; 14 | GetEnvironmentVariableA(环境变量名称.c_str(), pBuf, nRet); 15 | } 16 | string Ret(pBuf); 17 | delete[]pBuf; 18 | return Ret; 19 | } 20 | KrnlnApi wstring 读环境变量(const wstring& 环境变量名称) { 21 | wchar_t* pBuf = new wchar_t[MAX_PATH]; 22 | UINT nRet = GetEnvironmentVariableW(环境变量名称.c_str(), pBuf, MAX_PATH); 23 | if (nRet > MAX_PATH)//缓冲区不够 24 | { 25 | delete[]pBuf;//释放再申请 26 | pBuf = new wchar_t[nRet]; 27 | GetEnvironmentVariableW(环境变量名称.c_str(), pBuf, nRet); 28 | } 29 | wstring Ret(pBuf); 30 | delete[]pBuf; 31 | return Ret; 32 | } 33 | #else 34 | KrnlnApi string 读环境变量(const string& 环境变量名称) { 35 | char* val = getenv(环境变量名称.c_str()); 36 | return val ? val : string(); 37 | } 38 | KrnlnApi wstring 读环境变量(const wstring& 环境变量名称) { 39 | wchar_t* val = _wgetenv(环境变量名称.c_str()); 40 | return val ? val : wstring(); 41 | } 42 | #endif -------------------------------------------------------------------------------- /src/磁盘操作/写到文件.cpp: -------------------------------------------------------------------------------- 1 | #pragma warning(disable:4996) 2 | #include 3 | #include 4 | using namespace std; //直接使用标准库输出差距不大 5 | //#ifdef _WIN32 6 | //#include 7 | // 8 | // 9 | //KrnlnApi bool 写到文件(string 文件名, vector 欲写入文件的数据) { 10 | // 11 | // 12 | // HANDLE hFile = CreateFileA(文件名.c_str(), 13 | // GENERIC_WRITE, 14 | // 0, 15 | // NULL, 16 | // CREATE_ALWAYS, 17 | // FILE_ATTRIBUTE_ARCHIVE, 18 | // 0); 19 | // 20 | // BOOL bRet = FALSE; 21 | // if (hFile != INVALID_HANDLE_VALUE) 22 | // { 23 | // 24 | // DWORD dwNumOfByteRead; 25 | // bRet = TRUE; 26 | // 27 | // LPBYTE pData = 欲写入文件的数据.data(); 28 | // INT nLen = 欲写入文件的数据.size(); 29 | // 30 | // if (WriteFile(hFile, pData, nLen, &dwNumOfByteRead, NULL) == FALSE) 31 | // { 32 | // bRet = FALSE; 33 | // } 34 | // /* if(FlushFileBuffers(hFile)==FALSE) 35 | // { 36 | // bRet = FALSE; 37 | // break; 38 | // }*/ 39 | // 40 | // CloseHandle(hFile); 41 | // } 42 | // return bRet; 43 | // 44 | // 45 | //} 46 | // 47 | //KrnlnApi bool 写到文件(wstring 文件名, vector 欲写入文件的数据) { 48 | // 49 | // 50 | // HANDLE hFile = CreateFileW(文件名.c_str(), 51 | // GENERIC_WRITE, 52 | // 0, 53 | // NULL, 54 | // CREATE_ALWAYS, 55 | // FILE_ATTRIBUTE_ARCHIVE, 56 | // 0); 57 | // 58 | // BOOL bRet = FALSE; 59 | // if (hFile != INVALID_HANDLE_VALUE) 60 | // { 61 | // 62 | // DWORD dwNumOfByteRead; 63 | // bRet = TRUE; 64 | // 65 | // LPBYTE pData = 欲写入文件的数据.data(); 66 | // INT nLen = 欲写入文件的数据.size(); 67 | // 68 | // if (WriteFile(hFile, pData, nLen, &dwNumOfByteRead, NULL) == FALSE) 69 | // { 70 | // bRet = FALSE; 71 | // } 72 | // /* if(FlushFileBuffers(hFile)==FALSE) 73 | // { 74 | // bRet = FALSE; 75 | // break; 76 | // }*/ 77 | // 78 | // CloseHandle(hFile); 79 | // } 80 | // return bRet; 81 | // 82 | // 83 | //} 84 | // 85 | //#else 86 | // 87 | //#endif 88 | 89 | 90 | 91 | KrnlnApi bool 写到文件(const wstring& filename, vector data) 92 | { 93 | 94 | if (filename.empty() || data.empty()) 95 | return false; 96 | 97 | FILE* out = _wfopen(filename.c_str(), L"wb"); 98 | if (out == NULL) 99 | return false; 100 | 101 | const bool blpSucceeded = (fwrite(data.data(), 1, data.size(), out) == data.size()); 102 | fclose(out); 103 | return blpSucceeded; 104 | } 105 | KrnlnApi bool 写到文件(const string& filename, vector data) 106 | { 107 | 108 | if (filename.empty() || data.empty()) 109 | return false; 110 | 111 | FILE* out = fopen(filename.c_str(), "wb"); 112 | if (out == NULL) 113 | return false; 114 | 115 | const bool blpSucceeded = (fwrite(data.data(), 1, data.size(), out) == data.size()); 116 | fclose(out); 117 | return blpSucceeded; 118 | } -------------------------------------------------------------------------------- /src/磁盘操作/创建目录.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | KrnlnApi bool 创建目录(const std::string& 路径名称, bool 强制创建) { 6 | std::filesystem::path p(路径名称); 7 | if (!强制创建) 8 | { 9 | if (!std::filesystem::exists(p.parent_path())) { 10 | return false; 11 | } 12 | } 13 | return std::filesystem::create_directories(路径名称); 14 | } 15 | KrnlnApi bool 创建目录(const std::wstring& 路径名称, bool 强制创建) { 16 | std::filesystem::path p(路径名称); 17 | if (!强制创建) 18 | { 19 | if (!std::filesystem::exists(p.parent_path())) { 20 | return false; 21 | } 22 | } 23 | return std::filesystem::create_directories(路径名称); 24 | } 25 | -------------------------------------------------------------------------------- /src/磁盘操作/删除文件.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | #ifdef _WIN32 5 | #include 6 | using namespace std; 7 | KrnlnApi bool 删除文件(const string& 欲删除的文件名) { 8 | return DeleteFileA(欲删除的文件名.c_str()); 9 | } 10 | 11 | KrnlnApi bool 删除文件(const wstring 欲删除的文件名) { 12 | return DeleteFileW(欲删除的文件名.c_str()); 13 | } 14 | 15 | #else 16 | #include"direct.h" 17 | 18 | KrnlnApi bool 删除文件(const string& 欲删除的目录名称) { 19 | 20 | return remove(欲删除的目录名称.c_str()) == 0; 21 | } 22 | KrnlnApi bool 删除文件(const wstring& 欲删除的目录名称) { 23 | return _wremove(欲删除的目录名称.c_str()) == 0; 24 | } 25 | #endif 26 | -------------------------------------------------------------------------------- /src/磁盘操作/删除目录.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | #ifdef _WIN32 5 | #include 6 | using namespace std; 7 | KrnlnApi bool 删除目录(const string& 欲删除的目录名称) { 8 | if (欲删除的目录名称.empty()) 9 | return FALSE; 10 | size_t nLen = 欲删除的目录名称.size(); 11 | if (nLen == 0)//防止删除当前目录的根目录"\*" 12 | return FALSE; 13 | if (nLen == 1 && 欲删除的目录名称 == "\\")//防止删除当前目录的根目录"\*" 14 | return FALSE; 15 | return RemoveDirectoryA(欲删除的目录名称.c_str());//删除空目录 16 | } 17 | KrnlnApi bool 删除目录(const wstring& 欲删除的目录名称) { 18 | if (欲删除的目录名称.empty()) 19 | return FALSE; 20 | size_t nLen = 欲删除的目录名称.size(); 21 | if (nLen == 0)//防止删除当前目录的根目录"\*" 22 | return FALSE; 23 | if (nLen == 1 && 欲删除的目录名称 == L"\\")//防止删除当前目录的根目录"\*" 24 | return FALSE; 25 | return RemoveDirectoryW(欲删除的目录名称.c_str());//删除空目录 26 | } 27 | 28 | #else 29 | #include"direct.h" 30 | 31 | KrnlnApi bool 删除目录(const string& 欲删除的目录名称) { 32 | if (欲删除的目录名称.empty()) 33 | return FALSE; 34 | size_t nLen = 欲删除的目录名称.size(); 35 | if (nLen == 0)//防止删除当前目录的根目录"\*" 36 | return FALSE; 37 | if (nLen == 1 && 欲删除的目录名称 == "\\")//防止删除当前目录的根目录"\*" 38 | return FALSE; 39 | 40 | return rmdir(欲删除的目录名称.c_str()) == 0; 41 | } 42 | KrnlnApi bool 删除目录(const wstring& 欲删除的目录名称) { 43 | if (欲删除的目录名称.empty()) 44 | return FALSE; 45 | size_t nLen = 欲删除的目录名称.size(); 46 | if (nLen == 0)//防止删除当前目录的根目录"\*" 47 | return FALSE; 48 | if (nLen == 1 && 欲删除的目录名称 == L"\\")//防止删除当前目录的根目录"\*" 49 | return FALSE; 50 | return _wrmdir(欲删除的目录名称.c_str()) == 0; 51 | } 52 | #endif -------------------------------------------------------------------------------- /src/磁盘操作/取临时文件名.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | KrnlnApi std::string 取临时文件名A(const std::string& dir_name) { 6 | // 获取临时文件夹的路径 7 | std::filesystem::path temp_dir = std::filesystem::temp_directory_path(); 8 | if (!dir_name.empty()) { 9 | temp_dir = dir_name; 10 | } 11 | 12 | // 确保临时文件夹的路径以斜杠结尾 13 | if (!temp_dir.has_stem()) { 14 | temp_dir /= ""; 15 | } 16 | //根据时间生成随机文件名 17 | std::filesystem::path temp_file_name; 18 | do { 19 | time_t num = time(0); 20 | std::stringstream ss; 21 | ss << std::hex << num; 22 | std::string hex_string = ss.str() + ".tmp"; 23 | temp_file_name = temp_dir / hex_string; 24 | } while (std::filesystem::exists(temp_file_name)); 25 | 26 | return temp_file_name.string(); 27 | } 28 | 29 | KrnlnApi std::wstring 取临时文件名W(const std::wstring& dir_name) { 30 | // 获取临时文件夹的路径 31 | std::filesystem::path temp_dir = std::filesystem::temp_directory_path(); 32 | if (!dir_name.empty()) { 33 | temp_dir = dir_name; 34 | } 35 | 36 | // 确保临时文件夹的路径以斜杠结尾 37 | if (!temp_dir.has_stem()) { 38 | temp_dir /= ""; 39 | } 40 | //根据时间生成随机文件名 41 | std::filesystem::path temp_file_name; 42 | do { 43 | time_t num = time(0); 44 | std::wstringstream ss; 45 | ss << std::hex << num; 46 | std::wstring hex_string = ss.str() + L".tmp"; 47 | temp_file_name = temp_dir / hex_string; 48 | } while (std::filesystem::exists(temp_file_name)); 49 | 50 | return temp_file_name.wstring(); 51 | } 52 | -------------------------------------------------------------------------------- /src/磁盘操作/取当前目录.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #ifdef _WIN32 3 | #include 4 | using namespace std; 5 | KrnlnApi string 取当前目录A() { 6 | 7 | char DirName[MAX_PATH] = { 0 }; 8 | string pText; 9 | if (GetCurrentDirectoryA(MAX_PATH, DirName)) 10 | { 11 | return DirName; 12 | } 13 | return string(); 14 | } 15 | KrnlnApi wstring 取当前目录W() { 16 | wchar_t DirName[MAX_PATH] = { 0 }; 17 | if (GetCurrentDirectoryW(MAX_PATH, DirName)) 18 | { 19 | return DirName; 20 | } 21 | return wstring(); 22 | } 23 | 24 | #else 25 | #include"direct.h" 26 | KrnlnApi string 取当前目录A() 27 | { 28 | char pBuff[0x400] = { 0 }; 29 | if (_getcwd(pBuff, 0x400)) { 30 | return pBuff; 31 | } 32 | return string(); 33 | } 34 | KrnlnApi wstring 取当前目录W() { 35 | wchar_t pBuff[0x400] = { 0 }; 36 | if (_wgetcwd(pBuff, 0x400)) { 37 | return pBuff; 38 | } 39 | return wstring(); 40 | 41 | } 42 | #endif -------------------------------------------------------------------------------- /src/磁盘操作/取文件尺寸.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // 3 | //#ifdef _WIN32 4 | //#include 5 | //#include 6 | //using namespace std; 7 | //KrnlnApi long long 取文件尺寸(const string& filename) 8 | //{ 9 | // WIN32_FIND_DATAA inf; 10 | // const HANDLE handle = ::FindFirstFileA(filename.c_str(), &inf); 11 | // if (handle != INVALID_HANDLE_VALUE) { 12 | // ::FindClose(handle); 13 | // return (((INT64)inf.nFileSizeHigh << 32) | (INT64)inf.nFileSizeLow); 14 | // } 15 | // return -1; 16 | //} 17 | //KrnlnApi long long 取文件尺寸(const wstring& filename) { 18 | // WIN32_FIND_DATAW inf; 19 | // const HANDLE handle = ::FindFirstFileW(filename.c_str(), &inf); 20 | // if (handle != INVALID_HANDLE_VALUE) { 21 | // ::FindClose(handle); 22 | // return (((INT64)inf.nFileSizeHigh << 32) | (INT64)inf.nFileSizeLow); 23 | // } 24 | // return -1; 25 | //} 26 | // 27 | // 28 | // 29 | // 30 | // 31 | // 32 | //#else 33 | #include 34 | KrnlnApi long long 取文件尺寸(const std::string& filename) { 35 | if (!std::filesystem::exists(filename)) { 36 | return -1; 37 | } 38 | 39 | return std::filesystem::file_size(filename); 40 | } 41 | 42 | KrnlnApi long long 取文件尺寸(const std::wstring& filename) { 43 | if (!std::filesystem::exists(filename)) { 44 | return -1; 45 | } 46 | 47 | return std::filesystem::file_size(filename); 48 | } 49 | 50 | //#endif 51 | 52 | 53 | 54 | 55 | 56 | -------------------------------------------------------------------------------- /src/磁盘操作/取文件属性.cpp: -------------------------------------------------------------------------------- 1 |  2 | #include"string" 3 | #include"windows.h" 4 | using namespace std; 5 | 6 | KrnlnApi int 取文件属性(const string& 文件名) { 7 | const DWORD dwFlags = ::GetFileAttributesA(文件名.c_str()); 8 | return (dwFlags == 0xffffffff ? -1 : (INT)dwFlags); 9 | 10 | 11 | } 12 | KrnlnApi int 取文件属性(const wstring& 文件名) { 13 | 14 | const DWORD dwFlags = ::GetFileAttributesW(文件名.c_str()); 15 | return (dwFlags == 0xffffffff ? -1 : (INT)dwFlags); 16 | 17 | } 18 | 19 | 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /src/磁盘操作/取文件时间.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #ifdef _WIN32 5 | #include 6 | KrnlnApi std::tm 取文件时间(const std::string& 文件名) { 7 | WIN32_FIND_DATAA FindFileData; 8 | HANDLE hFind = FindFirstFileA(文件名.c_str(), &FindFileData); 9 | std::tm Ret = { 0, 0, 0, 1, 1, 100 }; 10 | if (hFind != INVALID_HANDLE_VALUE) 11 | { 12 | FindClose(hFind); 13 | if (FileTimeToLocalFileTime(&FindFileData.ftLastWriteTime, &FindFileData.ftCreationTime)) 14 | { 15 | SYSTEMTIME st; 16 | if (FileTimeToSystemTime(&FindFileData.ftCreationTime, &st)) { 17 | Ret = { st.wSecond, st.wMinute, st.wHour, st.wDay, st.wMonth - 1, st.wYear - 1900, st.wDayOfWeek, 0, 0 }; 18 | 19 | } 20 | } 21 | } 22 | return Ret; 23 | } 24 | KrnlnApi std::tm 取文件时间(const std::wstring& 文件名) { 25 | WIN32_FIND_DATAW FindFileData; 26 | HANDLE hFind = FindFirstFileW(文件名.c_str(), &FindFileData); 27 | std::tm Ret = { 0, 0, 0, 1, 1, 100 }; 28 | if (hFind != INVALID_HANDLE_VALUE) 29 | { 30 | FindClose(hFind); 31 | if (FileTimeToLocalFileTime(&FindFileData.ftLastWriteTime, &FindFileData.ftCreationTime)) 32 | { 33 | SYSTEMTIME st; 34 | if (FileTimeToSystemTime(&FindFileData.ftCreationTime, &st)) { 35 | Ret = { st.wSecond, st.wMinute, st.wHour, st.wDay, st.wMonth - 1, st.wYear - 1900, st.wDayOfWeek, 0, 0 }; 36 | 37 | } 38 | } 39 | } 40 | return Ret; 41 | } 42 | #else 43 | //SYSTEMTIME转time_t 44 | 45 | KrnlnApi std::tm 取文件时间(const std::string& filename) { 46 | struct _stat buf; 47 | 48 | //获得文件状态信息 49 | if (_stat(filename.c_str(), &buf) != 0) { 50 | return std::tm{ 0, 0, 0, 1, 1, 100 }; 51 | } 52 | 53 | std::tm file_time{}; 54 | gmtime_s(&file_time, &buf.st_mtime); 55 | return file_time; 56 | } 57 | 58 | std::tm KrnlnApi 取文件时间(const std::wstring& filename) { 59 | struct _stat buf; 60 | //获得文件状态信息 61 | if (_wstat(filename.c_str(), &buf) != 0) { 62 | return std::tm{ 0, 0, 0, 1, 1, 100 }; 63 | } 64 | std::tm file_time{}; 65 | gmtime_s(&file_time, &buf.st_mtime); 66 | return file_time; 67 | } 68 | #endif // _WIN32 69 | 70 | -------------------------------------------------------------------------------- /src/磁盘操作/取父路径.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | KrnlnApi std::string 取父路径(const std::string& file_or_directory_name) 4 | { 5 | std::string result = file_or_directory_name; 6 | if (!result.empty() && result.back() == '\\') { 7 | result.pop_back(); 8 | } 9 | size_t pos = result.find_last_of("\\"); 10 | return result.substr(0, pos); 11 | } 12 | KrnlnApi std::wstring 取父路径(const std::wstring& file_or_directory_name) 13 | { 14 | std::wstring result = file_or_directory_name; 15 | if (!result.empty() && result.back() == '\\') { 16 | result.pop_back(); 17 | } 18 | size_t pos = result.find_last_of(L"\\"); 19 | return result.substr(0, pos); 20 | } -------------------------------------------------------------------------------- /src/磁盘操作/取磁盘剩余空间.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #ifdef _WIN32 4 | 5 | #include"windows.h" 6 | using namespace std; 7 | KrnlnApi long long 取磁盘剩余空间(const string& 磁盘驱动器字符) { 8 | char DirName[MAX_PATH] = { 0 }; 9 | if (磁盘驱动器字符 == "") 10 | { 11 | if (GetCurrentDirectoryA(MAX_PATH, DirName) == 0) 12 | return -1; 13 | DirName[2] = 0; 14 | 15 | } 16 | else 17 | { 18 | if (磁盘驱动器字符.empty()) 19 | return -1; 20 | 21 | DirName[0] = *磁盘驱动器字符.c_str(); 22 | DirName[1] = ':'; 23 | DirName[2] = 0; 24 | 25 | } 26 | ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes, TotalNumberOfFreeBytes; 27 | if (GetDiskFreeSpaceExA(DirName, &FreeBytesAvailableToCaller, &TotalNumberOfBytes, &TotalNumberOfFreeBytes)) 28 | { 29 | long long nRet = (long long)(FreeBytesAvailableToCaller.QuadPart / 1024); 30 | return nRet; 31 | } 32 | return -1; 33 | } 34 | 35 | KrnlnApi long long 取磁盘剩余空间(const wstring& 磁盘驱动器字符) { 36 | wchar_t DirName[MAX_PATH] = { 0 }; 37 | if (磁盘驱动器字符.empty()) 38 | { 39 | if (GetCurrentDirectoryW(MAX_PATH, DirName) == 0) 40 | return -1; 41 | DirName[2] = L'\0'; 42 | 43 | } 44 | else 45 | { 46 | if (磁盘驱动器字符.empty()) 47 | return -1; 48 | 49 | DirName[0] = *磁盘驱动器字符.c_str(); 50 | DirName[1] = L':'; 51 | DirName[2] = L'\0'; 52 | 53 | } 54 | ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes, TotalNumberOfFreeBytes; 55 | 56 | if (GetDiskFreeSpaceExW(DirName, &FreeBytesAvailableToCaller, &TotalNumberOfBytes, &TotalNumberOfFreeBytes)) 57 | { 58 | long long nRet = (long long)(FreeBytesAvailableToCaller.QuadPart / 1024); 59 | return nRet; 60 | } 61 | return -1; 62 | } 63 | 64 | 65 | KrnlnApi long long 取磁盘剩余空间(char 磁盘驱动器字符) { 66 | char DirName[4] = { 0 }; 67 | DirName[0] = 磁盘驱动器字符; 68 | DirName[1] = ':'; 69 | DirName[2] = 0; 70 | ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes, TotalNumberOfFreeBytes; 71 | if (GetDiskFreeSpaceExA(DirName, &FreeBytesAvailableToCaller, &TotalNumberOfBytes, &TotalNumberOfFreeBytes)) 72 | { 73 | long long nRet = (long long)(FreeBytesAvailableToCaller.QuadPart / 1024); 74 | return nRet; 75 | } 76 | return -1; 77 | } 78 | 79 | KrnlnApi long long 取磁盘剩余空间(wchar_t 磁盘驱动器字符) { 80 | wchar_t DirName[4] = { 磁盘驱动器字符,L':' }; 81 | DirName[0] = 磁盘驱动器字符; 82 | DirName[1] = L':'; 83 | DirName[2] = L'\0'; 84 | ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes, TotalNumberOfFreeBytes; 85 | if (GetDiskFreeSpaceExW(DirName, &FreeBytesAvailableToCaller, &TotalNumberOfBytes, &TotalNumberOfFreeBytes)) 86 | { 87 | long long nRet = (long long)(FreeBytesAvailableToCaller.QuadPart / 1024); 88 | return nRet; 89 | } 90 | return -1; 91 | } 92 | #endif // _WIN32 93 | 94 | 95 | 96 | -------------------------------------------------------------------------------- /src/磁盘操作/取磁盘卷标.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #ifdef _WIN32 3 | #include 4 | std::string GetDiskLabel(const std::string& drive) { 5 | std::string dir_name; 6 | 7 | if (drive.empty()) { 8 | char current_dir[MAX_PATH]; 9 | if (GetCurrentDirectoryA(MAX_PATH, current_dir) == 0) { 10 | return ""; 11 | } 12 | dir_name = current_dir; 13 | dir_name[3] = 0; 14 | } 15 | else { 16 | dir_name = drive; 17 | dir_name += ":\\"; 18 | } 19 | 20 | char volume[MAX_PATH]; 21 | char file_system_name[64]; 22 | DWORD volume_serial_number; 23 | if (GetVolumeInformationA(dir_name.c_str(), volume, MAX_PATH, &volume_serial_number, NULL, NULL, file_system_name, 64)) { 24 | return std::string(volume); 25 | } 26 | 27 | return ""; 28 | } 29 | 30 | std::wstring GetDiskLabel(const std::wstring& drive) { 31 | std::wstring dir_name; 32 | 33 | if (drive.empty()) { 34 | wchar_t current_dir[MAX_PATH]; 35 | if (GetCurrentDirectoryW(MAX_PATH, current_dir) == 0) { 36 | return L""; 37 | } 38 | dir_name = current_dir; 39 | dir_name[3] = 0; 40 | } 41 | else { 42 | dir_name = drive; 43 | dir_name += L":\\"; 44 | } 45 | 46 | wchar_t volume[MAX_PATH]; 47 | wchar_t file_system_name[64]; 48 | DWORD volume_serial_number; 49 | if (GetVolumeInformationW(dir_name.c_str(), volume, MAX_PATH, &volume_serial_number, NULL, NULL, file_system_name, 64)) { 50 | return std::wstring(volume); 51 | } 52 | 53 | return L""; 54 | } 55 | 56 | KrnlnApi std::string 取磁盘卷标A(const std::string& 磁盘驱动器字符) { 57 | return GetDiskLabel(磁盘驱动器字符); 58 | } 59 | 60 | KrnlnApi std::wstring 取磁盘卷标W(const std::wstring& 磁盘驱动器字符) { 61 | 62 | return GetDiskLabel(磁盘驱动器字符); 63 | } 64 | 65 | KrnlnApi std::string 取磁盘卷标A(char 磁盘驱动器字符) { 66 | return GetDiskLabel(std::string(磁盘驱动器字符, 1)); 67 | } 68 | 69 | KrnlnApi std::wstring 取磁盘卷标W(wchar_t 磁盘驱动器字符) { 70 | 71 | return GetDiskLabel(std::wstring(磁盘驱动器字符, 1)); 72 | 73 | } 74 | #endif // _WIN32 -------------------------------------------------------------------------------- /src/磁盘操作/取磁盘总空间.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | #ifdef _WIN32 3 | #include 4 | using namespace std; 5 | 6 | KrnlnApi long long 取磁盘总空间(wchar_t 磁盘驱动器字符) { 7 | wchar_t DirName[4] = { 0 }; 8 | DirName[0] = 磁盘驱动器字符; 9 | DirName[1] = L':'; 10 | DirName[2] = L'\0'; 11 | ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes; 12 | return (GetDiskFreeSpaceExW(DirName, &i64FreeBytesToCaller, &i64TotalBytes, &i64FreeBytes) ? (long long)i64TotalBytes.QuadPart / 1024 : -1); 13 | } 14 | KrnlnApi long long 取磁盘总空间(char 磁盘驱动器字符) { 15 | char DirName[4] = { 0 }; 16 | DirName[0] = 磁盘驱动器字符; 17 | DirName[1] = ':'; 18 | DirName[2] = '\0'; 19 | ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes; 20 | return (GetDiskFreeSpaceExA(DirName, &i64FreeBytesToCaller, &i64TotalBytes, &i64FreeBytes) ? (long long)i64TotalBytes.QuadPart / 1024 : -1); 21 | } 22 | KrnlnApi long long 取磁盘总空间(const string& 磁盘驱动器字符) { 23 | 24 | char DirName[MAX_PATH] = { 0 }; 25 | if (磁盘驱动器字符.empty()) 26 | { 27 | if (GetCurrentDirectoryA(MAX_PATH, DirName) == 0) 28 | return -1; 29 | DirName[2] = 0; 30 | } 31 | else 32 | { 33 | DirName[0] = *磁盘驱动器字符.c_str(); 34 | DirName[1] = ':'; 35 | DirName[2] = '\0'; 36 | 37 | } 38 | ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes; 39 | return (GetDiskFreeSpaceExA(DirName, &i64FreeBytesToCaller, &i64TotalBytes, &i64FreeBytes) ? (INT64)i64TotalBytes.QuadPart / 1024 : -1); 40 | } 41 | 42 | 43 | 44 | KrnlnApi long long 取磁盘总空间(const wstring& 磁盘驱动器字符) { 45 | 46 | wchar_t DirName[MAX_PATH] = { 0 }; 47 | if (磁盘驱动器字符.empty()) 48 | { 49 | if (GetCurrentDirectoryW(MAX_PATH, DirName) == 0) 50 | return -1; 51 | DirName[2] = 0; 52 | } 53 | else 54 | { 55 | DirName[0] = *磁盘驱动器字符.c_str(); 56 | DirName[1] = L':'; 57 | DirName[2] = L'\0'; 58 | 59 | } 60 | //ULARGE_INTEGER FreeBytesAvailableToCaller, TotalNumberOfBytes, TotalNumberOfFreeBytes; 61 | ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes; 62 | return (GetDiskFreeSpaceExW(DirName, &i64FreeBytesToCaller, &i64TotalBytes, &i64FreeBytes) ? (INT64)i64TotalBytes.QuadPart / 1024 : -1); 63 | } 64 | 65 | #endif // _WIN32 -------------------------------------------------------------------------------- /src/磁盘操作/复制文件.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | #ifdef _WIN32 12 | #include 13 | using namespace std; 14 | KrnlnApi bool 复制文件(const string& 被复制的文件名, const string& 复制到的文件名) { 15 | return CopyFileA(被复制的文件名.c_str(), 复制到的文件名.c_str(), FALSE); 16 | } 17 | KrnlnApi bool 复制文件(const wstring& 被复制的文件名, const wstring& 复制到的文件名) { 18 | return CopyFileW(被复制的文件名.c_str(), 复制到的文件名.c_str(), FALSE); 19 | } 20 | #else //linux 文件流 21 | #include 22 | KrnlnApi bool 复制文件(const wstring& 被复制的文件名, const wstring& 复制到的文件名) 23 | { 24 | 25 | ifstream infile(被复制的文件名, ios::in | ios::binary);//二进制形式打开 26 | if (infile.is_open() == 0) {//出错处理 27 | return 0; 28 | } 29 | ofstream outfile(复制到的文件名, ios::out | ios::binary);//二进制形式打开 30 | if (outfile.is_open() == 0) {//出错处理 31 | infile.close();//记得关闭 32 | return 0; 33 | } 34 | //开始读写 35 | const int FLUSH_NUM = 1024 * 1024;//缓冲区大小设置为1M 36 | char* ch = new(nothrow)char[FLUSH_NUM]; 37 | if (ch == NULL) {//出错处理 38 | infile.close();//记得关闭 39 | outfile.close();//记得关闭 40 | return 0; 41 | } 42 | while (!infile.eof()) { 43 | infile.read(ch, FLUSH_NUM); 44 | outfile.write(ch, infile.gcount());//写入读入的成功个数 45 | } 46 | delete[]ch;//记得释放 47 | infile.close();//记得关闭 48 | outfile.close();//记得关闭 49 | return 1; 50 | } 51 | KrnlnApi bool 复制文件(const string& 被复制的文件名, const string& 复制到的文件名) 52 | { 53 | 54 | ifstream infile(被复制的文件名, ios::in | ios::binary);//二进制形式打开 55 | if (infile.is_open() == 0) {//出错处理 56 | return 0; 57 | } 58 | ofstream outfile(复制到的文件名, ios::out | ios::binary);//二进制形式打开 59 | if (outfile.is_open() == 0) {//出错处理 60 | infile.close();//记得关闭 61 | return 0; 62 | } 63 | //开始读写 64 | const int FLUSH_NUM = 1024 * 1024;//缓冲区大小设置为1M 65 | char* ch = new(nothrow)char[FLUSH_NUM]; 66 | if (ch == NULL) {//出错处理 67 | infile.close();//记得关闭 68 | outfile.close();//记得关闭 69 | return 0; 70 | } 71 | while (!infile.eof()) { 72 | infile.read(ch, FLUSH_NUM); 73 | outfile.write(ch, infile.gcount());//写入读入的成功个数 74 | } 75 | delete[]ch;//记得释放 76 | infile.close();//记得关闭 77 | outfile.close();//记得关闭 78 | return 1; 79 | } 80 | #endif -------------------------------------------------------------------------------- /src/磁盘操作/定位文件.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32//仅win下可用 2 | #include 3 | #include 4 | KrnlnApi bool 定位文件(const std::wstring& 文件路径, bool 编辑模式) 5 | { 6 | if (!std::filesystem::exists(文件路径)) {//文件不存在 7 | return false; 8 | } 9 | LPITEMIDLIST lng_pidl = nullptr; 10 | bool initialized = CoInitialize(0) == S_OK;//初始化过或者没有初始化成功 11 | lng_pidl = ILCreateFromPathW(文件路径.c_str()); 12 | if (!lng_pidl) { 13 | if (initialized) {//在本函数中初始化的com控件 14 | CoUninitialize(); 15 | } 16 | return false; 17 | } 18 | bool success = SHOpenFolderAndSelectItems(lng_pidl, 0, 0, 编辑模式 ? 1 : 0) == S_OK; 19 | SHFree(lng_pidl); 20 | if (initialized) { 21 | CoUninitialize(); 22 | } 23 | return success; 24 | } 25 | KrnlnApi bool 定位文件(const std::string& 文件路径, bool 编辑模式) 26 | { 27 | if (!std::filesystem::exists(文件路径)) {//文件不存在 28 | return false; 29 | } 30 | LPITEMIDLIST lng_pidl = nullptr; 31 | bool initialized = CoInitialize(0) == S_OK;//初始化过或者没有初始化成功 32 | lng_pidl = ILCreateFromPathA(文件路径.c_str()); 33 | if (!lng_pidl) { 34 | if (initialized) {//在本函数中初始化的com控件 35 | CoUninitialize(); 36 | } 37 | return false; 38 | } 39 | bool success = SHOpenFolderAndSelectItems(lng_pidl, 0, 0, 编辑模式 ? 1 : 0) == S_OK; 40 | SHFree(lng_pidl); 41 | if (initialized) { 42 | CoUninitialize(); 43 | } 44 | return success; 45 | } 46 | #endif // _WIN32 47 | 48 | -------------------------------------------------------------------------------- /src/磁盘操作/改变目录.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #ifdef _WIN32 3 | #include 4 | #else 5 | #include 6 | #endif 7 | using namespace std; 8 | KrnlnApi bool 改变目录(const string& 欲改变到的目录) { 9 | #ifdef _WIN32 10 | return SetCurrentDirectoryA(欲改变到的目录.c_str()); 11 | #else 12 | return _chdir(目录.c_str()) == 0; 13 | #endif 14 | } 15 | KrnlnApi bool 改变目录(const wstring& 欲改变到的目录) { 16 | #ifdef _WIN32 17 | return SetCurrentDirectoryW(欲改变到的目录.c_str()); 18 | #else 19 | return _wchdir(目录.c_str()) == 0; 20 | #endif 21 | } 22 | -------------------------------------------------------------------------------- /src/磁盘操作/改变驱动器.cpp: -------------------------------------------------------------------------------- 1 | //#include"string" 2 | // 3 | //#ifdef _WIN32 4 | //#include 5 | //#else///Linux,UNIX 6 | //#include 7 | //#define SetCurrentDirectoryW(dir) _wchdir(dir) 8 | //#define SetCurrentDirectoryA(dir) chdir(dir) 9 | //#endif 10 | //using namespace std; 11 | //KrnlnApi bool 改变驱动器(char 欲改变到的驱动器) { 12 | // char DirName[4] = { 欲改变到的驱动器, ':', '\\', 0 };; 13 | // return SetCurrentDirectoryA(DirName); 14 | //} 15 | //KrnlnApi bool 改变驱动器(wchar_t 欲改变到的驱动器) { 16 | // wchar_t DirName[4] = { 欲改变到的驱动器, L':', L'\\', 0 }; 17 | // return SetCurrentDirectoryW(DirName); 18 | //} 19 | // 20 | // 21 | //KrnlnApi bool 改变驱动器(const string& 欲改变到的驱动器) { 22 | // if (!欲改变到的驱动器.empty()) { 23 | // char DirName[4] = { *欲改变到的驱动器.c_str(), ':', '\\', 0 }; 24 | // return SetCurrentDirectoryA(DirName); 25 | // } 26 | // return false; 27 | //} 28 | // 29 | // 30 | //KrnlnApi bool 改变驱动器(const wstring& 欲改变到的驱动器) { 31 | // if (!欲改变到的驱动器.empty()) { 32 | // wchar_t DirName[4] = { *欲改变到的驱动器.c_str(), L':', L'\\', 0 }; 33 | // return SetCurrentDirectoryW(DirName); 34 | // } 35 | // return false; 36 | //} 37 | 38 | 39 | 40 | //对于不支持C++17不再兼容，标准库实现更方便更安全 41 | #include 42 | #include 43 | 44 | namespace fs = std::filesystem; 45 | 46 | KrnlnApi bool 改变驱动器(char drive) { 47 | try { 48 | std::string dir_name = { drive, ':', '/' }; 49 | fs::current_path(dir_name); 50 | return true; 51 | } 52 | catch (const fs::filesystem_error) { 53 | return false; 54 | } 55 | } 56 | 57 | KrnlnApi bool 改变驱动器(wchar_t drive) { 58 | try { 59 | std::wstring dir_name = { drive, L':', L'/' }; 60 | fs::current_path(dir_name); 61 | return true; 62 | } 63 | catch (const fs::filesystem_error) { 64 | return false; 65 | } 66 | } 67 | 68 | KrnlnApi bool 改变驱动器(const std::string& drive) { 69 | if (!drive.empty()) { 70 | try { 71 | std::string dir_name = { drive[0], ':', '/' }; 72 | fs::current_path(dir_name); 73 | return true; 74 | } 75 | catch (const fs::filesystem_error) { 76 | return false; 77 | } 78 | } 79 | return false; 80 | } 81 | 82 | KrnlnApi bool 改变驱动器(const std::wstring& drive) { 83 | if (!drive.empty()) { 84 | try { 85 | std::wstring dir_name = { drive[0], L':', L'/' }; 86 | fs::current_path(dir_name); 87 | return true; 88 | } 89 | catch (const fs::filesystem_error) { 90 | return false; 91 | } 92 | } 93 | return false; 94 | } 95 | 96 | -------------------------------------------------------------------------------- /src/磁盘操作/文件是否存在.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | KrnlnApi bool 文件是否存在(const std::string& file_name) 5 | { 6 | return std::filesystem::exists(file_name); 7 | } 8 | 9 | KrnlnApi bool 文件是否存在(const std::wstring& file_name) 10 | { 11 | return std::filesystem::exists(file_name); 12 | } 13 | -------------------------------------------------------------------------------- /src/磁盘操作/文件更名.cpp: -------------------------------------------------------------------------------- 1 | #define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING 2 | #include 3 | KrnlnApi bool 文件更名(const std::wstring& 欲更名的原文件或目录名, const std::wstring& 欲更改为的现文件或目录名) { 4 | bool success = false; 5 | try 6 | { 7 | std::filesystem::rename(欲更名的原文件或目录名, 欲更改为的现文件或目录名); 8 | success = true; 9 | } 10 | catch (const std::filesystem::filesystem_error) 11 | { 12 | // 文件更名操作失败，抛出异常 13 | } 14 | return success; 15 | } 16 | 17 | KrnlnApi bool 文件更名(const std::string& 欲更名的原文件或目录名, const std::string& 欲更改为的现文件或目录名) { 18 | 19 | bool success = false; 20 | try 21 | { 22 | std::filesystem::rename(欲更名的原文件或目录名, 欲更改为的现文件或目录名); 23 | success = true; 24 | } 25 | catch (const std::filesystem::filesystem_error) 26 | { 27 | // 文件更名操作失败，抛出异常 28 | } 29 | return success; 30 | 31 | } 32 | 33 | 34 | -------------------------------------------------------------------------------- /src/磁盘操作/清空目录.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | KrnlnApi bool 清空目录(const std::string& 要删除文件的目录, const std::string& 文件类型, bool 删除文件夹) 5 | { 6 | 7 | std::string dir = 要删除文件的目录; 8 | if (!dir.empty() && dir.back() != '/' && dir.back() != '\\') 9 | dir += '/'; 10 | 11 | bool success = true; 12 | for (const auto& entry : std::filesystem::directory_iterator(dir)) 13 | { 14 | 15 | if (entry.is_directory() && 删除文件夹)//判断是否为目录 16 | { 17 | 18 | if (!std::filesystem::remove(entry)) 19 | { 20 | success = false; 21 | break; 22 | } 23 | 24 | } 25 | else {//不为目录再判断 26 | if (文件类型 != "" && entry.path().extension().string() != "." + 文件类型)//输入了指定类型不匹配，跳出循环 27 | continue; 28 | else if (!entry.is_directory()) 29 | { 30 | if (!std::filesystem::remove(entry)) 31 | { 32 | success = false; 33 | break; 34 | } 35 | } 36 | } 37 | 38 | 39 | } 40 | 41 | return success; 42 | 43 | } 44 | 45 | 46 | KrnlnApi bool 清空目录(const std::wstring& 要删除文件的目录, const std::wstring& 文件类型, bool 删除文件夹) 47 | { 48 | 49 | std::wstring dir = 要删除文件的目录; 50 | if (!dir.empty() && dir.back() != L'/' && dir.back() != L'\\') 51 | dir += L'/'; 52 | 53 | bool success = true; 54 | for (const auto& entry : std::filesystem::directory_iterator(dir)) 55 | { 56 | 57 | if (entry.is_directory() && 删除文件夹)//判断是否为目录 58 | { 59 | 60 | if (!std::filesystem::remove(entry)) 61 | { 62 | success = false; 63 | break; 64 | } 65 | 66 | } 67 | else {//不为目录再判断 68 | if (文件类型 != L"" && entry.path().extension().wstring() != L"." + 文件类型)//输入了指定类型不匹配，跳出循环 69 | continue; 70 | else if (!entry.is_directory()) 71 | { 72 | if (!std::filesystem::remove(entry)) 73 | { 74 | success = false; 75 | break; 76 | } 77 | } 78 | } 79 | 80 | 81 | } 82 | 83 | return success; 84 | 85 | } -------------------------------------------------------------------------------- /src/磁盘操作/移动文件.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | KrnlnApi bool 移动文件(const std::wstring& 被移动的文件, const std::wstring& 移动到的位置) 3 | { 4 | // 尝试使用 std::filesystem::rename 移动文件,函数没有返回值，仅在失败时抛出异常，实际上更为安全 5 | try 6 | { 7 | std::filesystem::rename(被移动的文件, 移动到的位置); 8 | return true; 9 | } 10 | // 如果 rename 失败，则使用 std::filesystem::copy 和 std::filesystem::remove 实现文件移动 11 | catch (const std::filesystem::filesystem_error&) 12 | { 13 | std::filesystem::copy(被移动的文件, 移动到的位置); 14 | std::filesystem::remove(被移动的文件); 15 | return true; 16 | } 17 | // 如果发生未知异常，则返回 false 18 | catch (...) 19 | { 20 | return false; 21 | } 22 | } 23 | 24 | 25 | 26 | KrnlnApi bool 移动文件(const std::string& 被移动的文件, const std::string& 移动到的位置) 27 | { 28 | // 尝试使用 std::filesystem::rename 移动文件,函数没有返回值，仅在失败时抛出异常，实际上更为安全 29 | try 30 | { 31 | std::filesystem::rename(被移动的文件, 移动到的位置); 32 | return true; 33 | } 34 | // 如果 rename 失败，则使用 std::filesystem::copy 和 std::filesystem::remove 实现文件移动 35 | catch (const std::filesystem::filesystem_error&) 36 | { 37 | std::filesystem::copy(被移动的文件, 移动到的位置); 38 | std::filesystem::remove(被移动的文件); 39 | return true; 40 | } 41 | // 如果发生未知异常，则返回 false 42 | catch (...) 43 | { 44 | return false; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/磁盘操作/置文件属性.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | #include"windows.h" 3 | using namespace std; 4 | 5 | #ifdef _WIN32 6 | KrnlnApi bool 置文件属性(const string& 欲设置其属性的文件名称, int 欲设置为的属性值) { 7 | 8 | 9 | return SetFileAttributesA(欲设置其属性的文件名称.c_str(), 欲设置为的属性值); 10 | 11 | 12 | } 13 | 14 | 15 | KrnlnApi bool 置文件属性(const wstring& 欲设置其属性的文件名称, int 欲设置为的属性值) { 16 | 17 | 18 | return SetFileAttributesW(欲设置其属性的文件名称.c_str(), 欲设置为的属性值); 19 | 20 | 21 | } 22 | #endif // _WIN32 23 | 24 | -------------------------------------------------------------------------------- /src/磁盘操作/置磁盘卷标.cpp: -------------------------------------------------------------------------------- 1 |  2 | 3 | #include 4 | #ifdef _WIN32 5 | #include 6 | 7 | KrnlnApi bool 置磁盘卷标(const std::wstring& drive, const std::wstring& label) { 8 | std::wstring dir_name; 9 | if (drive.empty()) { 10 | wchar_t current_dir[MAX_PATH] = { 0 }; 11 | if (GetCurrentDirectoryW(MAX_PATH, current_dir) == 0) { 12 | return false; 13 | } 14 | dir_name = current_dir; 15 | } 16 | else { 17 | dir_name = drive; 18 | dir_name += L":\\"; 19 | } 20 | return SetVolumeLabelW(dir_name.c_str(), label.c_str()); 21 | } 22 | KrnlnApi bool 置磁盘卷标(const std::string& drive, const std::string& label) { 23 | std::string dir_name; 24 | 25 | if (drive.empty()) { 26 | char current_dir[MAX_PATH] = { 0 }; 27 | if (GetCurrentDirectoryA(MAX_PATH, current_dir) == 0) { 28 | return false; 29 | } 30 | dir_name = current_dir; 31 | } 32 | else { 33 | dir_name = drive; 34 | dir_name += ":\\"; 35 | } 36 | 37 | return SetVolumeLabelA(dir_name.c_str(), label.c_str()); 38 | } 39 | 40 | 41 | KrnlnApi bool 置磁盘卷标(char 磁盘驱动器字符, const std::string& 欲置入的卷标文本) { 42 | char DirName[4] = { 磁盘驱动器字符 ,':','\\','\0' }; 43 | return SetVolumeLabelA(DirName, 欲置入的卷标文本.c_str()); 44 | } 45 | KrnlnApi bool 置磁盘卷标(wchar_t 磁盘驱动器字符, const std::wstring& 欲置入的卷标文本) { 46 | wchar_t DirName[4] = { 磁盘驱动器字符 ,L':',L'\\',L'\0' };; 47 | return SetVolumeLabelW(DirName, 欲置入的卷标文本.c_str()); 48 | } 49 | 50 | #endif // _WIN32 51 | -------------------------------------------------------------------------------- /src/磁盘操作/读入文件.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | KrnlnApi std::vector 读入文件(const std::string& filename) { 6 | std::ifstream file(filename, std::ios::binary); 7 | std::vector data; 8 | 9 | // 如果文件打开成功 10 | if (file) { 11 | // 获取文件长度 12 | file.seekg(0, std::ios::end); 13 | std::streampos length = file.tellg(); 14 | // 重置文件指针到文件开头 15 | file.seekg(0, std::ios::beg); 16 | // 读取整个文件的所有字节到 vector 17 | data.resize((size_t)length); 18 | file.read(reinterpret_cast(&data[0]), length); 19 | } 20 | // 关闭文件 21 | file.close(); 22 | return data; 23 | } 24 | 25 | KrnlnApi std::vector 读入文件(const std::wstring& filename) { 26 | std::ifstream file(filename, std::ios::binary); 27 | std::vector data; 28 | 29 | // 如果文件打开成功 30 | if (file) { 31 | // 获取文件长度 32 | file.seekg(0, std::ios::end); 33 | std::streampos length = file.tellg(); 34 | // 重置文件指针到文件开头 35 | file.seekg(0, std::ios::beg); 36 | // 读取整个文件的所有字节到 vector 37 | data.resize((size_t)length); 38 | file.read(reinterpret_cast(&data[0]), length); 39 | } 40 | // 关闭文件 41 | file.close(); 42 | return data; 43 | } 44 | -------------------------------------------------------------------------------- /src/程序进程/禁止程序重复运行.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #ifdef _WIN32 3 | #include 4 | #else 5 | #include 6 | #endif 7 | 8 | 9 | #ifdef _WIN32 10 | KrnlnApi void 禁止重复运行(const std::wstring& identifier, void(*callback)()) 11 | { 12 | if (OpenEventW(EVENT_ALL_ACCESS, false, identifier.c_str())) { 13 | 14 | if (callback) { 15 | callback(); 16 | } 17 | exit(0); 18 | } 19 | CreateEventW(NULL, false, false, identifier.c_str()); 20 | } 21 | KrnlnApi void 禁止重复运行(const std::string& identifier, void(*callback)()) 22 | { 23 | if (OpenEventA(EVENT_ALL_ACCESS, false, identifier.c_str())) { 24 | 25 | if (callback) { 26 | callback(); 27 | } 28 | exit(0); 29 | } 30 | CreateEventA(NULL, false, false, identifier.c_str()); 31 | } 32 | #else 33 | #include 34 | KrnlnApi void 禁止重复运行(const std::string& identifier, void(*callback)()) 35 | { 36 | std::string lock_file = identifier + ".lock"; 37 | int fd = open(lock_file.c_str(), O_CREAT | O_WRONLY, 0644); 38 | if (fd < 0) { 39 | if (callback) { 40 | callback(); 41 | } 42 | exit(0); 43 | } 44 | if (lockf(fd, F_TLOCK, 0) < 0) { 45 | if (callback) { 46 | callback(); 47 | } 48 | exit(0); 49 | } 50 | } 51 | KrnlnApi void 禁止重复运行(const std::wstring& identifier, void(*callback)()) 52 | { 53 | std::wstring lock_file = identifier + L".lock"; 54 | int fd = wopen(lock_file.c_str(), O_CREAT | O_WRONLY, 0644); 55 | if (fd < 0) { 56 | if (callback) { 57 | callback(); 58 | } 59 | exit(0); 60 | } 61 | if (lockf(fd, F_TLOCK, 0) < 0) { 62 | if (callback) { 63 | callback(); 64 | } 65 | exit(0); 66 | } 67 | } 68 | #endif -------------------------------------------------------------------------------- /src/算数运算/一阶微分.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | /*五点 Runge-Kutta 法*/ 5 | class DifferentialEquationSolver { 6 | private: 7 | double x_known, y_known; 8 | double error_tolerance; 9 | double initial_step_size, min_step_size; 10 | double(*f)(double, double); 11 | public: 12 | DifferentialEquationSolver(double(*fun)(double, double), double x_known, double y_known, double error_tolerance, double initial_step_size, double min_step_size) : 13 | f(fun), x_known(x_known), y_known(y_known), error_tolerance(error_tolerance), initial_step_size(initial_step_size), min_step_size(min_step_size) {} 14 | bool solve(double x, double& y_estimate) { 15 | double step_size = initial_step_size; 16 | while (true) { 17 | double k1 = step_size * f(x_known, y_known); 18 | double k2 = step_size * f(x_known + step_size / 2, y_known + k1 / 2); 19 | double k3 = step_size * f(x_known + step_size / 2, y_known + k2 / 2); 20 | double k4 = step_size * f(x_known + step_size, y_known + k3); 21 | double error_estimate = fabs(k1 / 6 - k2 / 3 + k3 / 3 - k4 / 6); 22 | if (error_estimate < error_tolerance * step_size / 32) { 23 | step_size *= 2; 24 | } 25 | else if (error_estimate > error_tolerance * step_size) { 26 | step_size /= 2; 27 | } 28 | if (step_size < min_step_size) { 29 | return false; 30 | } 31 | x_known += step_size; 32 | y_known += (k1 + k2 + k3 + k4) / 6; 33 | if (x_known >= x) { 34 | y_estimate = y_known; 35 | return true; 36 | } 37 | } 38 | } 39 | }; 40 | 41 | KrnlnApi bool 一阶微分(double(*一阶微分方程)(double, double), double 已知的x值, double 已知的y值, double 要求解的x值, double 允许的误差, double 初始步长, double 最小步长) { 42 | DifferentialEquationSolver solver(一阶微分方程, 已知的x值, 已知的y值, 允许的误差, 初始步长, 最小步长); 43 | double y; 44 | return solver.solve(要求解的x值, y); 45 | } -------------------------------------------------------------------------------- /src/算数运算/取整.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | double __cdecl ProcessDouble1(double a1) 3 | { 4 | double v1; // st7@1 5 | double result; // st7@6 6 | double v3; // [sp+0h] [bp-8h]@1 7 | signed int v4; // [sp+Ch] [bp+4h]@4 8 | 9 | v1 = modf(a1, &v3); 10 | if (v1 < 0.0) 11 | v1 = -v1; 12 | if (v1 <= 0.999999999999) 13 | { 14 | result = a1; 15 | } 16 | else 17 | { 18 | v4 = -1; 19 | if (v3 >= 0.0) 20 | v4 = 1; 21 | result = (double)v4 + v3; 22 | } 23 | return result; 24 | } 25 | 26 | KrnlnApi int 取整(double 数) 27 | { 28 | return (int)floor(ProcessDouble1(数)); 29 | } -------------------------------------------------------------------------------- /src/算数运算/取斐波那契数列项值.cpp: -------------------------------------------------------------------------------- 1 | KrnlnApi int 取斐波那契数列项值(int n) { 2 | if (n == 0 || n == 1) { 3 | return n; // 第0项和第1项都是1 4 | } 5 | 6 | // 否则，第n项等于前两项之和 7 | return 取斐波那契数列项值(n - 1) + 取斐波那契数列项值(n - 2); 8 | } -------------------------------------------------------------------------------- /src/算数运算/取符号.cpp: -------------------------------------------------------------------------------- 1 |  2 | //算术运算 - 取符号 3 | /* 4 | 调用格式： 〈整数型〉 取符号 （双精度小数型 欲取其符号的数值） - 系统核心支持库->算术运算 5 | 英文名称：sgn 6 | 返回一个整数，如果小于零，表明给定数值为负；如果等于零，表明给定数值为零；如果大于零，表明给定数值为正。本命令为初级命令。 7 | 参数<1>的名称为“欲取其符号的数值”，类型为“双精度小数型（double）”。 8 | */ 9 | KrnlnApi int 取符号(double 数) { 10 | int n = 0; 11 | if (数 > 0) 12 | n = 1; 13 | else if (数 < 0) 14 | n = -1; 15 | return n; 16 | } 17 | -------------------------------------------------------------------------------- /src/算数运算/取绝对值.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //算术运算 - 取绝对值 3 | /* 4 | 调用格式： 〈双精度小数型〉 取绝对值 （双精度小数型 欲取其绝对值的数值） - 系统核心支持库->算术运算 5 | 英文名称：abs 6 | 如果所提供数值为字节型，则将直接返回该数值。本命令为初级命令。 7 | 参数<1>的名称为“欲取其绝对值的数值”，类型为“双精度小数型（double）”。 8 | */ 9 | KrnlnApi double 取绝对值(double 数) 10 | { 11 | return std::fabs(数); 12 | 13 | } 14 | -------------------------------------------------------------------------------- /src/算数运算/取随机数.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | KrnlnApi size_t 取随机数(size_t min, size_t max) { 4 | std::random_device rd; 5 | std::mt19937 gen(rd()); 6 | std::uniform_int_distribution dis(min, max); 7 | return dis(gen); 8 | } -------------------------------------------------------------------------------- /src/算数运算/四舍五入.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | inline double _round(double x) 4 | { 5 | return floor(x + 0.5); 6 | } 7 | 8 | 9 | KrnlnApi double 四舍五入(double 欲被四舍五入的值, int 被舍入位置) 10 | { 11 | if (被舍入位置 == 0) 12 | 欲被四舍五入的值 = _round(欲被四舍五入的值); 13 | else if (被舍入位置 > 0) 14 | { 15 | double dbNum = pow((double)10.0, 被舍入位置); 16 | 欲被四舍五入的值 = 欲被四舍五入的值 * dbNum; 17 | 欲被四舍五入的值 = _round(欲被四舍五入的值) / dbNum; 18 | 19 | } 20 | else 21 | { 22 | 被舍入位置 = abs(被舍入位置); 23 | double dbNum = pow((double)10.0, 被舍入位置); 24 | 欲被四舍五入的值 = 欲被四舍五入的值 / dbNum; 25 | 欲被四舍五入的值 = _round(欲被四舍五入的值) * dbNum; 26 | } 27 | return 欲被四舍五入的值; 28 | 29 | } 30 | 31 | -------------------------------------------------------------------------------- /src/算数运算/弧度到角度.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | KrnlnApi double 弧度到角度(double 欲转换的角度值) 5 | { 6 | return (double)欲转换的角度值 * 180 / 3.1415926535; 7 | } -------------------------------------------------------------------------------- /src/算数运算/数值积分计算.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class NumericIntegration 4 | { 5 | private: 6 | double IntegrateBySimpson13(int sampleInterval, double lowerLimit, double upperLimit) { 7 | // Simpson 1/3 法计算积分 8 | 9 | // 计算区间长度 10 | double intervalLength = upperLimit - lowerLimit; 11 | 12 | // 计算步长 13 | double step = intervalLength / sampleInterval; 14 | 15 | double integral = 0.0; 16 | 17 | // 计算所有子区间的积分值并求和 18 | for (int i = 0; i < sampleInterval; i++) 19 | { 20 | double x0 = lowerLimit + i * step; 21 | double x1 = x0 + step; 22 | integral += (Function(x0) + 4 * Function((x0 + x1) / 2) + Function(x1)) * step / 6; 23 | } 24 | 25 | return integral; 26 | }; 27 | double IntegrateBySimpson38(int sampleInterval, double lowerLimit, double upperLimit) 28 | { 29 | // Simpson 3/8 法计算积分 30 | 31 | // 计算区间长度 32 | double intervalLength = upperLimit - lowerLimit; 33 | 34 | // 计算步长 35 | double step = intervalLength / sampleInterval; 36 | 37 | double integral = 0.0; 38 | 39 | // 计算所有子区间的积分值并求和 40 | for (int i = 0; i < sampleInterval; i++) 41 | { 42 | double x0 = lowerLimit + i * step; 43 | double x1 = x0 + step; 44 | integral += (Function(x0) + 3 * Function(x0 + step / 3) + 3 * Function(x0 + 2 * step / 3) + Function(x1)) * step / 8; 45 | } 46 | 47 | return integral; 48 | }; 49 | double(*Function)(double); 50 | public: 51 | double Integrate(double(*F)(double), int sampleInterval, double lowerLimit, double upperLimit) 52 | { 53 | if (!F) 54 | { 55 | return 0; 56 | } 57 | Function = F; 58 | // 使用 Simpson 1/3 法和 Simpson 3/8 法计算积分 59 | return IntegrateBySimpson13(sampleInterval, lowerLimit, upperLimit) + IntegrateBySimpson38(sampleInterval, lowerLimit, upperLimit); 60 | } 61 | }; 62 | 63 | 64 | KrnlnApi int 数值积分计算(double(*函数)(double), int 样本区间, double 积分下限, double 积分上限) 65 | { 66 | NumericIntegration IntegrateVector; 67 | // 调用 Integrate 函数计算积分 68 | return IntegrateVector.Integrate(函数, 样本区间, 积分下限, 积分上限); 69 | } 70 | 71 | 72 | 73 | 74 | 75 | 76 | -------------------------------------------------------------------------------- /src/算数运算/是否素数.cpp: -------------------------------------------------------------------------------- 1 | KrnlnApi bool 是否素数(unsigned long long x) 2 | { 3 | if (x < 2) { 4 | // 小于 2 的数都不是素数 5 | return false; 6 | } 7 | if (x == 2 || x == 3) { 8 | // 2 和 3 是素数 9 | return true; 10 | } 11 | if (x % 2 == 0 || x % 3 == 0) { 12 | // 如果能够被 2 或 3 整除，则不是素数 13 | return false; 14 | } 15 | // 从 5 开始枚举到 sqrt(x)，如果 x 能够被枚举到的数整除，则不是素数 16 | for (unsigned long long i = 5; i * i <= x; i += 6) { 17 | if (x % i == 0 || x % (i + 2) == 0) { 18 | return false; 19 | } 20 | } 21 | // 如果没有被整除，则是素数 22 | return true; 23 | } -------------------------------------------------------------------------------- /src/算数运算/是否运算正确.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | //算术运算 - 是否运算正确 5 | /* 6 | 调用格式： 〈逻辑型〉 是否运算正确 （双精度小数型 欲校验的计算结果） - 系统核心支持库->算术运算 7 | 英文名称：IsCalcOK 8 | 对乘、除、“求次方”、“求平方根”、“求正弦值”、“求余弦值”、“求正切值”、“求反正切值”、“求自然对数”、“求反对数”等等数学运算命令所计算出来的双精度结果数值进行校验，如果该数值正确有效，返回真。如果该数值是运算错误或运算溢出后的结果，返回假。本命令为初级命令。 9 | 参数<1>的名称为“欲校验的计算结果”，类型为“双精度小数型（double）”。 10 | 11 | */ 12 | KrnlnApi bool 是否运算正确(double 欲校验的计算结果) 13 | { 14 | if (_finite(欲校验的计算结果) != 0) 15 | return true; 16 | return false; 17 | 18 | } -------------------------------------------------------------------------------- /src/算数运算/求余弦.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //算术运算 - 求余弦 3 | /* 4 | 调用格式： 〈双精度小数型〉 求余弦 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算 5 | 英文名称：cos 6 | 返回指定角的余弦值。本命令为初级命令。 7 | 参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。 8 | */ 9 | KrnlnApi double 求余弦(double 欲进行计算的角) 10 | { 11 | return std::cos(欲进行计算的角); 12 | 13 | } -------------------------------------------------------------------------------- /src/算数运算/求反对数.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | KrnlnApi double 求反对数(double 欲求其反对数的数值) 5 | { 6 | return std::exp(欲求其反对数的数值); 7 | } -------------------------------------------------------------------------------- /src/算数运算/求反正切.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //调用格式： 〈双精度小数型〉 求反正切 （双精度小数型 欲求其反正切值的数值） - 系统核心支持库->算术运算 3 | //英文名称：atn 4 | //返回指定数的反正切值。本命令为初级命令。 5 | //参数<1>的名称为“欲求其反正切值的数值”，类型为“双精度小数型（double）”。 6 | // 7 | //操作系统需求： Windows、Linux 8 | 9 | KrnlnApi double 求反正切(double 欲进行计算的角) 10 | { 11 | return std::atan(欲进行计算的角); 12 | 13 | } -------------------------------------------------------------------------------- /src/算数运算/求平方根.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //算术运算 - 求平方根 3 | /* 4 | 调用格式： 〈双精度小数型〉 求平方根 （双精度小数型 欲求其平方根的数值） - 系统核心支持库->算术运算 5 | 英文名称：sqr 6 | 返回指定参数的平方根。本命令为初级命令。 7 | 参数<1>的名称为“欲求其平方根的数值”，类型为“双精度小数型（double）”。参数值如果小于零将导致计算错误。 8 | */ 9 | KrnlnApi double 求平方根(double x) 10 | { 11 | double guess = 1.0; 12 | while (fabs(guess * guess - x) > 1e-5) { 13 | guess = (guess + x / guess) / 2.0; 14 | } 15 | return guess; 16 | } -------------------------------------------------------------------------------- /src/算数运算/求次方.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //算术运算 - 求次方 3 | /* 4 | 调用格式： 〈双精度小数型〉 求次方 （双精度小数型 欲求次方数值，双精度小数型 次方数） - 系统核心支持库->算术运算 5 | 英文名称：pow 6 | 返回指定数值的指定次方。本命令为初级命令。 7 | 参数<1>的名称为“欲求次方数值”，类型为“双精度小数型（double）”。参数值指定欲求其某次方的数值。 8 | 参数<2>的名称为“次方数”，类型为“双精度小数型（double）”。参数值指定对欲求次方数值的运算指数。 9 | */ 10 | KrnlnApi double 求次方(double 欲求次方数值, int 次方数) 11 | { 12 | return std::pow(欲求次方数值, 次方数); 13 | } -------------------------------------------------------------------------------- /src/算数运算/求正切.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | /* 调用格式： 〈双精度小数型〉 求正切 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算 3 | 英文名称：tan 4 | 返回指定角的正切值。本命令为初级命令。 5 | 参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。*/ 6 | 7 | KrnlnApi double 求正切(double 欲进行计算的角) 8 | { 9 | return std::tan(欲进行计算的角); 10 | 11 | } -------------------------------------------------------------------------------- /src/算数运算/求正弦.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //算术运算 - 求正弦 3 | /* 4 | 调用格式： 〈双精度小数型〉 求正弦 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算 5 | 英文名称：sin 6 | 返回指定角的正弦值。本命令为初级命令。 7 | 参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。 8 | */ 9 | KrnlnApi double 求正弦(double 欲进行计算的角) 10 | { 11 | return std::sin(欲进行计算的角); 12 | 13 | } -------------------------------------------------------------------------------- /src/算数运算/求自然对数.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //算术运算 - 求自然对数 4 | /* 5 | 调用格式： 〈双精度小数型〉 求自然对数 （双精度小数型 欲求其自然对数的数值） - 系统核心支持库->算术运算 6 | 英文名称：log 7 | 返回指定参数的自然对数值。自然对数是以 e 为底的对数。常量 #e 的值大约是 2.718282。本命令为初级命令。 8 | 参数<1>的名称为“欲求其自然对数的数值”，类型为“双精度小数型（double）”。 9 | */ 10 | KrnlnApi double 求自然对数(double 欲求其自然对数的数值) 11 | { 12 | return std::log(欲求其自然对数的数值); 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/算数运算/绝对取整.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //算术运算 - 绝对取整 3 | 4 | 5 | KrnlnApi int 绝对取整(double x) { 6 | return x < 0.0 ? std::ceil(x) : std::floor(x); 7 | } -------------------------------------------------------------------------------- /src/算数运算/角度到弧度.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | KrnlnApi double 角度到弧度(double 欲转换的角度值) 5 | { 6 | return (double)欲转换的角度值 * 3.1415926535 / 180; 7 | } -------------------------------------------------------------------------------- /src/算数运算/阶乘.cpp: -------------------------------------------------------------------------------- 1 | #pragma warning(disable:26451) 2 | #include 3 | KrnlnApi std::wstring 阶乘(uint64_t x) 4 | { 5 | std::wstring result = L"1"; 6 | for (uint64_t i = 2; i <= x; i++) { 7 | std::wstring tmp = std::to_wstring(i); 8 | int carry = 0; 9 | for (uint64_t j = 0; j < result.size() || j < tmp.size() || carry > 0; j++) { 10 | if (j < result.size()) { 11 | carry += result[result.size() - 1 - j] - L'0'; 12 | } 13 | if (j < tmp.size()) { 14 | carry += tmp[tmp.size() - 1 - j] - L'0'; 15 | } 16 | result[result.size() - 1 - j] = (carry % 10) + L'0'; 17 | carry /= 10; 18 | } 19 | if (carry > 0) { 20 | result = wchar_t(carry + L'0') + result; 21 | } 22 | } 23 | return result; 24 | } 25 | 26 | 27 | KrnlnApi std::wstring 双阶乘(uint64_t x) 28 | { 29 | std::wstring result = L"1"; 30 | for (uint64_t i = 2; i <= x; i += 2) { 31 | std::string tmp = std::to_string(i / (i - 1)); 32 | uint64_t carry = 0; 33 | for (uint64_t j = 0; j < result.size() || j < tmp.size() || carry > 0; j++) { 34 | if (j < result.size()) { 35 | carry += result[result.size() - 1 - j] - L'0'; 36 | } 37 | if (j < tmp.size()) { 38 | carry += tmp[tmp.size() - 1 - j] - L'0'; 39 | } 40 | result[result.size() - 1 - j] = (carry % 10) + L'0'; 41 | carry /= 10; 42 | } 43 | if (carry > 0) { 44 | result = wchar_t(carry + L'0') + result; 45 | } 46 | } 47 | return result; 48 | } -------------------------------------------------------------------------------- /src/系统处理/关闭系统.cpp: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #pragma warning(disable:4996) 3 | #include 4 | // 调整当前进程的权限，使其具有关机、重启、注销系统的权限 5 | static BOOL sSetPrivilege() 6 | { 7 | OSVERSIONINFO osv = { 0 }; 8 | osv.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); 9 | GetVersionEx(&osv); 10 | if (osv.dwPlatformId == VER_PLATFORM_WIN32_NT) 11 | { 12 | HANDLE hToken; 13 | TOKEN_PRIVILEGES tkp; 14 | 15 | if (!OpenProcessToken(GetCurrentProcess(), (TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY), &hToken)) 16 | return FALSE; 17 | 18 | LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid); 19 | 20 | tkp.PrivilegeCount = 1; 21 | tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 22 | AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0); 23 | 24 | if (GetLastError() != ERROR_SUCCESS) 25 | return FALSE; 26 | } 27 | 28 | return TRUE; 29 | } 30 | KrnlnApi bool 关闭系统(int npMode, bool blpForceExit) 31 | { 32 | if (npMode < 1 || npMode > 5 || sSetPrivilege() == FALSE) 33 | return FALSE; 34 | 35 | if (npMode >= 4) 36 | return SetSystemPowerState((npMode == 4), (BOOL)blpForceExit); 37 | 38 | UINT uFlags; 39 | if (npMode == 1) 40 | { 41 | OSVERSIONINFO osv = { 0 }; 42 | osv.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); 43 | GetVersionEx(&osv); 44 | if (osv.dwPlatformId == VER_PLATFORM_WIN32_NT) 45 | uFlags = EWX_POWEROFF; 46 | else 47 | uFlags = EWX_SHUTDOWN; 48 | } 49 | else 50 | { 51 | uFlags = (npMode == 2 ? EWX_REBOOT : EWX_LOGOFF); 52 | } 53 | 54 | if (blpForceExit) 55 | uFlags |= EWX_FORCE; 56 | 57 | return ExitWindowsEx(uFlags, 0); 58 | } 59 | 60 | 61 | 62 | 63 | 64 | #else 65 | 66 | #include 67 | #include 68 | 69 | KrnlnApi bool 关闭系统(int action, bool force) { 70 | char command[64] = ""; 71 | switch (action) { 72 | case 1: 73 | strcpy(command, "shutdown -h now"); 74 | break; 75 | case 2: 76 | strcpy(command, "reboot"); 77 | break; 78 | case 3: 79 | strcpy(command, "pkill -KILL -u $USER"); 80 | break; 81 | case 4: 82 | strcpy(command, "systemctl suspend"); 83 | break; 84 | case 5: 85 | strcpy(command, "systemctl hibernate"); 86 | break; 87 | default: 88 | return false; 89 | } 90 | // 如果 force 为真，则将命令字符串末尾添加 "-f" 91 | if (force) { 92 | strcat(command, " -f"); 93 | } 94 | return system(command) == 0; 95 | } 96 | 97 | #endif 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /src/系统处理/剪辑板中可有文本.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #ifdef _WIN32 4 | #include 5 | #else 6 | //#include 7 | //#include 8 | #include 9 | #endif 10 | 11 | KrnlnApi bool 剪辑板可有文本() 12 | { 13 | #ifdef _WIN32 14 | // Windows version: use Win32 API 15 | BOOL bRet = FALSE; 16 | if (OpenClipboard(NULL)) 17 | { 18 | HANDLE hClip = GetClipboardData(CF_TEXT); 19 | if (hClip) 20 | bRet = TRUE; 21 | CloseClipboard(); 22 | } 23 | return bRet; 24 | #else 25 | // Non-Windows version: use popen to execute "xclip -o -selection clipboard" 26 | std::string command = "xclip -o -selection clipboard"; 27 | FILE* fp = popen(command.c_str(), "r"); 28 | if (fp == nullptr) 29 | return false; 30 | int c = fgetc(fp); 31 | int ret = pclose(fp); 32 | return c != EOF || ret == 0; 33 | 34 | #endif 35 | } -------------------------------------------------------------------------------- /src/系统处理/取屏幕宽度.cpp: -------------------------------------------------------------------------------- 1 | #if defined(_WIN32) 2 | #include 3 | #else 4 | #include 5 | #endif 6 | KrnlnApi int 取屏幕宽度() { 7 | #if defined(_WIN32) 8 | return GetSystemMetrics(SM_CXSCREEN); 9 | #elif defined(__linux__) 10 | const char* widthStr = std::getenv("DISPLAY_WIDTH"); 11 | if (widthStr) { 12 | return std::atoi(widthStr); 13 | } 14 | else { 15 | return 0; 16 | } 17 | #else 18 | // Other operating systems 19 | #endif 20 | } 21 | -------------------------------------------------------------------------------- /src/系统处理/取屏幕高度.cpp: -------------------------------------------------------------------------------- 1 | #if defined(_WIN32) 2 | #include 3 | #else 4 | #include 5 | #endif 6 | KrnlnApi int 取屏幕高度() { 7 | #if defined(_WIN32) 8 | return GetSystemMetrics(SM_CYSCREEN); 9 | #elif defined(__linux__) 10 | const char* heightStr = std::getenv("DISPLAY_HEIGHT"); 11 | if (heightStr) { 12 | return std::atoi(heightStr); 13 | } 14 | else { 15 | // 如果获取失败，则返回0 16 | return 0; 17 | } 18 | #else 19 | // 其他系统 20 | #endif 21 | } 22 | -------------------------------------------------------------------------------- /src/系统处理/延时.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /* 5 | 本命令暂停当前程序的运行并等待指定的时间 6 | 类型变量 <欲等待的时间> 本参数指定欲暂停程序执行的时间，单位为毫秒 7 | */ 8 | KrnlnApi void 延时(int 欲等待的时间) { 9 | if (欲等待的时间 <= 0) { 10 | return; 11 | } 12 | std::this_thread::sleep_for(std::chrono::milliseconds(欲等待的时间)); 13 | } 14 | -------------------------------------------------------------------------------- /src/系统处理/终止进程.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #ifdef _WIN32 4 | #undef UNICODE 5 | #include 6 | #include 7 | #else 8 | #include 9 | #include 10 | #endif 11 | 12 | 13 | 14 | KrnlnApi bool 终止进程(std::wstring process_name_or_window_title) { 15 | // 用于存储进程 ID 的变量 16 | unsigned int process_id = 0; 17 | 18 | #ifdef _WIN32 19 | // 在 Windows 系统上使用 FindWindow 函数查找窗口句柄 20 | HWND window_handle = FindWindowW(0, process_name_or_window_title.c_str()); 21 | if (window_handle) { 22 | GetWindowThreadProcessId(window_handle, (LPDWORD)&process_id); 23 | } 24 | 25 | // 如果找到了窗口句柄，就不需要再枚举进程了 26 | if (process_id == 0) { 27 | // 枚举系统中的所有进程 28 | HANDLE snapshot_handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 29 | if (snapshot_handle == INVALID_HANDLE_VALUE) { 30 | return false; 31 | } 32 | 33 | PROCESSENTRY32W process_entry; 34 | process_entry.dwSize = sizeof(PROCESSENTRY32W); 35 | 36 | // 遍历每一个进程 37 | if (Process32FirstW(snapshot_handle, &process_entry)) { 38 | do { 39 | // 匹配进程名称 40 | if (process_name_or_window_title == std::wstring(process_entry.szExeFile)) { 41 | process_id = process_entry.th32ProcessID; 42 | break; 43 | } 44 | } while (Process32NextW(snapshot_handle, &process_entry)); 45 | } 46 | CloseHandle(snapshot_handle); 47 | } 48 | 49 | 50 | #else 51 | // 在 Linux 系统上使用 ps 命令查找进程 ID 52 | std::wstring command = L"ps -e -o pid,comm | grep " + process_name_or_window_title; 53 | std::FILE* process_id_file = _wpopen(command.c_str(), L"r"); 54 | if (process_id_file) { 55 | std::fscanf(process_id_file, "%d", &process_id); 56 | _pclose(process_id_file); 57 | } 58 | #endif 59 | // 如果没有找到进程 ID，返回 false 60 | if (process_id == 0) { 61 | return false; 62 | } 63 | 64 | // 在 Windows 系统上使用 TerminateProcess 函数终止进程 65 | #ifdef _WIN32 66 | HANDLE process_handle = OpenProcess(PROCESS_TERMINATE, 0, process_id); 67 | bool result = TerminateProcess(process_handle, 0) == TRUE; 68 | return result; 69 | #else 70 | int kill_result = _wsystem((L"kill " + std::to_wstring(process_id)).c_str()); 71 | // 如果 kill 命令返回 0，表示成功终止进程 72 | return kill_result == 0; 73 | #endif 74 | } 75 | KrnlnApi bool 终止进程(std::string process_name_or_window_title) { 76 | // 用于存储进程 ID 的变量 77 | unsigned int process_id = 0; 78 | 79 | #ifdef _WIN32 80 | // 在 Windows 系统上使用 FindWindow 函数查找窗口句柄 81 | HWND window_handle = FindWindowA(0, process_name_or_window_title.c_str()); 82 | if (window_handle) { 83 | GetWindowThreadProcessId(window_handle, (LPDWORD)&process_id); 84 | } 85 | 86 | // 如果找到了窗口句柄，就不需要再枚举进程了 87 | if (process_id == 0) { 88 | // 枚举系统中的所有进程 89 | HANDLE snapshot_handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 90 | if (snapshot_handle == INVALID_HANDLE_VALUE) { 91 | return false; 92 | } 93 | 94 | PROCESSENTRY32 process_entry; 95 | process_entry.dwSize = sizeof(PROCESSENTRY32W); 96 | 97 | // 遍历每一个进程 98 | if (Process32First(snapshot_handle, &process_entry)) { 99 | do { 100 | // 匹配进程名称 101 | if (process_name_or_window_title == std::string(process_entry.szExeFile)) { 102 | process_id = process_entry.th32ProcessID; 103 | break; 104 | } 105 | } while (Process32Next(snapshot_handle, &process_entry)); 106 | } 107 | CloseHandle(snapshot_handle); 108 | } 109 | 110 | 111 | #else 112 | // 在 Linux 系统上使用 ps 命令查找进程 ID 113 | std::string command = "ps -e -o pid,comm | grep " + process_name_or_window_title; 114 | std::FILE* process_id_file = _popen(command.c_str(), "r"); 115 | if (process_id_file) { 116 | std::fscanf(process_id_file, "%d", &process_id); 117 | _pclose(process_id_file); 118 | } 119 | #endif 120 | // 如果没有找到进程 ID，返回 false 121 | if (process_id == 0) { 122 | return false; 123 | } 124 | 125 | // 在 Windows 系统上使用 TerminateProcess 函数终止进程 126 | #ifdef _WIN32 127 | HANDLE process_handle = OpenProcess(PROCESS_TERMINATE, 0, process_id); 128 | bool result = TerminateProcess(process_handle, 0) == TRUE; 129 | return result; 130 | #else 131 | int kill_result = std::system(("kill " + std::to_string(process_id)).c_str()); 132 | // 如果 kill 命令返回 0，表示成功终止进程 133 | return kill_result == 0; 134 | #endif 135 | } 136 | KrnlnApi bool 终止进程(unsigned int process_id) { 137 | if (process_id == 0) 138 | { 139 | return 0; 140 | } 141 | // 在 Windows 系统上使用 TerminateProcess 函数终止进程 142 | #ifdef _WIN32 143 | HANDLE process_handle = OpenProcess(PROCESS_TERMINATE, 0, process_id); 144 | bool result = TerminateProcess(process_handle, 0) == TRUE; 145 | return result; 146 | #else 147 | // 在其他平台上使用 kill 命令终止进程 148 | int kill_result = std::system(("kill " + std::to_string(process_id)).c_str()); 149 | // 如果 kill 命令返回 0，表示成功终止进程 150 | return kill_result == 0; 151 | #endif 152 | } 153 | 154 | 155 | 156 | 157 | -------------------------------------------------------------------------------- /src/网络通信/取本机ip.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #ifdef _WIN32 4 | #include 5 | #pragma comment(lib,"Ws2_32.lib") 6 | #else 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #endif 14 | 15 | 16 | #ifdef _WIN32 17 | 18 | KrnlnApi std::wstring 取本机IPW() { 19 | WORD wVersionRequested = MAKEWORD(2, 2); 20 | WSADATA wsaData; 21 | if (WSAStartup(wVersionRequested, &wsaData) != 0) 22 | return L""; 23 | char local[255] = { 0 }; 24 | gethostname(local, sizeof(local)); 25 | hostent* ph = gethostbyname(local); 26 | if (ph == NULL) 27 | return L""; 28 | in_addr addr; 29 | memcpy(&addr, ph->h_addr_list[0], sizeof(in_addr)); 30 | std::string localIP; 31 | localIP.assign(inet_ntoa(addr)); 32 | WSACleanup(); 33 | int widesize = MultiByteToWideChar(CP_ACP, 0, localIP.c_str(), -1, NULL, 0); 34 | if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION) 35 | { 36 | throw std::exception("Invalid UTF-8 sequence."); 37 | } 38 | if (widesize == 0) 39 | { 40 | throw std::exception("Error in conversion."); 41 | } 42 | wchar_t* resultstring = new wchar_t[widesize]; 43 | 44 | int convresult = MultiByteToWideChar(CP_ACP, 0, localIP.c_str(), -1, resultstring, widesize); 45 | if (convresult != widesize) 46 | { 47 | throw std::exception("La falla!"); 48 | } 49 | std::wstring wstrReturn(resultstring); 50 | delete[] resultstring; 51 | return wstrReturn; 52 | } 53 | 54 | KrnlnApi std::string 取本机IPA() { 55 | WORD wVersionRequested = MAKEWORD(2, 2); 56 | WSADATA wsaData; 57 | if (WSAStartup(wVersionRequested, &wsaData) != 0) 58 | return ""; 59 | char local[255] = { 0 }; 60 | gethostname(local, sizeof(local)); 61 | hostent* ph = gethostbyname(local); 62 | if (ph == NULL) 63 | return ""; 64 | in_addr addr; 65 | memcpy(&addr, ph->h_addr_list[0], sizeof(in_addr)); 66 | std::string localIP; 67 | localIP.assign(inet_ntoa(addr)); 68 | WSACleanup(); 69 | return localIP; 70 | } 71 | 72 | #else 73 | 74 | KrnlnApi std::string 取本机IPA() { 75 | struct addrinfo hints, * info, * p; 76 | int gai_result; 77 | 78 | char hostname[256]; 79 | gethostname(hostname, sizeof(hostname)); 80 | 81 | memset(&hints, 0, sizeof(hints)); 82 | hints.ai_family = AF_UNSPEC; 83 | hints.ai_socktype = SOCK_STREAM; 84 | hints.ai_flags = AI_CANONNAME; 85 | 86 | if ((gai_result = getaddrinfo(hostname, NULL, &hints, &info)) != 0) { 87 | return ""; 88 | } 89 | 90 | for (p = info; p != NULL; p = p->ai_next) { 91 | if (p->ai_family == AF_INET) { 92 | struct sockaddr_in* ipv4 = (struct sockaddr_in*)p->ai_addr; 93 | char ip[INET_ADDRSTRLEN]; 94 | inet_ntop(AF_INET, &(ipv4->sin_addr), ip, INET_ADDRSTRLEN); 95 | freeaddrinfo(info); 96 | return ip; 97 | } 98 | else if (p->ai_family == AF_INET6) { 99 | struct sockaddr_in6* ipv6 = (struct sockaddr_in6*)p->ai_addr; 100 | char ip[INET6_ADDRSTRLEN]; 101 | inet_ntop(AF_INET6, &(ipv6->sin6_addr), ip, INET6_ADDRSTRLEN); 102 | freeaddrinfo(info); 103 | return ip; 104 | } 105 | } 106 | 107 | freeaddrinfo(info); 108 | return ""; 109 | } 110 | 111 | std::wstring 取本机IPW() { 112 | std::wstring_convert> converter; 113 | std::string local_ip = 取本机IPA(); 114 | return converter.from_bytes(local_ip); 115 | } 116 | 117 | 118 | #endif 119 | 120 | 121 | -------------------------------------------------------------------------------- /src/网络通信/取本机名.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #ifdef _WIN32 3 | #include 4 | #pragma comment(lib,"Ws2_32.lib") 5 | #else 6 | #include 7 | #endif 8 | 9 | 10 | 11 | KrnlnApi std::string 取本机名() 12 | { 13 | char name[260] = { 0 }; 14 | if (gethostname(name, 260) == 0) 15 | { 16 | return std::string(name); 17 | } 18 | else 19 | { 20 | return std::string(); 21 | } 22 | } -------------------------------------------------------------------------------- /src/网络通信/打开指定网址.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | using namespace std; 5 | 6 | KrnlnApi void 打开指定网址(const string& url) 7 | { 8 | #ifdef _WIN32 9 | const string OPEN_COMMAND = "start "; 10 | #elif __APPLE__ 11 | const string OPEN_COMMAND = "open "; 12 | #else 13 | const string OPEN_COMMAND = "xdg-open "; 14 | #endif 15 | string command = OPEN_COMMAND + url; 16 | system(command.c_str()); 17 | } 18 | KrnlnApi void 打开指定网址(const wstring& url) 19 | { 20 | #ifdef _WIN32 21 | const wstring OPEN_COMMAND = L"start "; 22 | #elif APPLE 23 | const wstring OPEN_COMMAND = L"open "; 24 | #else 25 | const wstring OPEN_COMMAND = L"xdg-open "; 26 | #endif 27 | wstring command = OPEN_COMMAND + url; 28 | _wsystem(command.c_str()); 29 | } 30 | 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /src/逻辑比较/文本对比.cpp: -------------------------------------------------------------------------------- 1 | #include"STRING" 2 | using namespace std; 3 | KrnlnApi bool 文本对比(string 文本1, string 文本2) 4 | { 5 | int result = 0; 6 | size_t strsize = 文本1.size(); 7 | const char* s1 = 文本1.c_str(); 8 | const char* s2 = 文本2.c_str(); 9 | if (strsize <= 文本2.size()) 10 | { 11 | result = strncmp(s1, s2, strsize); 12 | return result == 0; 13 | } 14 | return false; 15 | } 16 | KrnlnApi bool 文本对比(wstring 文本1, wstring 文本2) 17 | { 18 | int result = 0; 19 | size_t strsize = 文本1.size(); 20 | const wchar_t* s1 = 文本1.c_str(); 21 | const wchar_t* s2 = 文本2.c_str(); 22 | if (strsize <= 文本2.size()) 23 | { 24 | result = wcsncmp(s1, s2, strsize); 25 | return result == 0; 26 | } 27 | return false; 28 | } -------------------------------------------------------------------------------- /src/逻辑比较/近似等于.cpp: -------------------------------------------------------------------------------- 1 | #include"string" 2 | using namespace std; 3 | //逻辑比较 - 近似等于 4 | /* 5 | 调用格式： 〈逻辑型〉 近似等于 （文本型 被比较文本，文本型 比较文本） - 系统核心支持库->逻辑比较 6 | 英文名称：like 7 | 当比较文本在被比较文本的首部被包容时返回真，否则返回假，运算符号为“?=”或“≈”。本命令为初级命令。 8 | 参数<1>的名称为“被比较文本”，类型为“文本型（text）”。 9 | 参数<2>的名称为“比较文本”，类型为“文本型（text）”。 10 | */ 11 | KrnlnApi bool 近似等于(string 被比较文本, string 比较文本) 12 | { 13 | char* str1; 14 | char* str2; 15 | if (被比较文本.empty()) { 16 | str1 = 0; 17 | } 18 | else { 19 | str1 = const_cast(被比较文本.c_str()); 20 | } 21 | if (比较文本.empty()) { 22 | str2 = 0; 23 | } 24 | else { 25 | str2 = const_cast(比较文本.c_str()); 26 | } 27 | 28 | if (!str1 || !str2 || !*str1 || !*str2) return false; //空文本直接返回 29 | 30 | while (*str1 && *str2 && *str1 == *str2) 31 | str1++, str2++; 32 | return *str2 == 0; 33 | } 34 | 35 | 36 | KrnlnApi bool 近似等于(wstring 被比较文本, wstring 比较文本) 37 | { 38 | wchar_t* str1; 39 | wchar_t* str2; 40 | if (被比较文本.empty()) { 41 | str1 = 0; 42 | } 43 | else { 44 | str1 = const_cast(被比较文本.c_str()); 45 | } 46 | if (比较文本.empty()) { 47 | str2 = 0; 48 | } 49 | else { 50 | str2 = const_cast(比较文本.c_str()); 51 | } 52 | 53 | if (!str1 || !str2 || !*str1 || !*str2) return false; //空文本直接返回 54 | 55 | while (*str1 && *str2 && *str1 == *str2) 56 | str1++, str2++; 57 | return *str2 == 0; 58 | } 59 | KrnlnApi bool 约等于(wstring 参1, wstring 参2) 60 | { 61 | 62 | size_t 计次; 63 | wchar_t 是否不为结束符; 64 | bool result; 65 | const wchar_t* 参数1 = 参1.c_str(); 66 | const wchar_t* 参数2 = 参2.c_str(); 67 | 68 | if (参数1 && 参数2 && *参数1 && *参数2) 69 | { 70 | 计次 = 参数1 - 参数2; 71 | do 72 | { 73 | if (!*参数2) 74 | break; 75 | if (参数2[计次] != *参数2) 76 | break; 77 | 是否不为结束符 = (参数2++)[计次 + 1]; 78 | } while (是否不为结束符); 79 | result = *参数2 == 0; 80 | } 81 | else 82 | { 83 | result = 0; 84 | } 85 | 86 | return result; 87 | } 88 | KrnlnApi bool 约等于(string 参1, string 参2) 89 | { 90 | 91 | size_t 计次; 92 | char 是否不为结束符; 93 | bool result; 94 | const char* 参数1 = 参1.c_str(); 95 | const char* 参数2 = 参2.c_str(); 96 | 97 | if (参数1 && 参数2 && *参数1 && *参数2) 98 | { 99 | 计次 = 参数1 - 参数2; 100 | do 101 | { 102 | if (!*参数2) 103 | break; 104 | if (参数2[计次] != *参数2) 105 | break; 106 | 是否不为结束符 = (参数2++)[计次 + 1]; 107 | } while (是否不为结束符); 108 | result = *参数2 == 0; 109 | } 110 | else 111 | { 112 | result = 0; 113 | } 114 | 115 | return result; 116 | } --------------------------------------------------------------------------------