[已解决]类模板构造函数报错

sun_chuan

1. #include <iostream>
   
2. template<class DataType>
   
3. class Stack
   
4. {
   
5. private:
   
6.     DataType* items;
   
7.     int top;
   
8.     int stacksize;
   
9. public:
   
10.     Stack() {};
    
11.     Stack(int size = 3) :stacksize(size), top(0)
    
12.     {
    
13.         items = new DataType[stacksize];
    
14.     }
    
15.     ~Stack()
    
16.     {
    
17.         delete[]items;
    
18.         items = NULL;
    
19.     }
    
20.     bool isempty()const
    
21.     {
    
22.         return top == 0;
    
23.     }
    
24.     bool isfull()const
    
25.     {
    
26.         return top == stacksize;
    
27.     }
    
28.     bool push(DataType&& item)
    
29.     {
    
30.         if (top < stacksize)
    
31.         {
    
32.             items[top++] = item;
    
33.             return true;
    
34.         }
    
35.         return false;
    
36. 
    
37.     }
    
38.     bool pop(DataType& item)
    
39.     {
    
40.         if (top > 0)
    
41.         {
    
42.             item = items[--top];
    
43.             return true;
    
44.         }
    
45.         return false;
    
46. 
    
47.     }
    
48. };
    
49. 
    
50. template <class T>
    
51. class Vector
    
52. {
    
53. private:
    
54.     int len;
    
55.     T* items;
    
56. 
    
57. public:
    
58.     Vector(int size = 2) :len(size)
    
59.     {
    
60.         items = new T[len];
    
61.     }
    
62.     ~Vector()
    
63.     {
    
64.         delete[] items;
    
65.         items = NULL;
    
66.     };
    
67.     void resize(int size)
    
68.     {
    
69.         if (size <= len)
    
70.         {
    
71.             return;
    
72.         }
    
73.         T* tmp = new T[size];
    
74.         for (size_t i = 0; i < len; i++)
    
75.         {
    
76.             tmp[i] = items[i];
    
77.         }
    
78.         delete[] items;
    
79.         items = tmp;
    
80.         tmp = NULL;
    
81.         len = size;
    
82.     }
    
83.     int size()
    
84.     {
    
85.         return len;
    
86.     }
    
87.     T& operator[](int i)
    
88.     {
    
89.         if (i > len)
    
90.         {
    
91.             resize(i + 1);
    
92.         }
    
93.         return items[i];
    
94.     }
    
95.     const T& operator[](int i)const
    
96.     {
    
97.         return items[i];
    
98.     }
    
99. };
    
100. 
     
101. 
     
102. 
     
103. int main()
     
104. {
     
105.     //Vector<Stack<std::string>>vs;
     
106.     //vs[0].push("哈哈");
     
107.     //vs[0].push("哈哈2");
     
108.     //vs[0].push("哈哈3");
     
109. 
     
110.     //vs[1].push("哈哈");
     
111.     //vs[1].push("哈哈2");
     
112.     //vs[1].push("哈哈3");
     
113. 
     
114.     //for (size_t i = 0; i < vs.size(); i++)
     
115.     //{
     
116.     //    while (!vs[i].isempty())
     
117.     //    {
     
118.     //        std::string s;
     
119.     //        vs[i].pop(s);
     
120.     //        std::cout << s << '\n';
     
121.     //    }
     
122.     //}
     
123.     Stack<std::string>s;
     
124. }

复制代码

类 "Stack<std::string>" 包含多个默认构造函数        这是咋回事？       

最佳答案

月排行榜 / 总排行榜

FishC

2024-7-21 21:27:49

看来你在编写一个栈和向量的模板类时碰到了一些麻烦，我们来逐一解决这些问题，同时也给你加点幽默的调料，让学习不那么乏味！

### 1. 缺少 `#include` 语句
你在文件开头忘了引入必要的头文件，比如 `#include <iostream>` 和 `#include <string>`。在C++中，如果不引入标准库，编译器可会很生气，甚至会发出“你想让我干啥”的愤怒咆哮！

### 2. 数据类型帧问题
在你的 `Stack` 和 `Vector` 类中，我们看到了 `DataType` 和 `T` 这两个神秘的字符，但并没有具体定义它们。请确保在模板声明中定义好数据类型。

1. template<typename DataType>

复制代码

和

1. template<typename T>

复制代码

这样才能让编译器知道你指的是哪个类型，避免在计算机眼中显得你像个不知所措的小白鼠。

