C++学习

bin554385863

numbers.TXT

1. 
   
2. 时间:2019年11月20日22:18:43;
   
3. 作用:仿照C++ string用来处理数字串的类;
   
4. 构造函数:
   
5. //默认构造
   
6. numbers():numsLen(0), numsPtr(nullptr){}
   
7. //使用C风格数字数组构造
   
8. numbers(const tp *arr, const size_t arrSize);
   
9. //可变参数构造
   
10. numbers(std::initializer_list<tp> list);
    
11. //拷贝构造
    
12. numbers(const numbers<tp>& nums);
    
13. ****************************************************
    
14. 成员函数
    
15. 
    
16. at():
    
17. 按索引获取数字串的元素;
    
18. 按索引修改元素的值;
    
19. 
    
20. size():
    
21. 获取对象的大小
    
22. ****************************************************
    
23. 重载运算符
    
24. 
    
25. [](改)
    
26. 安索引修改对象元素的值;
    
27. 
    
28. +(增):
    
29. 添加元素;
    
30. 合并对象;
    
31. 
    
32. -(删)
    
33. 删除对象中指定的数据;
    
34. 删除父对象中与子对象相同的数据;
    
35. 
    
36. %(查)
    
37. 判断对象是否包含某数据;
    
38. 判断子对象是否父对象的子串;
    
39. 
    
40. /(查):
    
41. 返回数据在对象中出现的次数;
    
42. 返回对象与对象相同的元素;
    
43. 
    

复制代码

numbers.h

1. #ifndef NUMBERS_H
   
2. #define NUMBERS_H
   
3. #include <iostream>
   
4. #include <initializer_list>
   
5. template <typename tp>
   
6. class numbers
   
7. {
   
8. private:
   
9.     size_t numsLen;
   
10.     tp *numsPtr;
    
11. 
    
12. public:
    
13.     //1--默认构造
    
14.     numbers() : numsLen(0), numsPtr(nullptr) {}
    
15.     //2--使用C风格数字数组构造
    
16.     numbers(const tp *arr, const size_t arrSize);
    
17.     //3--可变参数构造
    
18.     numbers(std::initializer_list<tp> list);
    
19.     //4--拷贝构造
    
20.     numbers(const numbers<tp> &nums);
    
21.     /*--------------------------------------------------------*/
    
22.     //5--按索引获取元素;按索引修改元素的值
    
23.     tp &at(const size_t index) const;
    
24.     //6--对象的大小
    
25.     size_t const size() const;
    
26.     /*--------------------------------------------------------*/
    
27.     //7--重载下标运算符
    
28.     tp &operator[](const size_t index) const;
    
29.     //8--深度拷贝
    
30.     numbers<tp> &operator=(const numbers<tp> &nums);
    
31.     //9--重载流运算符<<
    
32.     friend std::ostream &operator<<(std::ostream &os, const numbers<tp> &nums)
    
33.     {
    
34.         size_t sz = nums.size();
    
35.         for (size_t i = 0; i < sz; i++)
    
36.         {
    
37.             os << nums[i] << " ";
    
38.         }
    
39.         return os;
    
40.     }
    
41.     /*--------------------------------------------------------*/
    
42.     //10--添加元素
    
43.     numbers<tp> operator+(const tp num) const;
    
44.     //11--合并对象
    
45.     numbers<tp> operator+(const numbers<tp> &nums) const;
    
46.     /*--------------------------------------------------------*/
    
47.     //12--判断数据在对象中存在
    
48.     bool operator%(const tp num) const;
    
49.     //13--判断子对象是否父对象的子串
    
50.     bool operator%(const numbers<tp>& nums) const;
    
51.     /*--------------------------------------------------------*/
    
52.     //14--返回数据出现的次数
    
53.     size_t operator/(tp num) const;
    
54.     //15--返回两个对象共同的元素
    
55.     numbers<tp> operator/(numbers<tp> &nums) const;
    
56.     /*--------------------------------------------------------*/
    
57.     //16--删除元素
    
58.     numbers<tp> operator-(const tp num) const;
    
59.     //17--删除父对象中与子对象中重复的元素
    
60.     numbers<tp> operator-(const numbers<tp> &nums) const;
    
61.     //18--按索引删除元素(数据必须是size_t类型)失败返回空串
    
62.     numbers<tp> operator-(const size_t index) const;
    
63.     /*--------------------------------------------------------*/
    
64.     ~numbers()
    
65.     {
    
66.         delete[] numsPtr;
    
67.     }
    
68. };
    
