C++ 数字串自定义类,推倒重写

bin554385863

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.     //默认构造
    
14.     numbers() : numsLen(0), numsPtr(nullptr) {}
    
15.     //使用C风格数字数组构造
    
16.     numbers(const tp *arr, const size_t arrSize);
    
17.     //可变参数构造
    
18.     numbers(std::initializer_list<tp> list);
    
19.     //拷贝构造
    
20.     numbers(const numbers<tp> &nums);
    
21.     /*--------------------------------------------------------*/
    
22.     //按索引获取元素;按索引修改元素的值
    
23.     tp &at(const size_t index);
    
24.     //对象的大小
    
25.     size_t size()const;
    
26.     /*--------------------------------------------------------*/
    
27.     //重载下标运算符
    
28.     tp &operator[](const size_t index);
    
29.     /*--------------------------------------------------------*/
    
30.     //添加元素
    
31.     numbers<tp> operator&(const tp num);
    
32.     //合并对象
    
33.     numbers<tp> operator&(const numbers<tp> &nums);
    
34.     /*--------------------------------------------------------*/
    
35.     //深度拷贝
    
36.     numbers<tp> &operator=(const numbers<tp> &nums);
    
37.     friend std::ostream& operator<<(std::ostream& os, numbers<tp>& nums)
    
38.     {
    
39.         size_t sz = nums.size();
    
40.         for (size_t i = 0; i < sz; i++)
    
41.         {
    
42.             os<<nums[i]<<" ";
    
43.         }
    
44.         return os;
    
45.     }
    
46.     ~numbers()
    
47.     {
    
48.         delete [] numsPtr;
    
49.     }
    
50. };
    
51. 
    
52. #endif

复制代码

numbers.cpp

1. #include "numbersh.cpp"
   
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. //可变参数构造
    
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. //拷贝构造
    
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. //按索引获取元素;按索引修改元素的值
    
34. template <typename tp>
    
35. inline tp &numbers<tp>::at(const size_t index)
    
36. {
    
37.     return numsPtr[index];
    
38. }
    
39. //对象的大小
    
40. template <typename tp>
    
41. inline size_t numbers<tp>::size() const
    
42. {
    
43.     return numsLen;
    
44. }
    
45. /*--------------------------------------------------------*/
    
46. //重载下标运算符
    
47. template <typename tp>
    
48. inline tp &numbers<tp>::operator[](const size_t index)
    
49. {
    
50.     return numsPtr[index];
    
51. }
    
52. /*--------------------------------------------------------*/
    
53. //添加元素
    
54. template <typename tp>
    
55. numbers<tp> numbers<tp>::operator&(const tp num)
    
56. {
    
57.     numbers<tp> t_nums(numsPtr, numsLen);
    
58.     if (t_nums.numsPtr != nullptr)
    
59.     {
    
60.         tp *t_numsPtr = new tp[numsLen + 1];
    
61.         for (size_t i = 0; i < numsLen; i++)
    
62.         {
    
63.             *(t_numsPtr + i) = this->at(i);
    
64.         }
    
65.         *(t_numsPtr + numsLen) = num;
    
66.         t_nums.numsLen++;
    
67.         delete[] t_nums.numsPtr;
    
68.         t_nums.numsPtr = t_numsPtr;
    
69.     }
    
70.     else
    
71.     {
    
72.         t_nums.numsLen+=1;
    
73.         t_nums.numsPtr = new tp[numsLen]{num};
    
74.     }
    
75. 
    
76.     return t_nums;
    
77. }
    
78. //合并对象
    
79. template <typename tp>
    
80. numbers<tp> numbers<tp>::operator&(const numbers<tp> &nums)
    
81. {
    
82.     numbers<tp> t_nums(numsPtr, numsLen);
    
83.     for (size_t i = 0; i < nums.numsLen; i++)
    
84.     {
    
85.         t_nums = t_nums & nums[i];
    
86.     }
    
87.     return t_nums;
    
88. }
    
89. /*--------------------------------------------------------*/
    
90. //深度拷贝
    
91. template <typename tp>
    
92. numbers<tp> &numbers<tp>::operator=(const numbers<tp> &nums)
    
93. {
    
94.     if (numsPtr != nullptr)
    
95.     {
    
96.         numsLen = nums.numsLen;
    
97.         delete[] numsPtr;
    
98.         numsPtr = new tp[numsLen];
    
99.         for (size_t i = 0; i < numsLen; i++)
    
100.         {
     
101.             *(numsPtr + i) = *(nums.numsPtr + i);
     
102.         }
     
103.     }
     
104.     else
     
105.     {
     
106.         numsLen = nums.numsLen;
     
107.         numsPtr = new tp[numsLen];
     
108.         for (size_t i = 0; i < nums.numsLen; i++)
     
109.         {
     
110.             this->at(i) = *(nums.numsPtr + i);
     
111.         }
     
112.     }
     
113.     return *this;
     
114. }
     
115. 
     
116. int main(int argc, char const *argv[])
     
117. {
     
118.     numbers<int> a = {1}, b;
     
119.     a = a & 2;
     
120.     std::cout << a << std::endl;
     
121.     //std::cout << a;
     
122.     return 0;
     
123. }
     

复制代码