Assertion failed:in>>data 报错abort() has been called

小易zjy

在进行数据结构课程设计时，所需排序的数据(ele类:其中Word存放单词信息，Num存放单词个数)包含多个信息（单词、单词个数），为了将待排序的数据按照单词个数进行排序，设计了存放待排序元素的数据表类datalist.
但是在进行文件读写时出现了Assertion failed:in>>data  报错abort() has been called的错误，查阅CSDN上相关资料，可能是调用了野指针或是内存泄露，看得云里雾里也不知道该怎么解决呜呜呜
报错信息在datalist.h line 79 小菜鸟一枚，麻烦各位大佬了（或者有没有更合适的数据结构可以实现包含多个数据类型的结构体按照某一关键字的排序呢）
datalist.h

1. #pragma once
   
2. #ifndef DATALIST_H
   
3. #define DATALIST_H
   
4. #include <iostream>
   
5. #include <cassert>
   
6. #include"ele.h"
   
7. using namespace std;
   
8. 
   
9. const int DefaultSize = 50;
   
10. 
    
11. template <typename E, typename K>class dataList {
    
12. public:
    
13.         dataList(int sz = DefaultSize) {
    
14.                 maxSize = sz;
    
15.                 currentSize = 0;
    
16.                 Element = new E[sz];
    
17.                 assert(Element);
    
18.         }
    
19.         dataList(dataList<E, K>& R) {
    
20.                 maxSize = R.maxSize;
    
21.                 currentSize = R.currentSize;
    
22.                 Element = new E[maxSize];
    
23.                 assert(Element);
    
24.                 for (int i = 0; i < currentSize; i++) {
    
25.                         Element[i] = R.Element[i];
    
26.                 }
    
27.         }
    
28.         virtual ~dataList() {
    
29.                 delete[]Element;
    
30.         }
    
31.         virtual int Length() {
    
32.                 return currentSize;
    
33.         }
    
34.         virtual bool SeqSearch(const K k1)const;
    
35.         virtual void keySearch(const K k1)const;
    
36.         virtual int keyCount(const K k1)const;
    
37.         void newDatalist(const K k1, dataList<E, K>& R);
    
38.         virtual void repeatSearch(const K k1)const;
    
39.         virtual bool Insert(E& e1);
    
40.         virtual bool Remove(K k1, E& e1);
    
41.         char least();
    
42.         void Swap(E& x, E& y) {
    
43.                 E temp = x;
    
44.                 x = y;
    
45.                 y = temp;
    
46.         }
    
47.         void Swap(int x, int y) {//#重载
    
48.                 E temp = Element[x];
    
49.                 Element[x] = Element[y];
    
50.                 Element[y] = temp;
    
51.         }
    
52.         E& display(int x)
    
53.         {
    
54.                 return Element[x];
    
55.         }
    
56.         dataList<E, K>& operator = (dataList<E, K>& R) {
    
57.                 maxSize = R.maxSize;
    
58.                 currentSize = R.currentSize;
    
59.                 Element = new E[maxSize];
    
60.                 assert(Element);
    
61.                 for (int i = 0; i < currentSize; i++) {
    
62.                         Element[i] = R.Element[i];
    
63.                 }
    
64.                 return *this;
    
65.         }
    
66.         E& operator [] (int i) {
    
67.                 return Element[i];
    
68.         }
    
69.         int Partition(const int low, const int high);
    
70.         friend ostream& operator << (ostream& out, dataList<E, K>& R) {
    
71.                 for (int i = 0; i < R.currentSize; i++) {
    
72.                         out << R.Element[i] << endl;
    
73.                 }
    
74.                 return out;
    
75.         }
    
76.         friend istream& operator >> (istream& in, dataList<E, K>& R) {
    
77.                 E data;
    
78.                 while (!in.eof()) {
    
79.                         assert(in >> data);
    
80.                         R.Insert(data);
    
81.                 }
    
82.                 return in;
    
83.         }
    
84. protected:
    
85.         E* Element;
    
86.         int maxSize, currentSize;
    
87. };
    
88. 
    
89. template <typename E, typename K >bool dataList<E, K>::Insert(E& e1) {
    
90.         if (currentSize == maxSize) {
    
91.                 return false;
    
92.         }
    
93.         Element[currentSize] = e1;
    
94.         currentSize++;
    
95.         return true;
    
96. }
    
97. 
    