69. 
    
70. #endif

复制代码

numbers.cpp

1. #include "numbers.h"
   
2. //2--使用C风格数字数组构造
   
3. template <typename tp>
   
4. numbers<tp>::numbers(const tp *arr, const size_t arrSize) : numsLen(arrSize)
   
5. {
   
6.     numsPtr = new tp[numsLen];
   
7.     for (size_t i = 0; i < numsLen; i++)
   
8.     {
   
9.         *(numsPtr + i) = *(arr + i);
   
10.     }
    
11. }
    
12. //3--可变参数构造
    
13. template <typename tp>
    
14. numbers<tp>::numbers(std::initializer_list<tp> list) : numsLen(list.size())
    
15. {
    
16.     numsPtr = new tp[numsLen];
    
17.     for (size_t i = 0; i < numsLen; i++)
    
18.     {
    
19.         *(numsPtr + i) = *(list.begin() + i);
    
20.     }
    
21. }
    
22. //4--拷贝构造
    
23. template <typename tp>
    
24. numbers<tp>::numbers(const numbers<tp> &nums) : numsLen(nums.numsLen)
    
25. {
    
26.     numsPtr = new tp[numsLen];
    
27.     for (size_t i = 0; i < numsLen; i++)
    
28.     {
    
29.         *(numsPtr + i) = *(nums.numsPtr + i);
    
30.     }
    
31. }
    
32. /*--------------------------------------------------------------------*/
    
33. //5--按索引获取元素;按索引修改元素的值
    
34. template <typename tp>
    
35. inline tp &numbers<tp>::at(const size_t index) const
    
36. {
    
37.     return numsPtr[index];
    
38. }
    
39. //6--对象的大小
    
40. template <typename tp>
    
41. inline const size_t numbers<tp>::size() const
    
42. {
    
43.     return numsLen;
    
44. }
    
45. /*--------------------------------------------------------*/
    
46. //7--重载下标运算符
    
47. template <typename tp>
    
48. inline tp &numbers<tp>::operator[](const size_t index) const
    
49. {
    
50.     return numsPtr[index];
    
51. }
    
52. /*--------------------------------------------------------*/
    
53. //8--深度拷贝
    
54. template <typename tp>
    
55. numbers<tp> &numbers<tp>::operator=(const numbers<tp> &nums)
    
56. {
    
57.     if (numsPtr != nullptr)
    
58.     {
    
59.         numsLen = nums.numsLen;
    
60.         delete[] numsPtr;
    
61.         numsPtr = new tp[numsLen];
    
62.         for (size_t i = 0; i < numsLen; i++)
    
63.         {
    
64.             *(numsPtr + i) = *(nums.numsPtr + i);
    
65.         }
    
66.     }
    
67.     else
    
68.     {
    
69.         numsLen = nums.numsLen;
    
70.         numsPtr = new tp[numsLen];
    
71.         for (size_t i = 0; i < nums.numsLen; i++)
    
72.         {
    
73.             this->at(i) = *(nums.numsPtr + i);
    
74.         }
    
75.     }
    
76.     return *this;
    
77. }
    
78. /*--------------------------------------------------------*/
    
79. //10--添加元素
    
80. template <typename tp>
    
81. numbers<tp> numbers<tp>::operator+(const tp num) const
    
82. {
    
83.     numbers<tp> t_nums = *this;
    
84.     if (t_nums.numsPtr != nullptr)
    
85.     {
    
86.         tp *t_numsPtr = new tp[numsLen + 1];
    
87.         for (size_t i = 0; i < numsLen; i++)
    
88.         {
    
89.             *(t_numsPtr + i) = this->at(i);
    
90.         }
    
91.         *(t_numsPtr + numsLen) = num;
    
92.         t_nums.numsLen++;
    
93.         delete[] t_nums.numsPtr;
    
94.         t_nums.numsPtr = t_numsPtr;
    
95.     }
    
96.     else
    
97.     {
    
98.         t_nums.numsLen+=1;
    
99.         t_nums.numsPtr = new tp[numsLen]{num};
    
100.     }
     
101. 
     
102.     return t_nums;
     
103. }
     
