C++ number.h更新

bin554385863

1. 构造函数:
   
2. //默认构造
   
3. numbers():numsLen(0), numsPtr(nullptr){}
   
4. //使用C风格数字数组构造
   
5. numbers(const tp *arr, const size_t arrSize);
   
6. //字符数组构造
   
7. numbers(const char *ncstr)------2019年11月24日22:35:17增加
   
8. //可变参数构造
   
9. numbers(std::initializer_list<tp> list);
   
10. //拷贝构造
    
11. numbers(const numbers<tp>& nums);
    
12. 注意:使用时请按规范输入数字或者数字字符数组,不然出现数据错误;
    
13. "-566666"---正确;
    
14. "*55555"---错误;*号会转化成错误数据;
    
15. 除了-号请不要再数字字符前添加任何字符包括+号;
    
16. 
    
17. ****************************************************
    
18. 成员函数
    
19. 
    
20. at()(为了方便this指针使用,普通对象请使用索引符[]):
    
21. 按索引获取数字串的元素;
    
22. 按索引修改元素的值;
    
23. 
    
24. size():
    
25. 获取对象的大小
    
26. ****************************************************
    
27. 重载运算符
    
28. 
    
29. [](改)
    
30. 安索引修改对象元素的值;
    
31. 
    
32. +(增):
    
33. 添加元素;
    
34. 合并对象;
    
35. 
    
36. -(删)
    
37. 删除对象中指定的数据;
    
38. 删除父对象中与子对象相同的数据;
    
39. 按索引删除元素参数必须显示声明为size_t类型
    
40. 对象翻转数据的正负属性;------2019年11月24日22:35:32增加
    
41. 
    
42. %(查)
    
43. 判断对象是否包含某数据;
    
44. 判断子对象是否父对象的子串;
    
45. 
    
46. /(查):
    
47. 返回数据在对象中出现的次数;
    
48. 返回对象与对象相同的元素;
    
49. 
    
50. 赋值运算符:
    
51. 
    
52. +=
    
53. /=
    
54. -=
    
55. 右边必须是可改变的对象;
    

复制代码

1---增加数字字符数组构造函数:
    numbers(const char* ncstr);

1. template <typename tp>
   
2. numbers<tp>::numbers(const char *ncstr)
   
3. {
   
4.     std::string tstr = ncstr;
   
5.     if (ncstr[0] == '-')
   
6.     {
   
7.         numsLen = tstr.size() - 1;
   
8.         numsPtr = new tp[numsLen];
   
9.         tstr.erase(0, 1);
   
10.         for (size_t i = 0; i < numsLen; i++)
    
11.         {
    
12.             *(numsPtr + i) = tstr[i] - '0';
    
13.         }
    
14.     }
    
15.     if(ncstr[0] != '-')
    
16.     {
    
17.         numsLen = tstr.size();
    
18.         numsPtr = new tp[numsLen];
    
19.         for (size_t i = 0; i < numsLen; i++)
    
20.         {
    
21.             *(numsPtr + i) = tstr[i] - '0';
    
22.         }
    
23.     }
    
24. }

复制代码

2---增加翻转对象数据正负符号重载:
    numbers<tp> operator-(void) const;

1. template <typename tp>
   
2. numbers<tp> numbers<tp>::operator-(void) const
   
3. {
   
4.     numbers<tp> r_nums;
   
5.     for (size_t i = 0; i < numsLen; i++)
   
6.     {
   
7.         r_nums += -*(numsPtr + i);
   
8.     }
   
9.     return r_nums;
   
10. }

复制代码

完整代码
numbers.h

1. #ifndef NUMBERS_H
   
2. #define NUMBERS_H
   
3. #include <iostream>
   
4. #include <initializer_list>
   
5. #include <string>
   
6. template <typename tp>
   
7. class numbers
   