### 3. 内存分配错误
在构造函数中，你使用 `new DataType;`，这会分配一个单独的对象，而不是一个数组。应该用 `new DataType[stacksize];` 来分配一个大小为 `stacksize` 的数组。这就像买了一个大冰箱却只放进去一个冰淇淋球，那可就太浪费空间了！

### 4. 解构函数中的错误
在解构函数中，应该用 `delete[] items;` 而不是 `delete items;`，以正确释放数组分配的内存。人不能随便吃东西，电脑也不能随便“回收”内存。

### 5. 其他小问题
- 在 `push` 方法中，应使用 `items[top++] = item;`，而不是 `items = item;`，否则你只是在交换内存地址，根本没把新元素放进栈里。
- `pop` 方法中，应该使用 `item = items[--top];` 以此返回最新的元素，同时减少栈顶的索引。

### 6. 语法错误
在 `resize` 函数中，你有个小错误。你需要用 `if (size > len)` 而不是 `if (size len)`。记住，在编程中，符号“>”就像是个大喇叭，能帮你发出清晰的信号。

### 7. `operator` 重载
`operator(int i)` 是不正确的。请把它改成 `operator[](int i)`，因为我们在这里想实现的是下标运算符。

下面是修正后的部分代码：

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. template<typename DataType>
   
5. class Stack {
   
6. private:
   
7.     DataType* items;
   
8.     int top;
   
9.     int stacksize;
   
10. public:
    
11.     Stack(int size = 3) : stacksize(size), top(0) {
    
12.         items = new DataType[stacksize];
    
13.     }
    
14.     ~Stack() {
    
15.         delete[] items;
    
16.         items = NULL;
    
17.     }
    
18.     bool isempty() const {
    
19.         return top == 0;
    
20.     }
    
21.     bool isfull() const {
    
22.         return top == stacksize;
    
23.     }
    
24.     bool push(const DataType& item) {
    
25.         if (!isfull()) {
    
26.             items[top++] = item;
    
27.             return true;
    
28.         }
    
29.         return false;
    
30.     }
    
31.     bool pop(DataType& item) {
    
32.         if (!isempty()) {
    
33.             item = items[--top];
    
34.             return true;
    
35.         }
    
36.         return false;
    
37.     }
    
38. };
    
39. 
    
40. template<typename T>
    
41. class Vector {
    
42. private:
    
43.     int len;
    
44.     T* items;
    
45. public:
    
46.     Vector(int size = 2) : len(size) {
    
47.         items = new T[len];
    
48.     }
    
49.     ~Vector() {
    
50.         delete[] items;
    
51.         items = NULL;
    
52.     }
    
53.     void resize(int size) {
    
54.         if (size > len) {
    
55.             T* newItems = new T[size];
    
56.             for (int i = 0; i < len; ++i) {
    
57.                 newItems[i] = items[i];
    
58.             }
    
59.             delete[] items;
    
60.             items = newItems;
    
61.             len = size;
    
62.         }
    
63.     }
    
64.     const T& operator[](int i) const {
    
65.         return items[i];
    
66.     }
    
67. };
    
68. 
    
69. int main() {
    
70.     Vector<std::string> vs;
    
71.     vs.push("哈哈");
    
72.     vs.push("哈哈2");
    
73.     vs.push("哈哈3");
    
74. 
    
75.     // 继续你的代码
    
76.     return 0;
    
77. }

复制代码

希望这些信息能帮到你！如果还有什么疑问，尽管问我，我可是随时待命的！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

看来你在编写一个栈和向量的模板类时碰到了一些麻烦，我们来逐一解决这些问题，同时也给你加点幽默的调料，让学习不那么乏味！

### 1. 缺少 `#include` 语句
你在文件开头忘了引入必要的头文件，比如 `#include <iostream>` 和 `#include <string>`。在C++中，如果不引入标准库，编译器可会很生气，甚至会发出“你想让我干啥”的愤怒咆哮！

### 2. 数据类型帧问题
在你的 `Stack` 和 `Vector` 类中，我们看到了 `DataType` 和 `T` 这两个神秘的字符，但并没有具体定义它们。请确保在模板声明中定义好数据类型。

1. template<typename DataType>

复制代码

和

1. template<typename T>

复制代码

这样才能让编译器知道你指的是哪个类型，避免在计算机眼中显得你像个不知所措的小白鼠。