104. //11--合并对象
     
105. template <typename tp>
     
106. numbers<tp> numbers<tp>::operator+(const numbers<tp> &nums) const
     
107. {
     
108.     numbers<tp> t_nums;
     
109.     if (numsPtr != nullptr)
     
110.     {
     
111.         t_nums = *this;
     
112.         for (size_t i = 0; i < nums.numsLen; i++)
     
113.         {
     
114.             t_nums = t_nums + *(nums.numsPtr + i);
     
115.         }
     
116.     }
     
117.     else
     
118.     {
     
119.         t_nums = nums;
     
120.     }
     
121. 
     
122.     return t_nums;
     
123. }
     
124. /*--------------------------------------------------------*/
     
125. //12--判断数据在对象中是否存在
     
126. template <typename tp>
     
127. bool numbers<tp>::operator%(const tp num) const
     
128. {
     
129.     bool flag = false;
     
130.     if (numsPtr != nullptr)
     
131.     {
     
132.         for (size_t i = 0; i < numsLen; i++)
     
133.         {
     
134.             if (num == *(numsPtr + i))
     
135.             {
     
136.                 flag = true;
     
137.                 break;
     
138.             }
     
139.         }
     
140.     }
     
141.     return flag;
     
142. }
     
143. //13--判断子对象是否父对象的子串
     
144. template <typename tp>
     
145. bool numbers<tp>::operator%(const numbers<tp> &nums) const
     
146. {
     
147.     bool flag = false;
     
148.     size_t count = 1;
     
149.     if (numsLen > nums.numsLen)
     
150.     {
     
151.         for (size_t i = 0; i < nums.numsLen; i++)
     
152.         {
     
153.             if ((*this) % (*(nums.numsPtr + i)))
     
154.             {
     
155.                 count++;
     
156.                 if (count == nums.numsLen)
     
157.                 {
     
158.                     break;
     
159.                 }
     
160.             }
     
161.         }
     
162.         if (count == nums.numsLen)
     
163.         {
     
164.             flag = true;
     
165.         }
     
166.     }
     
167.     if (nums.numsPtr == 0)
     
168.     {
     
169.         flag = true;
     
170.     }
     
171.     return flag;
     
172. }
     
173. /*--------------------------------------------------------*/
     
174. //14--返回数据出现的次数
     
175. template <typename tp>
     
176. size_t numbers<tp>::operator/(tp num) const
     
177. {
     
178.     size_t count = 0;
     
179.     if (numsPtr != nullptr)
     
180.     {
     
181.         for (size_t i = 0; i < numsLen; i++)
     
182.         {
     
183.             if (this->at(i) == num)
     
184.             {
     
185.                 count++;
     
186.             }
     
187.         }
     
188.     }
     
189.     return count;
     
190. }
     
191. //15--返回两个对象共同的元素
     
192. template <typename tp>
     
193. numbers<tp> numbers<tp>::operator/(numbers<tp> &nums) const
     
194. {
     
195.     numbers<tp> r_nums;
     
196.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
     
197.     {
     
198.         for (size_t i = 0; i < nums.numsLen; i++)
     
199.         {
     
200.             if ((*this)% (*(nums.numsPtr + i)))
     
201.             {
     
202.                 r_nums = r_nums + *(nums.numsPtr + i);
     
203.             }
     
204.         }
     
205.     }
     
206.     return r_nums;
     
207. }
     
208. /*--------------------------------------------------------*/
     
209. //16--删除元素
     
210. template <typename tp>
     
211. numbers<tp> numbers<tp>::operator-(const tp num) const
     
212. {
     
213.     numbers<tp> r_nums;
     
214.     if (numsPtr != nullptr)
     
215.     {
     
216.         for (size_t i = 0; i < numsLen; i++)
     
217.         {
     
218.             if (this->at(i) != num)
     
219.             {
     
220.                 r_nums = r_nums + *(numsPtr + i);
     
221.             }
     
222.         }
     
223.     }
     
224.     return r_nums;
     
225. }
     
226. //17--删除父对象中与子对象中重复的元素
     
227. template <typename tp>
     