8. {
   
9. private:
   
10.     size_t numsLen;
    
11.     tp *numsPtr;
    
12. public:
    
13.     //1--默认构造
    
14.     numbers() : numsLen(0), numsPtr(nullptr) {}
    
15.     //2--使用C风格数字数组构造
    
16.     numbers(const tp *arr, const size_t arrSize);
    
17.     //2*--char数字字符串构造
    
18.     numbers(const char* ncstr);
    
19.     //3--可变参数构造
    
20.     numbers(std::initializer_list<tp> list);
    
21.     //4--拷贝构造
    
22.     numbers(const numbers<tp> &nums);
    
23.     /*--------------------------------------------------------*/
    
24.     //5--按索引获取元素;按索引修改元素的值
    
25.     tp &at(const size_t index) const;
    
26.     //6--对象的大小
    
27.     size_t const size() const;
    
28.     /*--------------------------------------------------------*/
    
29.     //7--重载下标运算符
    
30.     tp &operator[](const size_t index) const;
    
31.     //8--深度拷贝
    
32.     numbers<tp> &operator=(const numbers<tp> &nums);
    
33.     //9--重载流运算符<<
    
34.     friend std::ostream &operator<<(std::ostream &os, const numbers<tp> &nums)
    
35.     {
    
36.         size_t sz = nums.size();
    
37.         for (size_t i = 0; i < sz; i++)
    
38.         {
    
39.             os << nums[i];
    
40.         }
    
41.         return os;
    
42.     }
    
43.     /*--------------------------------------------------------*/
    
44.     //10--添加元素
    
45.     numbers<tp> operator+(const tp num) const;
    
46.     numbers<tp>& operator+=(const tp num)
    
47.     {
    
48.         *this = *this + num;
    
49.         return *this;
    
50.     }
    
51.     //11--合并对象
    
52.     numbers<tp> operator+(const numbers<tp> &nums) const;
    
53.     numbers<tp>& operator+=(const numbers<tp> &nums)
    
54.     {
    
55.         *this = *this + nums;
    
56.         return *this;
    
57.     }
    
58.     /*--------------------------------------------------------*/
    
59.     //12--判断数据在对象中存在
    
60.     bool operator%(const tp num) const;
    
61.     //13--判断子对象是否父对象的子串
    
62.     bool operator%(const numbers<tp>& nums) const;
    
63.     /*--------------------------------------------------------*/
    
64.     //14--返回数据出现的次数
    
65.     size_t operator/(tp num) const;
    
66.     //15--返回两个对象共同的元素
    
67.     numbers<tp> operator/(const numbers<tp> &nums) const;
    
68.     //15-1返回并赋值
    
69.     numbers<tp> operator/=(const numbers<tp> &nums)
    
70.     {
    
71.         *this = *this / nums;
    
72.         return *this;
    
73.     }
    
74.     /*--------------------------------------------------------*/
    
75.     //16--删除元素
    
76.     numbers<tp> operator-(const tp num) const;
    
77.     numbers<tp> operator-=(const tp num)
    
78.     {
    
79.         *this = *this - num;
    
80.         return *this;
    
81.     }
    
82.     //17--删除父对象中与子对象中重复的元素
    
83.     numbers<tp> operator-(const numbers<tp> &nums) const;
    
84.     numbers<tp> operator-=(const numbers<tp> &nums)
    
85.     {
    
86.         *this = *this - nums;
    
87.         return *this;
    
88.     }
    
89.     //18--按索引删除元素(数据必须显示声明size_t类型)失败返回空串
    
90.     numbers<tp> operator-(const size_t index) const;
    
91.     numbers<tp> operator-=(const size_t index)
    
92.     {
    
93.         *this = *this - this->at(index);
    
94.         return *this;
    
95.     }
    
96.     //19-翻转数据的正负
    
97.     numbers<tp> operator-(void) const;
    
98.     /*--------------------------------------------------------*/
    
99.     ~numbers()
    
100.     {
     
101.         delete[] numsPtr;
     
102.     }
     
103. };
     
104. //2--使用C风格数字数组构造
     
105. template <typename tp>
     
106. numbers<tp>::numbers(const tp *arr, const size_t arrSize) : numsLen(arrSize)
     
107. {
     
108.     numsPtr = new tp[numsLen];
     
109.     for (size_t i = 0; i < numsLen; i++)
     
110.     {
     
111.         *(numsPtr + i) = *(arr + i);
     
112.     }
     
113. }
     
114. //char字符串构造
     
115. template <typename tp>
     
116. numbers<tp>::numbers(const char *ncstr)
     
117. {
     
118.     std::string tstr = ncstr;
     
119.     if (ncstr[0] == '-')
     
120.     {
     
121.         numsLen = tstr.size() - 1;
     
122.         numsPtr = new tp[numsLen];
     
123.         tstr.erase(0, 1);
     
124.         for (size_t i = 0; i < numsLen; i++)
     
125.         {
     
126.             *(numsPtr + i) = tstr[i] - '0';
     
127.         }
     
128.     }
     
129.     if(ncstr[0] != '-')
     
130.     {
     
131.         numsLen = tstr.size();
     
132.         numsPtr = new tp[numsLen];
     
133.         for (size_t i = 0; i < numsLen; i++)
     
134.         {
     
135.             *(numsPtr + i) = tstr[i] - '0';
     
136.         }
     
137.     }
     
138. }
     
139. //3--可变参数构造
     
140. template <typename tp>
     
141. numbers<tp>::numbers(std::initializer_list<tp> list) : numsLen(list.size())
     
142. {
     
143.     numsPtr = new tp[numsLen];
     
144.     for (size_t i = 0; i < numsLen; i++)
     
145.     {
     
146.         *(numsPtr + i) = *(list.begin() + i);
     
147.     }
     
148. }
     
