C++怎么避免访问空串

bin554385863

第149行和第156行的函数怎么能避免访问空串

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

复制代码