228. numbers<tp> numbers<tp>::operator-(const numbers<tp>& nums) const
     
229. {
     
230.     numbers<tp> r_nums;
     
231.     size_t count = 0;
     
232.     if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
     
233.     /*两个非空数字串*/
     
234.     {
     
235.         r_nums = *this;
     
236.         for (size_t i = 0; i < nums.numsLen; i++)
     
237.         {
     
238.             r_nums = r_nums - *(nums.numsPtr + i);            
     
239.         }
     
240.         if (r_nums.numsLen == 0)
     
241.         {
     
242.             delete [] r_nums.numsPtr;
     
243.             r_nums.numsPtr = nullptr;
     
244.         }
     
245.     }
     
246.     else if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))
     
247.     /*子串为空*/
     
248.     {
     
249.         r_nums = *this;
     
250.     }
     
251.     return r_nums;
     
252. }
     
253. //18--按索引删除元素(数据必须是size_t类型)失败返回空串
     
254. template <typename tp>
     
255. numbers<tp> numbers<tp>::operator-(size_t index) const
     
256. {
     
257.     numbers<tp> r_nums;
     
258.     if ((index < numsLen ) && (numsPtr != nullptr))
     
259.     {
     
260.         for (size_t i = 0; i < index; i++)
     
261.         {
     
262.             r_nums = r_nums + *(numsPtr + i);
     
263.         }
     
264.         for (size_t i = index + 1; i < numsLen; i++)
     
265.         {
     
266.             r_nums = r_nums + *(numsPtr + i);
     
267.         }
     
268.     }
     
269.     return r_nums;
     
270. }

复制代码

=================================================================================
main.c

1. #include "numbers.cpp"
   
2. int main(int argc, char const *argv[])
   
3. {
   
4.     numbers<int> a = {1}, b = {2}, c, z, d = {1, 2, 3}, e = {7, 9, 10}, f = {1,2,3,9,2,12};
   
5.     z = a + 2 + 3 + b + c + 4 + 5 + b + c;//测试+号重载,可以连加但必须数字串对象开头
   
6.     std::cout << z << std::endl;//测试<<
   
7.     std::cout<<z%1<<" "<<z%e<<" "<<z%f<<std::endl;//测试%重载,数字串对象必须在首位
   
8.     std::cout<<z/2<<"\n"<<z/f<<"\n"<<z/e<<std::endl;//测试\号重载,
   
9.     numbers<int> nums0 = {1,2,2,3,6,8,69,6,2,2,5,899};
   
10.     std::cout<<nums0<<std::endl;//测试-号重载,数字串必须对象在首位
    
11.     numbers<int> nums1;
    
12.     nums0 = nums0 - nums1;//
    
13.     std::cout<<"空串测试"<<nums0<<std::endl;
    
14.     nums0 = nums0 - 899;//
    
15.     std::cout<<"数字测试"<<nums0<<std::endl;
    
16.     nums0 = nums0 - (size_t)0;//
    
17.     std::cout<<"索引测试"<<nums0<<std::endl;
    
18.     nums0 = nums0 - z;//
    
19.     std::cout<<"非空对象测试(有相同元素)"<<nums0<<std::endl;
    
20.     nums0 = nums0 - e;//
    
21.     std::cout<<"非空对象测试(无相同元素)"<<nums0<<std::endl;
    
22.     return 0;
    
23. }
    

复制代码

----------------------------------------------------------------------------------------
Microsoft Windows [版本 10.0.18363.476]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.1\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-n5ukogix.do5 --stdout=Microsoft-MIEngine-Out-c5k34mn0.wwi --stderr=Microsoft-MIEngine-Error-k43i2w1i.n55 --pid=Microsoft-MIEngine-Pid-mqrubay4.n0f --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
1 2 3 2 4 5 2
1 0 0
3
1 2 3 2

1 2 2 3 6 8 69 6 2 2 5 899
空串测试1 2 2 3 6 8 69 6 2 2 5 899
数字测试1 2 2 3 6 8 69 6 2 2 5
索引测试2 2 3 6 8 69 6 2 2 5
非空对象测试(有相同元素)6 8 69 6
非空对象测试(无相同元素)6 8 69 6

E:\Users\admin\Documents\VScode>