149. //4--拷贝构造
     
150. template <typename tp>
     
151. numbers<tp>::numbers(const numbers<tp> &nums)
     
152. {
     
153.     if (nums.numsPtr != nullptr)
     
154.     {
     
155.         numsLen = nums.numsLen;
     
156.         numsPtr = new tp[numsLen];
     
157.         for (size_t i = 0; i < numsLen; i++)
     
158.         {
     
159.             *(numsPtr + i) = *(nums.numsPtr + i);
     
160.         }
     
161.     }
     
162.     else
     
163.     {
     
164.         numsLen = 0;
     
165.         numsPtr = nullptr;
     
166.     }
     
167.    
     
168. }
     
169. /*--------------------------------------------------------------------*/
     
170. //5--按索引获取元素;按索引修改元素的值
     
171. template <typename tp>
     
172. inline tp &numbers<tp>::at(const size_t index) const
     
173. {
     
174.     return numsPtr[index];
     
175. }
     
176. //6--对象的大小
     
177. template <typename tp>
     
178. inline const size_t numbers<tp>::size() const
     
179. {
     
180.     return numsLen;
     
181. }
     
182. /*--------------------------------------------------------*/
     
183. //7--重载下标运算符
     
184. template <typename tp>
     
185. inline tp &numbers<tp>::operator[](const size_t index) const
     
186. {
     
187.     return numsPtr[index];
     
188. }
     
189. /*--------------------------------------------------------*/
     
190. //8--深度拷贝
     
191. template <typename tp>
     
192. numbers<tp> &numbers<tp>::operator=(const numbers<tp> &nums)
     
193. {
     
194.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))//非空串的深度拷贝
     
195.     {
     
196.         numsLen = nums.numsLen;
     
197.         delete[] numsPtr;
     
198.         numsPtr = new tp[numsLen];
     
199.         for (size_t i = 0; i < numsLen; i++)
     
200.         {
     
201.             *(numsPtr + i) = *(nums.numsPtr + i);
     
202.         }
     
203.     }
     
204.     if((numsPtr == nullptr)&&(nums.numsPtr != nullptr))//调用对象为空,操作对象非空
     
205.     {
     
206.         numsLen = nums.numsLen;
     
207.         numsPtr = new tp[numsLen];
     
208.         for (size_t i = 0; i < nums.numsLen; i++)
     
209.         {
     
210.             this->at(i) = *(nums.numsPtr + i);
     
211.         }
     
212.     }
     
213.     if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))//调用对象非空,操作对象为空
     
214.     {
     
215.         numsLen = 0;
     
216.         delete [] numsPtr;
     
217.         numsPtr = nullptr;
     
218.     }
     
219.    
     
220.     return *this;
     
221. }
     
222. /*--------------------------------------------------------*/
     
223. //10--添加元素
     
224. template <typename tp>
     
225. numbers<tp> numbers<tp>::operator+(const tp num) const
     
226. {
     
227.     numbers<tp> r_nums;
     
228.     if (numsPtr != nullptr)
     
229.     {
     
230.         r_nums = *this;
     
231.         tp *t_numsPtr = new tp[numsLen + 1];
     
232.         for (size_t i = 0; i < numsLen; i++)
     
233.         {
     
234.             *(t_numsPtr + i) = this->at(i);
     
235.         }
     
236.         *(t_numsPtr + numsLen) = num;
     
237.         r_nums.numsLen++;
     
238.         delete[] r_nums.numsPtr;
     
239.         r_nums.numsPtr = t_numsPtr;
     
240.     }
     
241.     else
     
242.     {
     
243.         r_nums.numsLen = 1 + numsLen;
     
244.         r_nums.numsPtr = new tp[numsLen + 1]{num};
     
245.     }
     
246. 
     
247.     return r_nums;
     
248. }
     
249. //11--合并对象
     
250. template <typename tp>
     
251. numbers<tp> numbers<tp>::operator+(const numbers<tp> &nums) const
     
252. {
     
253.     numbers<tp> t_nums;
     
254.     if (numsPtr != nullptr)
     
255.     {
     
256.         t_nums = *this;
     
257.         for (size_t i = 0; i < nums.numsLen; i++)
     
258.         {
     
259.             t_nums = t_nums + *(nums.numsPtr + i);
     
260.         }
     
261.     }
     
262.     else
     
263.     {
     
264.         t_nums = nums;
     
265.     }
     
266. 
     
267.     return t_nums;
     
268. }
     
269. /*--------------------------------------------------------*/
     
270. //12--判断数据在对象中是否存在
     
271. template <typename tp>
     
272. bool numbers<tp>::operator%(const tp num) const
     