98. template <typename E, typename K>bool dataList<E, K>::Remove(K k1, E& e1) {
    
99.         if (currentSize == 0) {
    
100.                 return false;
     
101.         }
     
102.         int i;
     
103.         for (i = 0; i < currentSize && Element[i] != k1; i++);
     
104.         if (i == currentSize) {
     
105.                 return false;
     
106.         }
     
107.         e1 = Element[i];
     
108.         Element[i] = Element[currentSize - 1];
     
109.         currentSize--;
     
110.         return true;
     
111. }
     
112. 
     
113. template <typename E, typename K>bool dataList<E, K>::SeqSearch(const K k1)const {
     
114.         int i;
     
115.         for (i = 0; i < currentSize; i++) {
     
116.                 if (Element[i] == k1)return true;
     
117.         }
     
118.         return false;
     
119.         //return (i == currentSize) ? 0 : (i + 1);
     
120. }
     
121. 
     
122. template <typename E, typename K>void dataList<E, K>::keySearch(const K k1)const
     
123. {
     
124.         for (int i = 0; i < currentSize; i++)
     
125.         {
     
126.                 if (Element[i] == k1) { cout << Element[i] << "\t"; }
     
127.         }
     
128. }
     
129. 
     
130. template <typename E, typename K>int dataList<E, K>::keyCount(const K k1)const
     
131. {
     
132.         int num = 0;
     
133.         for (int i = 0; i < currentSize; i++)
     
134.         {
     
135.                 if (Element[i] == k1) { num++; }
     
136.         }
     
137.         return num;
     
138. }
     
139. 
     
140. template <typename E, typename K> void dataList<E, K>::newDatalist(const K k1, dataList<E, K>& R)
     
141. {
     
142.         for (int i = 0; i < currentSize; i++)
     
143.         {
     
144.                 if (Element[i] == k1)R.Insert(Element[i]);
     
145.         }
     
146. }
     
147. 
     
148. template <typename E, typename K>void dataList<E, K>::repeatSearch(const K k1)const
     
149. {
     
150.         for (int i = 0; i < currentSize; i++)
     
151.         {
     
152.                 if (Element[i] == k1)cout << Element[i] << "\t"; /*return Element[i];*/
     
153.         }
     
154.         //return (i == currentSize) ? 0 : (i + 1);
     
155. }
     
156. 
     
157. template <typename E, typename K>char dataList<E, K>::least()
     
158. {
     
159.         char least = 'a';
     
160.         int count = keyCount('a');
     
161.         for (char x = 'b'; x <= 'z'; x++)
     
162.         {
     
163.                 if ((keyCount(x) < count) && keyCount(x) != 0) { count = keyCount(x); least = x; }
     
164.         }
     
165.         return least;
     
166.         //leastSearch(Initial, least);
     
167.         //return (i == currentSize) ? 0 : (i + 1);
     
168. }
     
169. 
     
170. template <typename E, typename K>int dataList<E, K>::Partition(const int low, const int high) {
     
171.         //数据表类的共有函数
     
172.         int pivotpos = low;
     
173.         E pivot = Element[low];          //基准元素
     
174.         for (int i = low + 1; i <= high; i++) {
     
175.                 //检测整个序列, 进行划分
     
176.                 if (Element[i] < pivot) {
     
177.                         pivotpos++;
     
178.                         if (pivotpos != i) {
     
179.                                 Swap(Element[pivotpos], Element[i]);
     
180.                         }
     
181.                 }//小于基准的交换到左侧去
     
182.         }
     
183.         Element[low] = Element[pivotpos];
     
184.         Element[pivotpos] = pivot;        //将基准元素就位       
     
185.         return pivotpos;                        //返回基准元素位置
     
186. }
     
187. 
     
188. #endif

复制代码

ele.h

1. #pragma once
   
2. #include <string>
   
3. #include <cassert>
   
4. #include <iomanip>
   
5. #include <iostream>
   
6. using namespace std;
   
7. 
   
