C++ 自定义numbers类 初步完成

bin554385863

numbers.txt

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

复制代码

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

复制代码

Croper

嗯。。首先，模板的声明和实现不能分开写到两个文件里。。。
除非你在cpp文件里将其显式的实例化

1. template class numbers<int>;
   
2. template class numbers<char>;
   
3. ...

复制代码

不然无法正确实例化；

bin554385863

Croper 发表于 2019-11-22 01:15
嗯。。首先，模板的声明和实现不能分开写到两个文件里。。。
除非你在cpp文件里将其显式的实例化

我这个压根就没考虑char类型，而且在vscode调试也没出现啥问题啊，别的编译器就不知道了

Croper

是么？
你vscode是怎么配置的，用的什么编译器？

据我了解，.cpp文件在编译时应该是先生成.obj文件再进行连接的，如果生成文件时模板没有实例化，那么连接之后是会找不到相应代码的。
我想你是不是main.cpp里include了numbers.cpp?

测试代码：main.cpp:

1. #include <iostream>
   
2. #include "numbers.h"
   
3. 
   
4. using namespace std;
   
5. 
   
6. int main() {
   
7.         numbers<int> a = { 1,2,3,4,5,6 };
   
8.         auto b = a + 3;
   
9.         cout << b << endl;
   
10.         system("pause");
    
11. }

复制代码

vscode 使用MinGW64编译:

1. > Executing task: g++ '-g' 'e:\vscode source file\c++\Test Projection\main.cpp' '-std=c++14' '-o' 'main.exe' <
   
2. 
   
3. C:\Users\ADMINI~1\AppData\Local\Temp\ccTiogBg.o: In function `main':
   
4. e:/vscode source file/c++/Test Projection/main.cpp:7: undefined reference to `numbers<int>::numbers(std::initializer_list<int>)'
   
5. e:/vscode source file/c++/Test Projection/main.cpp:8: undefined reference to `numbers<int>::operator+(int) const'
   
6. C:\Users\ADMINI~1\AppData\Local\Temp\ccTiogBg.o: In function `operator<<(std::ostream&, numbers<int> const&)':
   
7. e:/vscode source file/c++/Test Projection/numbers.h:34: undefined reference to `numbers<int>::size() const'
   
8. e:/vscode source file/c++/Test Projection/numbers.h:37: undefined reference to `numbers<int>::operator[](unsigned long long) const'
   
9. collect2.exe: error: ld returned 1 exit status
   
10. 终端进程已终止，退出代码: 1

复制代码

使用vs2017编译，也是同样的问题：

1. 1>------ 已启动生成: 项目: Project1, 配置: Debug x64 ------
   
2. 1>源1.cpp
   
3. 1>源1.obj : error LNK2019: 无法解析的外部符号 "public: __cdecl numbers<int>::numbers<int>(class std::initializer_list<int>)" (??0?$numbers@H@@QEAA@V?$initializer_list@H@std@@@Z)，该符号在函数 main 中被引用
   
4. 1>源1.obj : error LNK2019: 无法解析的外部符号 "public: unsigned __int64 const __cdecl numbers<int>::size(void)const " (?size@?$numbers@H@@QEBA?B_KXZ)，该符号在函数 "class std::basic_ostream<char,struct std::char_traits<char> > & __cdecl operator<<(class std::basic_ostream<char,struct std::char_traits<char> > &,class numbers<int> const &)" (??6@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@std@@AEAV01@AEBV?$numbers@H@@@Z) 中被引用
   
5. 1>源1.obj : error LNK2019: 无法解析的外部符号 "public: int & __cdecl numbers<int>::operator[](unsigned __int64)const " (??A?$numbers@H@@QEBAAEAH_K@Z)，该符号在函数 "class std::basic_ostream<char,struct std::char_traits<char> > & __cdecl operator<<(class std::basic_ostream<char,struct std::char_traits<char> > &,class numbers<int> const &)" (??6@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@std@@AEAV01@AEBV?$numbers@H@@@Z) 中被引用
   
6. 1>源1.obj : error LNK2019: 无法解析的外部符号 "public: class numbers<int> __cdecl numbers<int>::operator+(int)const " (??H?$numbers@H@@QEBA?AV0@H@Z)，该符号在函数 main 中被引用
   
7. 1>C:\Users\Administrator\source\repos\Project1\x64\Debug\Project1.exe : fatal error LNK1120: 4 个无法解析的外部命令
   
8. 1>已完成生成项目“Project1.vcxproj”的操作 - 失败。

复制代码

把numbers.cpp内的内容全部扔到numbers.h下后，两程序均输出

1. 1 2 3 4 5 6 3

复制代码

符合预期

bin554385863

Croper 发表于 2019-11-22 17:43
是么？
你vscode是怎么配置的，用的什么编译器？

我包含的cpp,不是.h

Croper

任何时候都不应该包含.cpp文件，这完全失去了把.h文件和.cpp文件写成两部分的意义。（虽然这段代码本来.h文件和.cpp文件就写不开)
当你包含.cpp文件时，实际是把这两个文件写一块了。

如果你包含.cpp文件。在编译时，程序上的任何改动都会导致程序将整段程序重新编译，而不是仅仅重新编译单个模块。并且，被包含部分的代码会被反复多次编译。大大降低编译效率。
其次，一旦.cpp文件里包含static修饰的全局变量，那么static关键字将失去效果。导致一些不可预期的错误。毕竟模块化的思想是你不需要了解模块的实现，而只需要了解接口和功能。

csdn上有很多相关的文章，你可以去查查。

bin554385863

Croper 发表于 2019-11-23 14:18
任何时候都不应该包含.cpp文件，这完全失去了把.h文件和.cpp文件写成两部分的意义。（虽然这段代码本来.h文 ...

如果我把类模板的定义和成员函数的实现分开写然后在写一个头文件同时包含进去,应该没问题吧

Croper

我感觉没啥问题，不过两部分应该都写成.h。

不过这样是不是有点为了分开而分开了。