273. {
     
274.     bool flag = false;
     
275.     if (numsPtr != nullptr)
     
276.     {
     
277.         for (size_t i = 0; i < numsLen; i++)
     
278.         {
     
279.             if (num == *(numsPtr + i))
     
280.             {
     
281.                 flag = true;
     
282.                 break;
     
283.             }
     
284.         }
     
285.     }
     
286.     return flag;
     
287. }
     
288. //13--判断子对象是否父对象的子串
     
289. template <typename tp>
     
290. bool numbers<tp>::operator%(const numbers<tp> &nums) const
     
291. {
     
292.     bool flag = false;
     
293.     size_t count = 1;
     
294.     if (numsLen > nums.numsLen)
     
295.     {
     
296.         for (size_t i = 0; i < nums.numsLen; i++)
     
297.         {
     
298.             if ((*this) % (*(nums.numsPtr + i)))
     
299.             {
     
300.                 count++;
     
301.                 if (count == nums.numsLen)
     
302.                 {
     
303.                     break;
     
304.                 }
     
305.             }
     
306.         }
     
307.         if (count == nums.numsLen)
     
308.         {
     
309.             flag = true;
     
310.         }
     
311.     }
     
312.     if (nums.numsPtr == 0)
     
313.     {
     
314.         flag = true;
     
315.     }
     
316.     return flag;
     
317. }
     
318. /*--------------------------------------------------------*/
     
319. //14--返回数据出现的次数
     
320. template <typename tp>
     
321. size_t numbers<tp>::operator/(tp num) const
     
322. {
     
323.     size_t count = 0;
     
324.     if (numsPtr != nullptr)
     
325.     {
     
326.         for (size_t i = 0; i < numsLen; i++)
     
327.         {
     
328.             if (this->at(i) == num)
     
329.             {
     
330.                 count++;
     
331.             }
     
332.         }
     
333.     }
     
334.     return count;
     
335. }
     
336. //15--返回两个对象共同的元素
     
337. template <typename tp>
     
338. numbers<tp> numbers<tp>::operator/(const numbers<tp> &nums) const
     
339. {
     
340.     numbers<tp> r_nums;
     
341.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
     
342.     {
     
343.         for (size_t i = 0; i < nums.numsLen; i++)
     
344.         {
     
345.             if ((*this)% (*(nums.numsPtr + i)))
     
346.             {
     
347.                 r_nums += (*(nums.numsPtr + i));
     
348.             }
     
349.         }
     
350.     }
     
351.     return r_nums;
     
352. }
     
353. /*--------------------------------------------------------*/
     
354. //16--删除对象中符合条件的元素
     
355. template <typename tp>
     
356. numbers<tp> numbers<tp>::operator-(const tp num) const
     
357. {
     
358.     numbers<tp> r_nums;
     
359.     if (numsPtr != nullptr)
     
360.     {
     
361.         for (size_t i = 0; i < numsLen; i++)
     
362.         {
     
363.             if (this->at(i) != num)
     
364.             {
     
365.                 r_nums += *(numsPtr + i);
     
366.             }
     
367.         }
     
368.     }
     
369.     return r_nums;
     
370. }
     
371. //17--删除父对象中与子对象中重复的元素
     
372. template <typename tp>
     
373. numbers<tp> numbers<tp>::operator-(const numbers<tp>& nums) const
     
374. {
     
375.     numbers<tp> r_nums;
     
376.     size_t count = 0;
     
377.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
     
378.     /*两个非空数字串*/
     
379.     {
     
380.         r_nums = *this;
     
381.         for (size_t i = 0; i < nums.numsLen; i++)
     
382.         {
     
383.             if ((*this)%(*(nums.numsPtr + i)))
     
384.             {
     
385.                 r_nums = r_nums - *(nums.numsPtr + i);   
     
386.             }     
     
387.         }
     
388.         if (r_nums.numsLen == 0)
     
389.         {
     
390.             delete [] r_nums.numsPtr;
     
391.             r_nums.numsPtr = nullptr;
     
392.         }
     
393.     }
     
394.     else if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))
     
395.     /*子串为空*/
     
396.     {
     
397.         r_nums = *this;
     
398.     }
     
399.     return r_nums;
     
400. }
     
401. //18--按索引删除元素(数据必须是size_t类型)失败返回空串
     
402. template <typename tp>
     
403. numbers<tp> numbers<tp>::operator-(const size_t index) const
     
404. {
     
405.     numbers<tp> r_nums;
     
406.     if ((index < numsLen ) && (numsPtr != nullptr))
     
407.     {
     
408.         for (size_t i = 0; i < index; i++)
     
409.         {
     
410.             r_nums = r_nums + *(numsPtr + i);
     
411.         }
     
412.         for (size_t i = index + 1; i < numsLen; i++)
     
413.         {
     
414.             r_nums = r_nums + *(numsPtr + i);
     
415.         }
     
416.     }
     
417.     return r_nums;
     
418. }
     
419. //19-翻转数据的正负
     
