my_function.h
1 #pragma once
2 #include <iostream>
3 #include <cstdarg>
4 #include <list>
5 #include <vector>
6 #include <bitset>
7 #include <cstdlib>
8
9 #ifndef MY_FUNCTION_H_
10 #define MY_FUNCTION_H_
11 namespace MY_TOOLS {
12 /*
13 * 专用于输入double类型的变量；处理用户输入，确保用户输入的是合法数字；对于数字和字符混合的输入，数字在前的读取数字，后续的字符丢弃；若是字符在前，则要求重新输入
14 * 返回int值EXIT_SUCCESS
15 * result_int：用于存放用户输入的整型数字，double*指针，对应的存放空间必须在调用之前分配好；
16 * hint_str：const char*指针，用于提示输入的字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
17 * error_message：在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
18 */
19 int in_double(double& result_int, const char* hint_str, const char* error_message = {});
20 /*
21 * 处理用户输入，只处理char字符数组；
22 * result_str：char*指针，用于存放用户输入的字符，对应的存放空间必须在调用之前分配好；
23 * len：无符号整型，用于指定result_str最多能存储多少个字符（不包括NULL），也就是说，若是result_str能存放10个字符，那么len最多只能传递9；len的最大允许范围为0~(UINT_MAX-1)
24 * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
25 * error_message：const char*指针，在用户输入错误的情况下（长度过长，或者输入为空），提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
26 * 输入成功会返回EXIT_SUCCESS
27 * 在len的值等于UINT_MAX时会返回EXIT_FAILURE
28 */
29 int in_charArray(char* result_str, unsigned int len, const char* hint_str, const char* error_message = {});
30 /*
31 * 处理用户输入，专用于输入单个字符；对于输入了多个字符的输入，只取第一个字符，后续字符全部丢弃
32 * result_str：char*指针，用于存放用户输入的字符，对应的存放空间必须在调用之前分配好；
33 * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
34 * error_message：const char*指针，在用户输入错误的情况下（长度过长，或者输入为空），提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
35 * 输入成功会返回EXIT_SUCCESS
36 * 在len的值等于UINT_MAX时会返回EXIT_FAILURE
37 */
38 int in_char(char& result_char, const char* hint_str, const char* error_message = {});
39 /*
40 * 处理用户输入，专用于输入单个宽字符；对于输入了多个字符的输入，只取第一个字符，后续字符全部丢弃
41 * result_str：char*指针，用于存放用户输入的字符，对应的存放空间必须在调用之前分配好；
42 * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
43 * error_message：const char*指针，在用户输入错误的情况下（长度过长，或者输入为空），提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
44 * 输入成功会返回EXIT_SUCCESS
45 * 在len的值等于UINT_MAX时会返回EXIT_FAILURE
46 */
47 int in_wchar_t(wchar_t& result_char, const wchar_t* hint_str, const wchar_t* error_message = {});
48 /*
49 * in_uint：处理用户输入，确保用户输入的是正整数；
50 * result_int：用于存放用户输入的整型数字，unsigned int*指针，对应的存放空间必须在调用之前分配好；
51 * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
52 * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
53 */
54 int in_uint(unsigned int& result_int, const char* hint_str, const char* error_message = {});
55 /*
56 * in_int：处理用户输入，确保用户输入的是整数；
57 * result_int：用于存放用户输入的整型数字，int*指针，对应的存放空间必须在调用之前分配好；
58 * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
59 * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
60 */
61 int in_int(int& result_int, const char* hint_str, const char* error_message = {});
62 /*
63 * in_long：处理用户输入，确保用户输入的是整数；
64 * result_int：用于存放用户输入的整型数字，int*指针，对应的存放空间必须在调用之前分配好；
65 * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
66 * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
67 */
68 long in_long(long& result_int, const char* hint_str, const char* error_message = {});
69 /*
70 * 函数功能：简单实现类似于python 中的format功能；该函数将会重载，以适应不同的情况；
71 * 注意，你需要保证，args不定数量参数中的每个参数都要为const char*类型；
72 * 注意：你需要保证，str中的{}数量与args中参数的数量对应，否则会触发未定义行为。
73 * 使用示例：std::cout << MY_IN::format("我的名字：{}。{}", "aaa","今天阳光明媚！\n");
74 */
75 std::string format(const std::string str, ...);
76 /*
77 * 注意：宽字符版本format实现很有难度，这里没有实现，建议使用对应的swprintf
78 * 函数功能：简单实现类似于python 中的format功能；该函数将会重载，以适应不同的情况；
79 * 注意，你需要保证，args不定数量参数中的每个参数都要为const wchar_t*类型；
80 * 注意：你需要保证，str中的{}数量与args中参数的数量对应，否则会触发未定义行为。
81 * 使用示例：std::wcout << MY_IN::format(L"我的名字：{}。{}", L"aaa",L"今天阳光明媚！\n");
82 */
83 std::wstring format(const wchar_t* str, ...);
84
85 /*
86 * in_uint_scope：处理用户输入，确保用户输入的是正整数，且输入的值处于指定范围内；
87 * result_int： 用于存放用户输入的整型数字，unsigned int*指针，对应的存放空间必须在调用之前分配好；
88 * start_num: 范围的起始值，若是start_num大于等于end_num，函数将抛出异常（ L"起始值大于等于截止值！"）
89 * end_num: 范围的结束值，范围将包含该结束值；
90 * hint_str：const char*指针，提示字符串的地址，用于提示用户的输入，字符串建议在结尾处添加换行符；
91 * error_message：const char*指针，在用户输入错误的情况下，提示用户的信息字符串的地址，可以为空，为空则不提示，字符串建议在结尾处添加换行符
92 */
93 int in_uint_scope(unsigned int& result_int, unsigned int start_num, unsigned int end_num, const char* hint_str, const char* error_message = {});
94 /*
95 * 变大写，将给定的wstring、string、char数组、wchar_t数组里面的字母变为大写字母
96 * 直接修改原来的变量
97 * 目前只支持char和wchar_t类型的字符
98 * value：需要变大写的变量，引用方式
99 * start_index：从哪里开始修改
100 * numberOfChar：修改多少个字符
101 */
102 template<typename T>
103 void toUppercase(T& value, unsigned start_index, unsigned numberOfChar) {
104 //判断是哪种字符
105 if (sizeof(value[0]) == sizeof(char)) {
106 for (unsigned i = start_index; i < numberOfChar; i++) {
107 value[i] = toupper(value[i]);
108 }
109 }
110 else if (sizeof(value[0]) == sizeof(wchar_t)) {
111 for (unsigned i = start_index; i < numberOfChar; i++) {
112 value[i] = towupper(value[i]);
113 }
114 }
115 else {
116 ;
117 }
118 }
119
120 /*string字符串分割函数：split
121 * 返回list对象
122 * value：表示被分割的字符串
123 * character：分隔符
124 * len：字符串长度
125 */
126 std::list<std::string>split(std::string& value, char character, unsigned len);
127 /*wstring字符串分割函数：split
128 * 返回list对象
129 * value：表示被分割的字符串
130 * character：分隔符
131 * len：字符串长度
132 */
133 std::list<std::wstring>split(std::wstring& value, wchar_t character, unsigned len);
134 /*wstring字符串分割函数：split_vector：返回类型为vector
135 * 返回vector对象
136 * value：表示被分割的字符串
137 * character：分隔符
138 * len：字符串长度
139 */
140 std::vector<std::wstring>split_vector(std::wstring& value, wchar_t character, unsigned len);
141 /*wstring字符串分割函数：split_vector：返回类型为vector
142 * 返回vector对象
143 * value：表示被分割的字符串，传递wchar_t*类型
144 * character：分隔符
145 * len：字符串长度
146 */
147 std::vector<std::wstring>split_vector(const wchar_t* value, wchar_t character, unsigned len);
148 /*返回list对象的第几个值
149 * 若是下标越界，将返回一个默认初始化的T对象，同时将is_success置为false
150 * List：list对象
151 * index：下标，从0开始
152 * is_success：执行是否成功；输出参数
153 */
154 template<typename T>
155 const T list_at(std::list<T> List, unsigned index,bool * is_success = nullptr) {
156 if (index >= List.size()) {
157 if (is_success) {
158 *is_success = false;
159 }
160 return T{};
161 }
162 else {
163 T ret{};
164 unsigned i{};
165 for (auto & v:List) {
166 if (i == index) {
167 ret = v;
168 break;
169 }
170 i++;
171 }
172 return ret;
173 }
174 }
175 /*保留两位小数
176 * 数字字符串保留两位小数
177 * str：数字字符串
178 * num：保留小数的位数，默认为2
179 * isCarry：是否进位，默认尝试进位
180 * 分为两种方式，一个是尝试进位的方式保留两位小数，另外一种是不管能否进位，直接截断，以达到保留两位小数的目的，若是原字符串长度不够，比如传递过来0.9这样的，那么会原样返回。
181 */
182 std::wstring two_decimal_places(const std::wstring& str, unsigned num = 2, bool isCarry = true);
183 /*检查给定值是否在后者中；若是存在，则返回给定值所在的下标（从0开始），否则返回-1
184 * T1元素位于T2中，比如：T1是int，那么T2应该是stl中的某种容器，比如vector<int>
185 */
186 template<typename T1, typename T2>
187 int isExist(T1 t1, T2 t2) {
188 bool flag{};
189 int index{};
190 for(auto &v:t2){
191 if (t1 == v) {
192 flag = true;
193 return index;
194 }
195 index++;
196 }
197 if (!flag) {
198 return -1;
199 }
200 else {
201 return index;
202 }
203 }
204 /*
205 * wstring版本的replace函数，主要是实现在给定的范围内，将replaced_str替换成value_str，is_all表示是否替换所有的replaced_str；
206 * 注：是直接在源字符串上操作；
207 * str：源字符串
208 * first：size_t，指向开始范围；
209 * strLen：size_t，范围的长度；
210 * replaced_str：被替换的字符（串）
211 * value_str：目标字符（串）
212 * is_all：为true时表示替换给定范围内的所有replaced_str；为false的时候表示只替换一次（如果存在匹配）；
213 */
214 std::wstring& replace(std::wstring& str, size_t first, size_t strLen, const std::wstring replaced_str, const std::wstring value_str, bool is_all);
215 /*
216 * 循环左移函数：将数字类型的变量类型（int,long,long long等）的二进制循环左移
217 * 注：只针对基础类型，不支持对象类型
218 * source：被循环左移的变量
219 * num：循环的位数，你应该确保num小于source的二进制位数
220 */
221 template<typename T>
222 T ring_shift_left(T source, int num) {
223 int binary_len = sizeof(T) * 8;
224 if (binary_len == num) {
225 return source;
226 }
227 else if(binary_len < num)
228 {
229 num = num % binary_len;
230 }
231
232 T a = source << num;
233 T b = source >> (binary_len - num);
234 T result = a | b;
235 return result;
236 }
237
238 /*
239 * vector<char>转为string
240 */
241 std::string vecChar_to_string(std::vector<char>& source);
242 /*
243 * vector<unsigned char>转为string
244 */
245 std::string vecUChar_to_string(std::vector<unsigned char>& source);
246 }
247
248 #endif // !MY_FUNCTION_H_
View Code
my_function.cpp
1 #include "my_function.h"
2 #include <iostream>
3 #include <string>
4
5 namespace MY_TOOLS {
6 int in_double(double& result_int, const char* hint_str, const char* error_message) {
7 double a;
8 while (true)
9 {
10 std::cout << hint_str;
11
12 if (std::cin >> a) {
13 std::cin.get(); //cin不处理回车符
14 result_int = a;
15 break;
16 }
17 else {
18 if (nullptr != error_message) {
19 std::cout << error_message;
20 }
21 std::cin.clear();
22 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
23 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
24 // 通过 numeric_limits 模板的特化提供此信息。
25 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
26 }
27 }
28 return EXIT_SUCCESS;
29 }
30 int in_charArray(char* result_str, unsigned int len, const char* hint_str, const char* error_message) {
31 std::string a;
32 if (UINT_MAX == len) {
33 std::cout << "参数len的值为UINT_MAX！";
34 return EXIT_FAILURE;
35 }
36 while (true)
37 {
38 std::cout << hint_str;
39
40 if (std::getline(std::cin, a)) {
41 if (a.size() <= len) {
42 const char* b = a.c_str();
43 strncpy_s(result_str, len + 1, b, len);
44 /*
45 * errno_t strncpy_s( char *strDest, size_t numberOfElements, const char *strSource, size_t count);
46 * 函数在内部处理的时候，会因为要保留NULL字符，将numberOfElements减去1，就是说，numberOfElements最小值应该为2，否则就会触发参数无效异常
47 */
48 *(result_str + len) = NULL;
49 break;
50 }
51 else {
52 if (nullptr == error_message) {
53 std::cout << "你输入的字符串太长了，超过了" << len << "。重新输入。" << std::endl;
54 a = "";
55 }
56 else {
57 std::cout << error_message;
58 a = "";
59 }
60
61 }
62 }
63 else {
64 //对于输入字符类型，这个应该是有点多余的。
65 std::cin.clear();
66 //std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行 ,但是若是输入缓冲区为空，就会阻塞，等待缓冲区有值才会执行。
67 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
68 // 通过 numeric_limits 模板的特化提供此信息。
69 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
70 }
71 }
72 return EXIT_SUCCESS;
73 }
74 int in_uint(unsigned int& result_int, const char* hint_str, const char* error_message) {
75 long long a;
76 while (true)
77 {
78 std::cout << hint_str;
79
80 if (std::cin >> a) {
81 std::cin.get(); //cin不处理回车符
82 if (a >= 0 && a <= UINT_MAX) {
83 result_int = static_cast<unsigned int>(a);
84 break;
85 }
86 }
87 else {
88 std::cin.clear();
89 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
90 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
91 // 通过 numeric_limits 模板的特化提供此信息。
92 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
93 }
94 if (nullptr == error_message) {
95 std::cout << "请输入正整数！\n";
96 }
97 else {
98 std::cout << error_message;
99 }
100 }
101 return EXIT_SUCCESS;
102 }
103 int in_int(int& result_int, const char* hint_str, const char* error_message) {
104 int a;
105 while (true)
106 {
107 std::cout << hint_str;
108
109 if (std::cin >> a) {
110 result_int = a;
111 std::cin.get(); //cin不处理回车符
112 break;
113 }
114 else {
115 std::cin.clear();
116 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
117 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
118 // 通过 numeric_limits 模板的特化提供此信息。
119 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
120 }
121 if (nullptr == error_message) {
122 std::cout << "请输入整数！";
123 }
124 else {
125 std::cout << error_message;
126 }
127 }
128 return EXIT_SUCCESS;
129 }
130 std::string format(const std::string str, ...) {
131 va_list args;
132 va_start(args, str);
133 std::string result_str = str;
134 size_t index = result_str.find("{}",0);
135 const char* value{};
136 while (index !=std::string::npos)
137 {
138 value = va_arg(args, const char*);
139
140 result_str.replace(index, 2, value);
141
142 index = result_str.find("{}",0);
143 }
144 va_end(args);
145
146 return result_str;
147 }
148
149 long in_long(long& result_int, const char* hint_str, const char* error_message) {
150 long a;
151 while (true)
152 {
153 std::cout << hint_str;
154
155 if (std::cin >> a) {
156 result_int = a;
157 std::cin.get(); //cin不处理回车符
158 break;
159 }
160 else {
161 std::cin.clear();
162 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
163 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
164 // 通过 numeric_limits 模板的特化提供此信息。
165 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
166 }
167 if (nullptr == error_message) {
168 std::cout << "请输入整数！";
169 }
170 else {
171 std::cout << error_message;
172 }
173 }
174 return EXIT_SUCCESS;
175 }
176 int in_uint_scope(unsigned int& result_int, unsigned int start_num, unsigned int end_num, const char* hint_str, const char* error_message) {
177 if (start_num < end_num) {
178 unsigned int a;
179 while (true)
180 {
181 std::cout << hint_str;
182 if (std::cin >> a) {
183 if (start_num <= a && a <= end_num) {
184 result_int = a;
185 std::cin.get(); //cin不处理回车符
186 break;
187 }
188 else {
189 std::wcout << L"输入的值应该大于等于" << start_num << L"小于等于" << end_num << L"！\n";
190 std::cin.get(); //cin不处理回车符
191 continue;
192 }
193 }
194 else {
195 std::cin.clear();
196 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
197 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
198 // 通过 numeric_limits 模板的特化提供此信息。
199 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
200 }
201 if (nullptr == error_message) {
202 std::cout << "请输入整数！";
203 }
204 else {
205 std::cout << error_message;
206 }
207 }
208 return EXIT_SUCCESS;
209 }
210 else {
211 throw L"起始值大于等于截止值！";
212 //std::wcout << L"起始值大于等于截止值！" << std::endl;
213 return EXIT_SUCCESS;
214 }
215 }
216 int in_char(char& result_char, const char* hint_str, const char* error_message) {
217 std::string a;
218 while (true)
219 {
220 std::cout << hint_str;
221
222 if (std::getline(std::cin,a)) {
223 result_char = a[0];
224 break;
225 }
226 else {
227 std::cin.clear();
228 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
229 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
230 // 通过 numeric_limits 模板的特化提供此信息。
231 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
232 }
233 if (nullptr == error_message) {
234 std::cout << "请输入！";
235 }
236 else {
237 std::cout << error_message;
238 }
239 }
240 return EXIT_SUCCESS;
241 }
242 int in_wchar_t(wchar_t& result_char, const wchar_t* hint_str, const wchar_t* error_message ) {
243 std::wstring a;
244 while (true)
245 {
246 std::wcout << hint_str;
247
248 if (std::getline(std::wcin, a)) {
249 a += L'\n'; //不能丢弃换行符，因为有时候就是需要它。
250 result_char = a[0];
251 break;
252 }
253 else {
254 std::cin.clear();
255 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');//清除输入缓冲区的当前行
256 //numeric_limits:numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
257 // 通过 numeric_limits 模板的特化提供此信息。
258 //streamsize：类型 std::streamsize 是用于表示 I/O 操作中转移字符数或 I/O 缓冲区的大小，是有符号整数类型。
259 }
260 if (nullptr == error_message) {
261 std::wcout << L"请输入！";
262 }
263 else {
264 std::wcout << error_message;
265 }
266 }
267 return EXIT_SUCCESS;
268 }
269 std::list<std::string>split(std::string& value, char character, unsigned len) {
270 std::list<std::string> ret;
271 unsigned start_index{}, end_index{};
272 for (unsigned i{}; i < len; i++) {
273 end_index = i;
274 if (value[i] == character) {
275 ret.push_back(value.substr(start_index, end_index - start_index));
276 start_index = end_index + 1;
277 }
278 }
279 ret.push_back(value.substr(start_index, value.size() - start_index));
280 return ret;
281 }
282 std::list<std::wstring>split(std::wstring& value, wchar_t character, unsigned len) {
283 std::list<std::wstring> ret;
284 unsigned start_index{}, end_index{};
285 for (unsigned i{}; i < len; i++) {
286 end_index = i;
287 if (value[i] == character) {
288 ret.push_back(value.substr(start_index, end_index - start_index));
289 start_index = end_index + 1;
290 }
291 }
292 ret.push_back(value.substr(start_index, value.size() - start_index));
293 return ret;
294 }
295 std::vector<std::wstring>split_vector(std::wstring& value, wchar_t character, unsigned len) {
296 std::vector<std::wstring> ret;
297 unsigned start_index{}, end_index{};
298 for (unsigned i{}; i < len; i++) {
299 end_index = i;
300 if (value[i] == character) {
301 ret.push_back(value.substr(start_index, end_index - start_index));
302 start_index = end_index + 1;
303 }
304 }
305 ret.push_back(value.substr(start_index, value.size() - start_index));
306 return ret;
307 }
308 std::vector<std::wstring>split_vector(const wchar_t* value, wchar_t character, unsigned len) {
309 std::vector<std::wstring> ret;
310 unsigned start_index{}, end_index{};
311 std::wstring value_str = value;
312 for (unsigned i{}; i < len; i++) {
313 end_index = i;
314 if (value[i] == character) {
315 ret.push_back(value_str.substr(start_index, end_index - start_index));
316 start_index = end_index + 1;
317 }
318 }
319 ret.push_back(value_str.substr(start_index, value_str.size() - start_index));
320 return ret;
321 }
322 std::wstring two_decimal_places(const std::wstring& str, unsigned num, bool isCarry) {
323 std::wstring cost = str;
324
325 size_t str_index = cost.find('.');
326 if (str_index != std::wstring::npos) {
327 if (isCarry) {
328 if ((str_index + num + 1) < cost.size()) {
329 //长度足够
330 //尝试进位
331 if (cost[str_index + num + 1] > L'4') {
332 //进位
333 bool is_carry{}; //是否需要最终进位，比如99.99进位到100.00；true表示要
334 std::wstring cost_ = cost.substr(0, str_index + num + 1);
335 for (auto rend = cost_.rbegin(); rend < cost_.rend(); rend++) {
336 if (*rend == L'9') {
337 *rend = L'0';
338 is_carry = true;
339 }
340 else {
341 is_carry = false;
342 *rend = ++(*rend);
343 cost = cost_;
344 break;
345 }
346 }
347 if (is_carry) {
348 cost = L'1' + cost_;
349 }
350 }
351 else {
352 //直接截断，保留两位小数
353 cost = cost.substr(0, str_index + 3);
354 }
355 }
356 else {
357 //长度不足
358 ;
359 }
360 }
361 else{
362 if ((str_index + num + 1) < cost.size()) {
363 cost = cost.substr(0, str_index + 3);
364 }
365 }
366 }
367 return cost;
368 }
369
370 std::wstring& replace(std::wstring& str, size_t first, size_t strLen, const std::wstring replaced_str, const std::wstring value_str, bool is_all) {
371
372 std::wstring result = str.substr(first, strLen);
373 if (is_all) {
374 size_t index{};
375 index = result.find(replaced_str, index);
376 unsigned int replaced_str_len = replaced_str.size();
377 while (index != std::wstring::npos)
378 {
379 result.replace(index, replaced_str_len, value_str);
380 index += value_str.length(); //主要是为了防止出现循环替换的情况
381 index = result.find(replaced_str, index);
382 }
383 str.replace(first, strLen, result);
384 return str;
385 }
386 else {
387 size_t index = result.find(replaced_str);
388 if (index != std::wstring::npos) {
389 unsigned int replaced_str_len = replaced_str.size();
390 result.replace(index, replaced_str_len, value_str);
391 str.replace(first, strLen, result);
392 }
393 return str;
394 }
395 }
396 std::string vecChar_to_string(std::vector<char>& source) {
397 std::string ret;
398 for (auto& v : source) {
399 ret += static_cast<char>(v);
400 }
401 return ret;
402 }
403 std::string vecUChar_to_string(std::vector<unsigned char>& source) {
404 std::string ret;
405 for (auto& v : source) {
406 ret += static_cast<unsigned char>(v);
407 }
408 return ret;
409 }
410 }
View Code
不定期更新。
标签：std,index,函数,自定义,int,C++,char,value,str From： https://www.cnblogs.com/love-DanDan/p/16720275.html