### 3. 内存分配错误
在构造函数中，你使用 `new DataType;`，这会分配一个单独的对象，而不是一个数组。应该用 `new DataType[stacksize];` 来分配一个大小为 `stacksize` 的数组。这就像买了一个大冰箱却只放进去一个冰淇淋球，那可就太浪费空间了！

### 4. 解构函数中的错误
在解构函数中，应该用 `delete[] items;` 而不是 `delete items;`，以正确释放数组分配的内存。人不能随便吃东西，电脑也不能随便“回收”内存。

### 5. 其他小问题
- 在 `push` 方法中，应使用 `items[top++] = item;`，而不是 `items = item;`，否则你只是在交换内存地址，根本没把新元素放进栈里。
- `pop` 方法中，应该使用 `item = items[--top];` 以此返回最新的元素，同时减少栈顶的索引。

### 6. 语法错误
在 `resize` 函数中，你有个小错误。你需要用 `if (size > len)` 而不是 `if (size len)`。记住，在编程中，符号“>”就像是个大喇叭，能帮你发出清晰的信号。

### 7. `operator` 重载
`operator(int i)` 是不正确的。请把它改成 `operator[](int i)`，因为我们在这里想实现的是下标运算符。

下面是修正后的部分代码：

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. template<typename DataType>
   
5. class Stack {
   
6. private:
   
7.     DataType* items;
   
8.     int top;
   
9.     int stacksize;
   
10. public:
    
11.     Stack(int size = 3) : stacksize(size), top(0) {
    
12.         items = new DataType[stacksize];
    
13.     }
    
14.     ~Stack() {
    
15.         delete[] items;
    
16.         items = NULL;
    
17.     }
    
18.     bool isempty() const {
    
19.         return top == 0;
    
20.     }
    
21.     bool isfull() const {
    
22.         return top == stacksize;
    
23.     }
    
24.     bool push(const DataType& item) {
    
25.         if (!isfull()) {
    
26.             items[top++] = item;
    
27.             return true;
    
28.         }
    
29.         return false;
    
30.     }
    
31.     bool pop(DataType& item) {
    
32.         if (!isempty()) {
    
33.             item = items[--top];
    
34.             return true;
    
35.         }
    
36.         return false;
    
37.     }
    
38. };
    
39. 
    
40. template<typename T>
    
41. class Vector {
    
42. private:
    
43.     int len;
    
44.     T* items;
    
45. public:
    
46.     Vector(int size = 2) : len(size) {
    
47.         items = new T[len];
    
48.     }
    
49.     ~Vector() {
    
50.         delete[] items;
    
51.         items = NULL;
    
52.     }
    
53.     void resize(int size) {
    
54.         if (size > len) {
    
55.             T* newItems = new T[size];
    
56.             for (int i = 0; i < len; ++i) {
    
57.                 newItems[i] = items[i];
    
58.             }
    
59.             delete[] items;
    
60.             items = newItems;
    
61.             len = size;
    
62.         }
    
63.     }
    
64.     const T& operator[](int i) const {
    
65.         return items[i];
    
66.     }
    
67. };
    
68. 
    
69. int main() {
    
70.     Vector<std::string> vs;
    
71.     vs.push("哈哈");
    
72.     vs.push("哈哈2");
    
73.     vs.push("哈哈3");
    
74. 
    
75.     // 继续你的代码
    
76.     return 0;
    
77. }

复制代码

希望这些信息能帮到你！如果还有什么疑问，尽管问我，我可是随时待命的！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

人造人

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. template<class DataType> class Stack {
   
5. private:
   
6.     DataType *items;
   
7.     int top = 0;
   
8.     int stacksize;
   
9. 
   
10. public:
    
11.     Stack(int size = 3): items(new DataType[size]), stacksize(size) {}
    
12.     ~Stack() {delete[] items;}
    
13.     bool isempty() const {return top == 0;}
    
14.     bool isfull() const {return top == stacksize;}
    
15.     bool push(const DataType &&item) {
    
16.         if(isfull()) return false;
    
17.         items[top++] = item;
    
18.         return true;
    
19.     }
    
20.     bool pop(DataType &item) {
    
21.         if(isempty()) return false;
    
22.         item = items[--top];
    
23.         return true;
    
24.     }
    
25. };
    
26. 
    
27. int main() {
    
28.     Stack<std::string> s;
    
29.     std::string x;
    
30.     s.push("1234");
    
31.     s.push("abcd");
    
32.     s.pop(x);
    
33.     std::cout << x << std::endl;
    
34.     s.pop(x);
    
35.     std::cout << x << std::endl;
    
36. }
    

复制代码