420. template <typename tp>
     
421. numbers<tp> numbers<tp>::operator-(void) const
     
422. {
     
423.     numbers<tp> r_nums;
     
424.     for (size_t i = 0; i < numsLen; i++)
     
425.     {
     
426.         r_nums += -*(numsPtr + i);
     
427.     }
     
428.     return r_nums;
     
429. }
     
430. #endif

复制代码

bin554385863

2019年11月24日23:36:39
-----增加私有函数
void isnumbers(std::string& str);

1. //判断是否是数字字符串
   
2. template <typename tp>
   
3. void numbers<tp>::isnumbers(const std::string &str)
   
4. {
   
5.     size_t s = str.size();
   
6.     bool flag = true;
   
7.     if (str[0] != '-' && (!isdigit(str[0])))
   
8.     {
   
9.         flag = false;
   
10.     }
    
11.     if (str[0] == '-' || (isdigit(str[0])))
    
12.     {
    
13.         for (size_t i = 1; i < s; i++)
    
14.         {
    
15.             if(!isdigit(str[i]))
    
16.             {
    
17.                 flag = false;
    
18.                 std::cerr<<"Cannot convert to a valid number!"<<std::endl;
    
19.                 exit(1);
    
20.             }
    
21.         }
    
22.         
    
23.     }
    
24. }

复制代码

numbers.h

1. #ifndef NUMBERS_H
   
2. #define NUMBERS_H
   
3. #include <iostream>
   
4. #include <initializer_list>
   
5. #include <string>
   
6. #include <cctype>
   
7. template <typename tp>
   
8. class numbers
   
9. {
   
10. private:
    
11.     size_t numsLen;
    
12.     tp *numsPtr;
    
13.     void isnumbers(const std::string& str);
    
14. public:
    
15.     //1--默认构造
    
16.     numbers() : numsLen(0), numsPtr(nullptr) {}
    
17.     //2--使用C风格数字数组构造
    
18.     numbers(const tp *arr, const size_t arrSize);
    
19.     //2*--char数字字符串构造
    
20.     numbers(const char* ncstr);
    
21.     //3--可变参数构造
    
22.     numbers(std::initializer_list<tp> list);
    
23.     //4--拷贝构造
    
24.     numbers(const numbers<tp> &nums);
    
25.     /*--------------------------------------------------------*/
    
26.     //5--按索引获取元素;按索引修改元素的值
    
27.     tp &at(const size_t index) const;
    
28.     //6--对象的大小
    
29.     size_t const size() const;
    
30.     /*--------------------------------------------------------*/
    
31.     //7--重载下标运算符
    
32.     tp &operator[](const size_t index) const;
    
33.     //8--深度拷贝
    
34.     numbers<tp> &operator=(const numbers<tp> &nums);
    
35.     //9--重载流运算符<<
    
36.     friend std::ostream &operator<<(std::ostream &os, const numbers<tp> &nums)
    
37.     {
    
38.         size_t sz = nums.size();
    
39.         for (size_t i = 0; i < sz; i++)
    
40.         {
    
41.             os << nums[i];
    
42.         }
    
43.         return os;
    
44.     }
    
45.     /*--------------------------------------------------------*/
    
46.     //10--添加元素
    
47.     numbers<tp> operator+(const tp num) const;
    
48.     numbers<tp>& operator+=(const tp num)
    
49.     {
    
50.         *this = *this + num;
    
51.         return *this;
    
52.     }
    
53.     //11--合并对象
    
54.     numbers<tp> operator+(const numbers<tp> &nums) const;
    
55.     numbers<tp>& operator+=(const numbers<tp> &nums)
    
56.     {
    
57.         *this = *this + nums;
    
58.         return *this;
    
59.     }
    
60.     /*--------------------------------------------------------*/
    
61.     //12--判断数据在对象中存在
    
62.     bool operator%(const tp num) const;
    
63.     //13--判断子对象是否父对象的子串
    
64.     bool operator%(const numbers<tp>& nums) const;
    
65.     /*--------------------------------------------------------*/
    
66.     //14--返回数据出现的次数
    
67.     size_t operator/(tp num) const;
    
68.     //15--返回两个对象共同的元素
    
69.     numbers<tp> operator/(const numbers<tp> &nums) const;
    
70.     //15-1返回并赋值
    
71.     numbers<tp> operator/=(const numbers<tp> &nums)
    
72.     {
    
73.         *this = *this / nums;
    
74.         return *this;
    
75.     }
    
76.     /*--------------------------------------------------------*/
    
77.     //16--删除元素
    
78.     numbers<tp> operator-(const tp num) const;
    
79.     numbers<tp> operator-=(const tp num)
    
80.     {
    
81.         *this = *this - num;
    
82.         return *this;
    
83.     }
    
84.     //17--删除父对象中与子对象中重复的元素
    
85.     numbers<tp> operator-(const numbers<tp> &nums) const;
    
86.     numbers<tp> operator-=(const numbers<tp> &nums)
    
87.     {
    
88.         *this = *this - nums;
    
89.         return *this;
    
90.     }
    
91.     //18--按索引删除元素(数据必须显示声明size_t类型)失败返回空串
    
92.     numbers<tp> operator-(const size_t index) const;
    
93.     numbers<tp> operator-=(const size_t index)
    
94.     {
    
95.         *this = *this - this->at(index);
    
96.         return *this;
    
97.     }
    
98.     //19-翻转数据的正负
    
99.     numbers<tp> operator-(void) const;
    
100.     /*--------------------------------------------------------*/
     
101.     ~numbers()
     
102.     {
     
103.         delete[] numsPtr;
     
104.     }
     
105. };
     