8. class ele {
   
9. public:
   
10.         int key;
    
11.         ele(int num = 0, string word = " ") {
    
12.                 Num = num;
    
13.                 Word = word;
    
14.                 key = Num;
    
15.         }
    
16.         ele(ele& pr) {
    
17.                 Num = pr.Num;
    
18.                 Word = pr.Word;
    
19.                 key = Num;
    
20.         }
    
21.         int getKey() {
    
22.                 return key;
    
23.         }
    
24.         void setKey(int k1) {
    
25.                 key = k1;
    
26.         }
    
27.         int getNum() {
    
28.                 return Num;
    
29.         }
    
30.         void setNum(int num) {
    
31.                 Num = num;
    
32.         }
    
33.         string getWord() {
    
34.                 return Word;
    
35.         }
    
36.         void setWord(string word) {
    
37.                 Word = word;
    
38.         }
    
39.         ele& operator = (const ele& pr) {
    
40.                 Num = pr.Num;
    
41.                 Word = pr.Word;
    
42.                 key = Num;
    
43.                 return *this;
    
44.         }
    
45.         ele& operator = (int k1) {
    
46.                 Num = k1;
    
47.                 key = Num;
    
48.                 return *this;
    
49.         }
    
50. 
    
51.         friend bool operator < (const ele& pr, int k1) {
    
52.                 return (pr.Num < k1);
    
53.         }
    
54.         friend bool operator <= (const ele& pr, int k1) {
    
55.                 return (pr.Num <= k1);
    
56.         }
    
57.         friend bool operator > (const ele& pr, int k1) {
    
58.                 return (pr.Num > k1);
    
59.         }
    
60.         friend bool operator >= (const ele& pr, int k1) {
    
61.                 return (pr.Num >= k1);
    
62.         }
    
63.         friend bool operator == (const ele& pr, int k1) {
    
64.                 return (pr.Num == k1);
    
65.         }
    
66.         friend bool operator != (const ele& pr, int k1) {
    
67.                 return (pr.Num != k1);
    
68.         }
    
69. 
    
70.         friend bool operator < (int k1, const ele& pr) {
    
71.                 return (k1 < pr.Num);
    
72.         }
    
73.         friend bool operator <= (int k1, const ele& pr) {
    
74.                 return (k1 <= pr.Num);
    
75.         }
    
76.         friend bool operator > (int k1, const ele& pr) {
    
77.                 return (k1 > pr.Num);
    
78.         }
    
79.         friend bool operator >= (int k1, const ele& pr) {
    
80.                 return (k1 >= pr.Num);
    
81.         }
    
82.         friend bool operator == (int k1, const ele& pr) {
    
83.                 return (k1 == pr.Num);
    
84.         }
    
85.         friend bool operator != (int k1, const ele& pr) {
    
86.                 return (k1 != pr.Num);
    
87.         }
    
88. 
    
89.         friend bool operator < (const ele& pr1, const ele& pr2) {
    
90.                 return (pr1.Num < pr2.Num);
    
91.         }
    
92.         friend bool operator <= (const ele& pr1, const ele& pr2) {
    
93.                 return (pr1.Num < pr2.Num);
    
94.         }
    
95.         friend bool operator > (const ele& pr1, const ele& pr2) {
    
96.                 return (pr1.Num > pr2.Num);
    
97.         }
    
98.         friend bool operator >= (const ele& pr1, const ele& pr2) {
    
99.                 return (pr1.Num >= pr2.Num);
    
100.         }
     
101.         friend bool operator == (const ele& pr1, const ele& pr2) {
     
102.                 return (pr1.Num == pr2.Num);
     
103.         }
     
104.         friend bool operator != (const ele& pr1, const ele& pr2) {
     
105.                 return (pr1.Num != pr2.Num);
     
106.         }
     
107.         friend ostream& operator << (ostream& out, ele& pr) {
     
108.                 out << pr.Word << '\t';
     
109.                 return out;
     
110.         }
     
111.         friend istream& operator >> (istream& in, ele& pr) {
     
112.                 in >> pr.Num >> pr.Word;
     
113.                 pr.key = pr.Num;
     
114.                 return in;
     
115.         }
     
116. private:
     
117.         int Num;
     
118.         string Word;
     
119. };

复制代码

main.cpp

1. #include <sstream>
   
2. #include <fstream>
   
3. #include <cassert>
   
4. #include<iostream>
   
5. #include<string.h>
   
6. #include<algorithm>
   
7. #include"datalist.h"
   
8. #include"ele.h"
   
9. using namespace std;
   
10. int main
    
11. {
    
12. dataList<ele, int>list1;
    
13.     remove("test.txt");
    
14.     for (int j = 0; j < 10; j++)
    
15.    {
    
16.         ofstream ofs;
    
17.         ofs.open("test.txt", ios::out | ios::app);
    
18.         ofs << j << " " << "string" << endl;
    
19.         ofs.close();
    
20.     }
    
21.     ifstream fin2;
    
22.     fin2.open("test.txt");
    
23.     assert(fin2 >> list1);
    
24.     fin2.close();
    
25.     cout << list1 << endl;
    
26.     return 0;
    
27. }

复制代码

小易zjy

我觉得datalist.h和ele.h写的都没有问题，应该就是文件读写的时候出错了