106. 
     
107. //判断是否是数字字符串
     
108. template <typename tp>
     
109. void numbers<tp>::isnumbers(const std::string &str)
     
110. {
     
111.     size_t s = str.size();
     
112.     bool flag = true;
     
113.     if (str[0] != '-' && (!isdigit(str[0])))
     
114.     {
     
115.         flag = false;
     
116.     }
     
117.     if (str[0] == '-' || (isdigit(str[0])))
     
118.     {
     
119.         for (size_t i = 1; i < s; i++)
     
120.         {
     
121.             if(!isdigit(str[i]))
     
122.             {
     
123.                 flag = false;
     
124.                 std::cerr<<"Cannot convert to a valid number!"<<std::endl;
     
125.                 exit(1);
     
126.             }
     
127.         }
     
128.         
     
129.     }
     
130. }
     
131. //2--使用C风格数字数组构造
     
132. template <typename tp>
     
133. numbers<tp>::numbers(const tp *arr, const size_t arrSize) : numsLen(arrSize)
     
134. {
     
135.     numsPtr = new tp[numsLen];
     
136.     for (size_t i = 0; i < numsLen; i++)
     
137.     {
     
138.         *(numsPtr + i) = *(arr + i);
     
139.     }
     
140. }
     
141. //char字符串构造
     
142. template <typename tp>
     
143. numbers<tp>::numbers(const char *ncstr)
     
144. {
     
145.     std::string tstr = ncstr;
     
146.     isnumbers(tstr);
     
147.     if (tstr[0] == '-')
     
148.     {
     
149.         size_t s = tstr.size();
     
150.         numsLen = tstr.size() - 1;
     
151.         numsPtr = new tp[numsLen];
     
152.         tstr.erase(0, 1);
     
153.         for (size_t i = 0; i < numsLen; i++)
     
154.         {
     
155.             *(numsPtr + i) = '0' - tstr[i];
     
156.         }
     
157.     }
     
158.     else if (isdigit(tstr[0]))
     
159.     {
     
160.         numsLen = tstr.size();
     
161.         numsPtr = new tp[numsLen];
     
162.         for (size_t i = 0; i < numsLen; i++)
     
163.         {
     
164.             *(numsPtr + i) = tstr[i] - '0';
     
165.         }
     
166.     }
     
167. }
     
168. //3--可变参数构造
     
169. template <typename tp>
     
170. numbers<tp>::numbers(std::initializer_list<tp> list) : numsLen(list.size())
     
171. {
     
172.     numsPtr = new tp[numsLen];
     
173.     for (size_t i = 0; i < numsLen; i++)
     
174.     {
     
175.         *(numsPtr + i) = *(list.begin() + i);
     
176.     }
     
177. }
     
178. //4--拷贝构造
     
179. template <typename tp>
     
180. numbers<tp>::numbers(const numbers<tp> &nums)
     
181. {
     
182.     if (nums.numsPtr != nullptr)
     
183.     {
     
184.         numsLen = nums.numsLen;
     
185.         numsPtr = new tp[numsLen];
     
186.         for (size_t i = 0; i < numsLen; i++)
     
187.         {
     
188.             *(numsPtr + i) = *(nums.numsPtr + i);
     
189.         }
     
190.     }
     
191.     else
     
192.     {
     
193.         numsLen = 0;
     
194.         numsPtr = nullptr;
     
195.     }
     
196.    
     
197. }
     
198. /*--------------------------------------------------------------------*/
     
199. //5--按索引获取元素;按索引修改元素的值
     
200. template <typename tp>
     
201. inline tp &numbers<tp>::at(const size_t index) const
     
202. {
     
203.     return numsPtr[index];
     
204. }
     
205. //6--对象的大小
     
206. template <typename tp>
     
207. inline const size_t numbers<tp>::size() const
     
208. {
     
209.     return numsLen;
     
210. }
     
211. /*--------------------------------------------------------*/
     
212. //7--重载下标运算符
     
213. template <typename tp>
     
214. inline tp &numbers<tp>::operator[](const size_t index) const
     
215. {
     
216.     return numsPtr[index];
     
217. }
     
218. /*--------------------------------------------------------*/
     
219. //8--深度拷贝
     
220. template <typename tp>
     
221. numbers<tp> &numbers<tp>::operator=(const numbers<tp> &nums)
     
222. {
     
223.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))//非空串的深度拷贝
     
224.     {
     
225.         numsLen = nums.numsLen;
     
226.         delete[] numsPtr;
     
227.         numsPtr = new tp[numsLen];
     
228.         for (size_t i = 0; i < numsLen; i++)
     
229.         {
     
230.             *(numsPtr + i) = *(nums.numsPtr + i);
     
231.         }
     
232.     }
     
233.     if((numsPtr == nullptr)&&(nums.numsPtr != nullptr))//调用对象为空,操作对象非空
     
234.     {
     
235.         numsLen = nums.numsLen;
     
236.         numsPtr = new tp[numsLen];
     
237.         for (size_t i = 0; i < nums.numsLen; i++)
     
238.         {
     
239.             this->at(i) = *(nums.numsPtr + i);
     
240.         }
     
241.     }
     
242.     if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))//调用对象非空,操作对象为空
     
243.     {
     
244.         numsLen = 0;
     
245.         delete [] numsPtr;
     
246.         numsPtr = nullptr;
     
247.     }
     
248.    
     
249.     return *this;
     
250. }
     
251. /*--------------------------------------------------------*/
     
252. //10--添加元素
     
253. template <typename tp>
     
254. numbers<tp> numbers<tp>::operator+(const tp num) const
     
255. {
     
256.     numbers<tp> r_nums;
     
257.     if (numsPtr != nullptr)
     
258.     {
     
259.         r_nums = *this;
     
260.         tp *t_numsPtr = new tp[numsLen + 1];
     
261.         for (size_t i = 0; i < numsLen; i++)
     
262.         {
     
263.             *(t_numsPtr + i) = this->at(i);
     
264.         }
     
265.         *(t_numsPtr + numsLen) = num;
     
266.         r_nums.numsLen++;
     
267.         delete[] r_nums.numsPtr;
     
268.         r_nums.numsPtr = t_numsPtr;
     
269.     }
     
270.     else
     
271.     {
     
272.         r_nums.numsLen = 1 + numsLen;
     
273.         r_nums.numsPtr = new tp[numsLen + 1]{num};
     
274.     }
     
275. 
     
276.     return r_nums;
     
277. }
     
278. //11--合并对象
     
279. template <typename tp>
     
280. numbers<tp> numbers<tp>::operator+(const numbers<tp> &nums) const
     
281. {
     
282.     numbers<tp> t_nums;
     
283.     if (numsPtr != nullptr)
     
284.     {
     
285.         t_nums = *this;
     
286.         for (size_t i = 0; i < nums.numsLen; i++)
     
287.         {
     
288.             t_nums = t_nums + *(nums.numsPtr + i);
     
289.         }
     
290.     }
     
291.     else
     
292.     {
     
293.         t_nums = nums;
     
294.     }
     
295. 
     
296.     return t_nums;
     
297. }
     
298. /*--------------------------------------------------------*/
     
299. //12--判断数据在对象中是否存在
     
300. template <typename tp>
     
301. bool numbers<tp>::operator%(const tp num) const
     
302. {
     
303.     bool flag = false;
     
304.     if (numsPtr != nullptr)
     
305.     {
     
306.         for (size_t i = 0; i < numsLen; i++)
     
307.         {
     
308.             if (num == *(numsPtr + i))
     
309.             {
     
310.                 flag = true;
     
311.                 break;
     
312.             }
     
313.         }
     
314.     }
     
315.     return flag;
     
316. }
     
317. //13--判断子对象是否父对象的子串
     
318. template <typename tp>
     
319. bool numbers<tp>::operator%(const numbers<tp> &nums) const
     
320. {
     
321.     bool flag = false;
     
322.     size_t count = 1;
     
323.     if (numsLen > nums.numsLen)
     
324.     {
     
325.         for (size_t i = 0; i < nums.numsLen; i++)
     
326.         {
     
327.             if ((*this) % (*(nums.numsPtr + i)))
     
328.             {
     
329.                 count++;
     
330.                 if (count == nums.numsLen)
     
331.                 {
     
332.                     break;
     
333.                 }
     
334.             }
     
335.         }
     
336.         if (count == nums.numsLen)
     
337.         {
     
338.             flag = true;
     
339.         }
     
340.     }
     
341.     if (nums.numsPtr == 0)
     
342.     {
     
343.         flag = true;
     
344.     }
     
345.     return flag;
     
346. }
     
347. /*--------------------------------------------------------*/
     
348. //14--返回数据出现的次数
     
349. template <typename tp>
     
350. size_t numbers<tp>::operator/(tp num) const
     
351. {
     
352.     size_t count = 0;
     
353.     if (numsPtr != nullptr)
     
354.     {
     
355.         for (size_t i = 0; i < numsLen; i++)
     
356.         {
     
357.             if (this->at(i) == num)
     
358.             {
     
359.                 count++;
     
360.             }
     
361.         }
     
362.     }
     
363.     return count;
     
364. }
     
365. //15--返回两个对象共同的元素
     
366. template <typename tp>
     
367. numbers<tp> numbers<tp>::operator/(const numbers<tp> &nums) const
     
368. {
     
369.     numbers<tp> r_nums;
     
370.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
     
371.     {
     
372.         for (size_t i = 0; i < nums.numsLen; i++)
     
373.         {
     
374.             if ((*this)% (*(nums.numsPtr + i)))
     
375.             {
     
376.                 r_nums += (*(nums.numsPtr + i));
     
377.             }
     
378.         }
     
379.     }
     
380.     return r_nums;
     
381. }
     
382. /*--------------------------------------------------------*/
     
383. //16--删除对象中符合条件的元素
     
384. template <typename tp>
     
385. numbers<tp> numbers<tp>::operator-(const tp num) const
     
386. {
     
387.     numbers<tp> r_nums;
     
388.     if (numsPtr != nullptr)
     
389.     {
     
390.         for (size_t i = 0; i < numsLen; i++)
     
391.         {
     
392.             if (this->at(i) != num)
     
393.             {
     
394.                 r_nums += *(numsPtr + i);
     
395.             }
     
396.         }
     
397.     }
     
398.     return r_nums;
     
399. }
     
400. //17--删除父对象中与子对象中重复的元素
     
401. template <typename tp>
     
402. numbers<tp> numbers<tp>::operator-(const numbers<tp>& nums) const
     
403. {
     
404.     numbers<tp> r_nums;
     
405.     size_t count = 0;
     
406.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
     
407.     /*两个非空数字串*/
     
408.     {
     
409.         r_nums = *this;
     
410.         for (size_t i = 0; i < nums.numsLen; i++)
     
411.         {
     
412.             if ((*this)%(*(nums.numsPtr + i)))
     
413.             {
     
414.                 r_nums = r_nums - *(nums.numsPtr + i);   
     
415.             }     
     
416.         }
     
417.         if (r_nums.numsLen == 0)
     
418.         {
     
419.             delete [] r_nums.numsPtr;
     
420.             r_nums.numsPtr = nullptr;
     
421.         }
     
422.     }
     
423.     else if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))
     
424.     /*子串为空*/
     
425.     {
     
426.         r_nums = *this;
     
427.     }
     
428.     return r_nums;
     
429. }
     
430. //18--按索引删除元素(数据必须是size_t类型)失败返回空串
     
431. template <typename tp>
     
432. numbers<tp> numbers<tp>::operator-(const size_t index) const
     
433. {
     
434.     numbers<tp> r_nums;
     
435.     if ((index < numsLen ) && (numsPtr != nullptr))
     
436.     {
     
437.         for (size_t i = 0; i < index; i++)
     
438.         {
     
439.             r_nums = r_nums + *(numsPtr + i);
     
440.         }
     
441.         for (size_t i = index + 1; i < numsLen; i++)
     
442.         {
     
443.             r_nums = r_nums + *(numsPtr + i);
     
444.         }
     
445.     }
     
446.     return r_nums;
     
447. }
     
448. //19-翻转数据的正负
     
449. template <typename tp>
     
450. numbers<tp> numbers<tp>::operator-(void) const
     
451. {
     
452.     numbers<tp> r_nums;
     
453.     for (size_t i = 0; i < numsLen; i++)
     
454.     {
     
455.         r_nums += -*(numsPtr + i);
     
456.     }
     
457.     return r_nums;
     
458. }
     
459. #endif

复制代码

优化isnumbers()函数

1. //0---判断是否是数字字符串
   
2. template <typename tp>
   
3. void numbers<tp>::isnumbers(const std::string &str)
   
4. {
   
5.     size_t s = str.size();
   
6.     if (str[0] != '-' && (!isdigit(str[0])))
   
7.     {
   
8.         std::cerr << "Cannot convert to a valid number!" << std::endl;
   
9.         exit(1);
   
10.     }
    
11.     if (str[0] == '-' || (isdigit(str[0])))
    
12.     {
    
13.         for (size_t i = 1; i < s; i++)
    
14.         {
    
15.             if (!isdigit(str[i]))
    
16.             {
    
17.                 std::cerr << "Cannot convert to a valid number!" << std::endl;
    
18.                 exit(1);
    
19.             }
    
20.         }
    
21.     }
    
22. }

复制代码