[已解决]没有找到接受“SeqList<int>”类型的右操作数的运算符(或没有可接受的转换)

小易zjy

等号处报错，但我觉着赋值运算符重载没问题啊，两边都是同样类型的，有大佬知道原因嘛（main.cpp的55行报错

1. L = mul(list1, list2);

复制代码

）
//Seqlist.h

1. #pragma once
   
2. #ifndef SEQLIST_H
   
3. #define SEQLIST_H
   
4. 
   
5. #include <iostream>
   
6. #include <cstdlib>
   
7. #include <cassert>
   
8. #include<string>
   
9. using namespace std;
   
10. 
    
11. const int defaultSize = 100;
    
12. 
    
13. template <typename T>class SeqList {
    
14.         friend string multiply(string num1, string num2);
    
15.         friend        SeqList<T> mul(const SeqList<T> & list1,const SeqList<T> &list2);
    
16. protected:
    
17.         T* data;//存放数组
    
18.         int maxSize;//最大可容纳表项的项数
    
19.         int last;//当前已存表项的最后位置（从0开始）
    
20. public:
    
21. 
    
22.         SeqList(int sz = defaultSize);//构造函数
    
23.         SeqList(SeqList<T>& L);//复制构造函数
    
24.         ~SeqList() {
    
25.                 delete[]data;
    
26.         }
    
27.         void reSize(int newSize);
    
28.         int Size() const {
    
29.                 return maxSize;
    
30.         }
    
31.         int Length()const {
    
32.                 return last + 1;
    
33.         }
    
34.         int Search(T& x) const;
    
35.         int Locate(int i) const;
    
36.         bool getData(int i, T& x) const {//改
    
37.                 if (i > 0 && i <= last + 1) {
    
38.                         x = data[i - 1];
    
39.                         return true;
    
40.                 }
    
41.                 else return false;
    
42.         }
    
43. 
    
44.         void setData(int i, T& x) {
    
45.                 if (i > 0 && i <= last + 1) {
    
46.                         data[i - 1] = x;
    
47.                 }
    
48.         }
    
49.         bool Insert(int i, T& x);
    
50.         bool Remove(int i, T& x);
    
51.         bool IsEmpty() {
    
52.                 return (last == -1);
    
53.         }
    
54.         bool IsFull() {
    
55.                 return (last == maxSize - 1);
    
56.         }
    
57.         void Sort();
    
58.         void input();
    
59.         void output();
    
60.         SeqList<T> operator = (SeqList<T>& L);
    
61.         friend istream& operator >> (istream& in, SeqList<T>& R) {
    
62.                 R.last = -1;//先清空
    
63.                 while (!in.eof()) {
    
64.                         R.last++;
    
65.                         if (R.last == R.maxSize) R.reSize(2 * R.maxSize);
    
66.                         assert(in >> R.data[R.last]);
    
67.                 }
    
68.                 return in;
    
69.         }
    
70.         friend ostream& operator << (ostream& out, SeqList<T>& R) {
    
71.                 for (int i = 0; i <= R.last; i++) {
    
72.                         cout << "#" << i + 1 << ":\t" << R.data[i] << endl;
    
73.                 }
    
74.                 return out;
    
75.         }
    
76. };
    
77. 
    
78. template <typename T>SeqList<T>::SeqList(int sz) {
    
79.         if (sz > 0) {
    
80.                 maxSize = sz;
    
81.                 last = -1;
    
82.                 data = new T[maxSize];
    
83.                 if (data == NULL) {
    
84.                         cerr << "Memory allocating error!" << endl;
    
85.                         exit(1);
    
86.                 }
    
87.         }
    
88. }
    
89. 
    
90. template <typename T>SeqList<T>::SeqList(SeqList<T>& L) {
    
91.         maxSize = L.Size();
    
92.         last = L.Length() - 1;
    
93.         T value;
    
94.         data = new T[maxSize];
    
95.         if (data == NULL)
    
96.         {
    
97.                 cerr << "Memory allocating error!" << endl;
    
98.                 exit(1);
    
99.         }
    
100.         for (int i = 1; i <= last + 1; i++)
     
101.         {
     
102.                 L.getData(i, value); data[i - 1] = value;
     
103.         };
     
104. }
     
105. 
     
106. template<typename T>void SeqList<T>::reSize(int newSize) {
     
107.         if (newSize <= 0) {
     
108.                 cerr << "Invalid array index!" << endl;
     
109.                 return;
     
110.         }
     
111.         if (newSize != maxSize) {
     
112.                 T* newarray = new T[newSize];//建立新数组
     
113.                 if (newarray == NULL) {
     
114.                         cerr << "Memory allocating error!" << endl;
     
115.                         exit(1);
     
116.                 }
     
117.                 int n = last + 1;//改
     
118.                 T* srcptr = data;//源数组首地址
     
119.                 T* destptr = newarray;//目的数组首地址
     
120.                 while (n--)        *destptr++ = *srcptr++;//复制
     
121.                 delete[]data;//删老数组
     
122.                 data = newarray;//复制新数组
     
123.                 maxSize = newSize;
     
124.         }
     
125. }
     
126. 
     
127. template<typename T>int SeqList<T>::Search(T& x)const {
     
128.         for (int i = 0; i <= last; i++) {
     
129.                 if (data[i] == x)        return i + 1;
     
130.         }
     
131.         return 0;
     
132. }
     
133. 
     
134. template<typename T>int SeqList<T>::Locate(int i)const {
     
135.         if (i >= 1 && i <= last + 1)        return i;
     
136.         else        return 0;
     
137. }
     
138. 
     
139. template<typename T>bool SeqList<T>::Insert(int i, T& x) {
     
140.         if (last == maxSize - 1)        return false;
     
141.         if (i < 0 || i > last + 1) return false;
     
142.         for (int j = last; j >= i; j--)        data[j + 1] = data[j];
     
143.         data[i] = x;
     
144.         last++;
     
145.         return true;
     
146. }
     
147. 
     
148. template<typename T>bool SeqList<T>::Remove(int i, T& x) {
     
149.         if (last == -1)        return false;
     
150.         if (i < 1 || i > last + 1) return false;
     
151.         x = data[i - 1];
     
152.         for (int j = i; j <= last; j++)        data[j - 1] = data[j];
     
153.         last--;
     
154.         return true;
     
155. }
     
156. 
     
157. template<typename T>void SeqList<T>::Sort() {
     
158.         for (int i = 1; i <= last; i++) {
     
159.                 for (int j = last; j >= i; j--) {
     
160.                         if (data[j - 1] > data[j]) {
     
161.                                 T tmp = data[j - 1];
     
162.                                 data[j - 1] = data[j];
     
163.                                 data[j] = tmp;
     
164.                         }
     
165.                 }
     
166.         }
     
167. }
     
168. 
     
169. template<typename T>void SeqList<T>::input() {
     
170.         cout << "Input the size of the list which will be created:";
     
171.         while (1) {
     
172.                 assert(cin >> last);
     
173.                 last--;
     
174.                 if (last < 0) {
     
175.                         cout << "Input error, the size must be positive!\n";
     
176.                         cout << "Input the size again:";
     
177.                 }
     
178.                 else if (last > maxSize - 1) {//改一改可以扩大
     
179.                         cout << "Input error, the size must be less than maxSize!\n";
     
180.                         cout << "Input the size again:";
     
181.                 }
     
182.                 else        break;
     
183.         }
     
184.         cout << "\nInput the data for each element to create the list:" << endl;
     
185.         for (int i = 0; i <= last; i++) {
     
186.                 cout << "#" << i + 1 << ":";
     
187.                 assert(cin >> data[i]);
     
188.         }
     
189. }
     
190. 
     
191. template<typename T>void SeqList<T>::output() {
     
192.         cout << "\nThe size of the list is:" << last + 1 << endl;
     
193.         for (int i = 0; i <= last; i++)        cout << "#" << i + 1 << ":\t" << data[i] << endl;
     
194. }
     
195. 
     
196. //SeqList<T> operator = (SeqList<T>& L);
     
197. template<typename T>SeqList<T> SeqList<T>::operator = (SeqList<T>& L) {//改
     
198.         T value;
     
199.         maxSize = L.Size();
     
200.         last = L.Length() - 1;
     
201.         delete[]data;//先清空
     
202.         data = new T[maxSize];
     
203.         if (data == NULL) {
     
204.                 cerr << "Memory allocating error!" << endl;
     
205.                 exit(1);
     
206.         }
     
207.         for (int i = 1; i <= last + 1; i++)
     
208. 
     
209.         {
     
210.                 L.getData(i, value);
     
211.                 data[i - 1] = value;
     
212.         }
     
213.         return *this;
     
214. }
     
215. 
     
216. #endif

复制代码

//main.cpp

1. #include <iostream>
   
2. #include "SeqList.h"
   
3. #include<string>
   
4. #include <fstream>
   
5. #include <cassert>
   
6. using namespace std;
   
7. 
   
8. template<typename T>
   
9. SeqList<T> mul(const SeqList<T>& list1,const SeqList<T>& list2)
   
10. {
    
11.         SeqList<int> list3(list1.Size() + list2.Size());//初始化结果的最大长度，用list3保存。乘法得到数字的位数一定不超过乘数位数之和
    
12.         for(int i=0;i<list1.Size();i++)
    
13.                 for(int j=0;j<list2.Size();j++)
    
14.                 {
    
15.                         int x,y;
    
16.                         list1.getData(i, x);
    
17.                         list2.getData(j, y);
    
18.                         int z=0;
    
19.                         z += x * y;
    
20.                         list3.setData(i + j, z);
    
21.                 }
    
22. 
    
23.         int t = 0;
    
24.         for (int i = 0; i < list3.Size(); i++)//处理进位
    
25.         {
    
26.                 int p;
    
27.                 list3.getData(i, p);
    
28.                 t += p;
    
29.                 int m = t % 10;
    
30.                 list3.setData(i, m);
    
31.                 t /= 10;
    
32.         }
    
33. 
    
34.         while (list3.Size() > 1 && (list3.last) == 0)//初始时结果的最高位为0，若最终最高位仍为0，去掉最高位的0
    
35.         {
    
36.                 int q;
    
37.                 list3.Remove(list3.last, q);
    
38.         }
    
39.         return list3;
    
40. }
    
41. 
    
42. string multiply(string num1, string num2) {
    
43.         //num1="123"
    
44.         SeqList<int>list1,list2;
    
45.         for(int i=num1.size()-1;i>=0;i--)
    
46.         {
    
47.                 int x = num1[i] - '0';
    
48.                 list1.setData(list1.last, x);
    
49.         }//list1=[3,2,1] 倒序输出
    
50.         for (int i = num2.size() - 1; i >= 0; i--)
    
51.         {
    
52.                 int y = num2[i] - '0';
    
53.                 list2.setData(list2.last, y);
    
54.         }
    
55.         SeqList<int> L;
    
56.         L = mul(list1, list2);
    
57.        
    
58. 
    
59.         string res = "";
    
60.         for (int i = L.Size() - 1; i >= 0; i--)
    
61.         {
    
62.                 int p;
    
63.                 res += to_string(L.getData(i, p));
    
64.         }
    
65. 
    
66.         return res;
    
67. }
    
68. 
    
69. int main() {
    
70.         SeqList<int>l1, l2, l3;
    
71. }

复制代码

最佳答案

月排行榜 / 总排行榜

lhgzbxhz

2021-11-29 21:03:21

典型的左右值不分问题
operator=()函数签名里写的的是一个SeqList<T>&类型的参数，接收一个左值引用
然而调用时mul()函数返回的是一个临时变量，也就是一个右值，无法进行转换
operator=()重载是有规则的，复制赋值运算符就写const SeqList<T>& ,移动赋值运算符就写SeqList<T>&& ,你这样SeqList<T>&显得不伦不类。
（关于移动赋值运算符和复制赋值运算符的区别，这个讲起来没完没了，建议上百度深入了解一下）
如果不想了解就无脑改成const SeqList<T>&

跳转到最佳答案楼层

小易zjy

1>D:\C++\作业1 顺序表\Project3\源.cpp(55,23): error C2679: 二元“=”: 没有找到接受“SeqList<int>”类型的右操作数的运算符(或没有可接受的转换)
1>D:\C++\作业1 顺序表\Project3\SeqList.h(60,13): message : 可能是“SeqList<int> SeqList<int>::operator =(SeqList<int> &)”
1>D:\C++\作业1 顺序表\Project3\源.cpp(55,23): message : 尝试匹配参数列表“(SeqList<int>, SeqList<int>)”时

人造人

这是什么？一个字符串减一个字符？

小易zjy

人造人 发表于 2021-11-28 17:01
这是什么？一个字符串减一个字符？

我代码复制过来的时候出错了，应该是这样的int y = num2 [ i ] -  '0';
不好意思

傻眼貓咪

路过学习

人造人

少了 operator= 函数

1. // Seqlist.h
   
2. //#pragma once
   
3. #ifndef SEQLIST_H
   
4. #define SEQLIST_H
   
5. 
   
6. #include <cassert>
   
7. #include <cstdlib>
   
8. #include <iostream>
   
9. #include <string>
   
10. 
    
11. using namespace std;
    
12. 
    
13. const int defaultSize = 100;
    
14. 
    
15. template <typename T> class SeqList {
    
16.     friend string multiply(string num1, string num2);
    
17.     friend SeqList<T> mul(const SeqList<T> &list1, const SeqList<T> &list2);
    
18. 
    
19.   protected:
    
20.     T *data;     //存放数组
    
21.     int maxSize; //最大可容纳表项的项数
    
22.     int last;    //当前已存表项的最后位置（从0开始）
    
23.   public:
    
24. 
    
25. 
    
26.     SeqList<T> &operator=(const SeqList<T> &rhs) {
    
27.         // ...
    
28.         return *this;
    
29.     }
    
30. 
    
31. 
    
32. 
    
33. 
    
34.     SeqList(int sz = defaultSize); //构造函数
    
35.     SeqList(SeqList<T> &L);        //复制构造函数
    
36.     ~SeqList() { delete[] data; }
    
37.     void reSize(int newSize);
    
38.     int Size() const { return maxSize; }
    
39.     int Length() const { return last + 1; }
    
40.     int Search(T &x) const;
    
41.     int Locate(int i) const;
    
42.     bool getData(int i, T &x) const { //改
    
43.         if(i > 0 && i <= last + 1) {
    
44.             x = data[i - 1];
    
45.             return true;
    
46.         } else
    
47.             return false;
    
48.     }
    
49. 
    
50.     void setData(int i, T &x) {
    
51.         if(i > 0 && i <= last + 1) {
    
52.             data[i - 1] = x;
    
53.         }
    
54.     }
    
55.     bool Insert(int i, T &x);
    
56.     bool Remove(int i, T &x);
    
57.     bool IsEmpty() { return (last == -1); }
    
58.     bool IsFull() { return (last == maxSize - 1); }
    
59.     void Sort();
    
60.     void input();
    
61.     void output();
    
62.     SeqList<T> operator=(SeqList<T> &L);
    
63.     friend istream &operator>>(istream &in, SeqList<T> &R) {
    
64.         R.last = -1; //先清空
    
65.         while(!in.eof()) {
    
66.             R.last++;
    
67.             if(R.last == R.maxSize)
    
68.                 R.reSize(2 * R.maxSize);
    
69.             assert(in >> R.data[R.last]);
    
70.         }
    
71.         return in;
    
72.     }
    
73.     friend ostream &operator<<(ostream &out, SeqList<T> &R) {
    
74.         for(int i = 0; i <= R.last; i++) {
    
75.             cout << "#" << i + 1 << ":\t" << R.data << endl;
    
76.         }
    
77.         return out;
    
78.     }
    
79. };
    
80. 
    
81. template <typename T> SeqList<T>::SeqList(int sz) {
    
82.     if(sz > 0) {
    
83.         maxSize = sz;
    
84.         last = -1;
    
85.         data = new T[maxSize];
    
86.         if(data == NULL) {
    
87.             cerr << "Memory allocating error!" << endl;
    
88.             exit(1);
    
89.         }
    
90.     }
    
91. }
    
92. 
    
93. template <typename T> SeqList<T>::SeqList(SeqList<T> &L) {
    
94.     maxSize = L.Size();
    
95.     last = L.Length() - 1;
    
96.     T value;
    
97.     data = new T[maxSize];
    
98.     if(data == NULL) {
    
99.         cerr << "Memory allocating error!" << endl;
    
100.         exit(1);
     
101.     }
     
102.     for(int i = 1; i <= last + 1; i++) {
     
103.         L.getData(i, value);
     
104.         data[i - 1] = value;
     
105.     };
     
106. }
     
107. 
     
108. template <typename T> void SeqList<T>::reSize(int newSize) {
     
109.     if(newSize <= 0) {
     
110.         cerr << "Invalid array index!" << endl;
     
111.         return;
     
112.     }
     
113.     if(newSize != maxSize) {
     
114.         T *newarray = new T[newSize]; //建立新数组
     
115.         if(newarray == NULL) {
     
116.             cerr << "Memory allocating error!" << endl;
     
117.             exit(1);
     
118.         }
     
119.         int n = last + 1;      //改
     
120.         T *srcptr = data;      //源数组首地址
     
121.         T *destptr = newarray; //目的数组首地址
     
122.         while(n--)
     
123.             *destptr++ = *srcptr++; //复制
     
124.         delete[] data;              //删老数组
     
125.         data = newarray;            //复制新数组
     
126.         maxSize = newSize;
     
127.     }
     
128. }
     
129. 
     
130. template <typename T> int SeqList<T>::Search(T &x) const {
     
131.     for(int i = 0; i <= last; i++) {
     
132.         if(data == x)
     
133.             return i + 1;
     
134.     }
     
135.     return 0;
     
136. }
     
137. 
     
138. template <typename T> int SeqList<T>::Locate(int i) const {
     
139.     if(i >= 1 && i <= last + 1)
     
140.         return i;
     
141.     else
     
142.         return 0;
     
143. }
     
144. 
     
145. template <typename T> bool SeqList<T>::Insert(int i, T &x) {
     
146.     if(last == maxSize - 1)
     
147.         return false;
     
148.     if(i < 0 || i > last + 1)
     
149.         return false;
     
150.     for(int j = last; j >= i; j--)
     
151.         data[j + 1] = data[j];
     
152.     data = x;
     
153.     last++;
     
154.     return true;
     
155. }
     
156. 
     
157. template <typename T> bool SeqList<T>::Remove(int i, T &x) {
     
158.     if(last == -1)
     
159.         return false;
     
160.     if(i < 1 || i > last + 1)
     
161.         return false;
     
162.     x = data[i - 1];
     
163.     for(int j = i; j <= last; j++)
     
164.         data[j - 1] = data[j];
     
165.     last--;
     
166.     return true;
     
167. }
     
168. 
     
169. template <typename T> void SeqList<T>::Sort() {
     
170.     for(int i = 1; i <= last; i++) {
     
171.         for(int j = last; j >= i; j--) {
     
172.             if(data[j - 1] > data[j]) {
     
173.                 T tmp = data[j - 1];
     
174.                 data[j - 1] = data[j];
     
175.                 data[j] = tmp;
     
176.             }
     
177.         }
     
178.     }
     
179. }
     
180. 
     
181. template <typename T> void SeqList<T>::input() {
     
182.     cout << "Input the size of the list which will be created:";
     
183.     while(1) {
     
184.         assert(cin >> last);
     
185.         last--;
     
186.         if(last < 0) {
     
187.             cout << "Input error, the size must be positive!\n";
     
188.             cout << "Input the size again:";
     
189.         } else if(last > maxSize - 1) { //改一改可以扩大
     
190.             cout << "Input error, the size must be less than maxSize!\n";
     
191.             cout << "Input the size again:";
     
192.         } else
     
193.             break;
     
194.     }
     
195.     cout << "\nInput the data for each element to create the list:" << endl;
     
196.     for(int i = 0; i <= last; i++) {
     
197.         cout << "#" << i + 1 << ":";
     
198.         assert(cin >> data);
     
199.     }
     
200. }
     
201. 
     
202. template <typename T> void SeqList<T>::output() {
     
203.     cout << "\nThe size of the list is:" << last + 1 << endl;
     
204.     for(int i = 0; i <= last; i++)
     
205.         cout << "#" << i + 1 << ":\t" << data << endl;
     
206. }
     
207. 
     
208. // SeqList<T> operator = (SeqList<T>& L);
     
209. template <typename T> SeqList<T> SeqList<T>::operator=(SeqList<T> &L) {
     
210.     T value;
     
211.     maxSize = L.Size();
     
212.     last = L.Length() - 1;
     
213.     delete[] data; //先清空
     
214.     data = new T[maxSize];
     
215.     if(data == NULL) {
     
216.         cerr << "Memory allocating error!" << endl;
     
217.         exit(1);
     
218.     }
     
219.     for(int i = 1; i <= last + 1; i++)
     
220. 
     
221.     {
     
222.         L.getData(i, value);
     
223.         data[i - 1] = value;
     
224.     }
     
225.     return *this;
     
226. }
     
227. 
     
228. #endif
     
229. 
     
230. // main.cpp
     
231. #include <iostream>
     
232. //#include "SeqList.h"
     
233. #include <cassert>
     
234. #include <fstream>
     
235. #include <string>
     
236. using namespace std;
     
237. 
     
238. template <typename T>
     
239. SeqList<T> mul(const SeqList<T> &list1, const SeqList<T> &list2) {
     
240.     SeqList<int> list3(list1.Size() + list2.Size());
     
241.     for(int i = 0; i < list1.Size(); i++)
     
242.         for(int j = 0; j < list2.Size(); j++) {
     
243.             int x, y;
     
244.             list1.getData(i, x);
     
245.             list2.getData(j, y);
     
246.             int z = 0;
     
247.             z += x * y;
     
248.             list3.setData(i + j, z);
     
249.         }
     
250. 
     
251.     int t = 0;
     
252.     for(int i = 0; i < list3.Size(); i++) //处理进位
     
253.     {
     
254.         int p;
     
255.         list3.getData(i, p);
     
256.         t += p;
     
257.         int m = t % 10;
     
258.         list3.setData(i, m);
     
259.         t /= 10;
     
260.     }
     
261. 
     
262.     while(list3.Size() > 1 && (list3.last) == 0) //去掉最高位的0
     
263.     {
     
264.         int q;
     
265.         list3.Remove(list3.last, q);
     
266.     }
     
267.     return list3;
     
268. }
     
269. 
     
270. string multiply(string num1, string num2) {
     
271.     SeqList<int> list1, list2;
     
272.     for(int i = num1.size() - 1; i >= 0; i--) {
     
273.         int x = num1[i] - '0';
     
274.         list1.setData(list1.last, x);
     
275.     }
     
276.     for(int i = num2.size() - 1; i >= 0; i--) {
     
277.         int y = num2[i] - '0';
     
278.         list2.setData(list2.last, y);
     
279.     }
     
280.     SeqList<int> L;
     
281.     L = mul(list1, list2); //这一行报错了
     
282. 
     
283.     string res = "";
     
284.     for(int i = L.Size() - 1; i >= 0; i--) {
     
285.         int p;
     
286.         res += to_string(L.getData(i, p));
     
287.     }
     
288. 
     
289.     return res;
     
290. }
     
291. 
     
292. int main() {
     
293.     SeqList<int> l1, l2, l3;
     
294.     return 0;
     
295. }
     

复制代码

小易zjy

人造人 发表于 2021-11-28 18:46
少了 operator= 函数

第209行开始的不是operator=嘛
还有我发现好多中括号直接复制过来格式都变了，现在都已经改过来了
之前没检查 抱歉抱歉

人造人

小易zjy 发表于 2021-11-28 18:54
第209行开始的不是operator=嘛
还有我发现好多中括号直接复制过来格式都变了，现在都已经改过 ...

你这代码写的，我有点看不懂，我找时间研究研究

小易zjy

人造人 发表于 2021-11-28 19:01
你这代码写的，我有点看不懂，我找时间研究研究

好滴好滴 感谢！

人造人

小易zjy 发表于 2021-11-28 19:06
好滴好滴 感谢！

改了一部分，剩下的函数不知道做什么用的，没法改了

1. // Seqlist.h
   
2. //#pragma once
   
3. #ifndef SEQLIST_H
   
4. #define SEQLIST_H
   
5. 
   
6. #include <cassert>
   
7. #include <cstdlib>
   
8. #include <iostream>
   
9. #include <string>
   
10. #include <cstring>
    
11. 
    
12. using namespace std;
    
13. 
    
14. const int defaultSize = 100;
    
15. 
    
16. template <typename T>
    
17. class SeqList {
    
18. protected:
    
19.     T *data;
    
20.     size_t maxSize;
    
21.     size_t size;
    
22. 
    
23.     void resize() {
    
24.         size_t size = 2 * this->maxSize;
    
25.         T *temp = new T[size];
    
26.         memcpy(temp, this->data, this->size * sizeof(T));
    
27.         delete[] this->data;
    
28.         this->data = temp;
    
29.         this->maxSize = size;
    
30.     }
    
31. public:
    
32.     SeqList(size_t sz) {
    
33.         this->maxSize = sz;
    
34.         this->data = new T[sz];
    
35.         this->size = 0;
    
36.     }
    
37.     SeqList(const SeqList<T> &L) {
    
38.         this->data = nullptr;
    
39.         this->operator=(L);
    
40.     }
    
41.     ~SeqList() {delete[] this->data;}
    
42.     bool Insert(size_t i, const T &x) {
    
43.         if(i > this->Length()) return false;
    
44.         ++this->size;
    
45.         if(this->size > this->maxSize) {
    
46.             this->resize();
    
47.         }
    
48.         for(size_t j = this->size - 1; j != i; --j) {
    
49.             this->data[j] = this->data[j - 1];
    
50.         }
    
51.         this->data[i] = x;
    
52.         return true;
    
53.     }
    
54.     bool Remove(size_t i) {
    
55.         if(i >= this->Length()) return false;
    
56.         for(size_t j = i; j < this->size - 1; ++j) {
    
57.             this->data[j] = this->data[j + 1];
    
58.         }
    
59.         --this->size;
    
60.         return true;
    
61.     }
    
62.     int Length() const {return this->size;}
    
63.     bool getData(size_t i, T &x) const {
    
64.         if(i >= this->Length()) return false;
    
65.         x = this->data[i];
    
66.         return true;
    
67.     }
    
68.     bool setData(size_t i, const T &x) {
    
69.         if(i >= this->Length()) return false;
    
70.         this->data[i] = x;
    
71.         return true;
    
72.     }
    
73.     bool IsEmpty() {return this->Length() == 0;}
    
74.     SeqList<T> operator=(const SeqList<T> &L) {
    
75.         delete[] this->data;
    
76.         this->maxSize = L.maxSize;
    
77.         this->data = new T[L.maxSize];
    
78.         this->size = L.size;
    
79.         memcpy(this->data, L.data, L.size * sizeof(T));
    
80.         return *this;
    
81.     }
    
82.     void clean() {this->size = 0;}
    
83.     bool append(const T &value) {
    
84.         return this->Insert(this->Length(), value);
    
85.     }
    
86.     friend istream &operator>>(istream &in, SeqList<T> &R) {
    
87.         R.clean();
    
88.         T value;
    
89.         while(in >> value) {
    
90.             R.append(value);
    
91.         }
    
92.         return in;
    
93.     }
    
94.     friend ostream &operator<<(ostream &out, const SeqList<T> &R) {
    
95.         for(int i = 0; i < R.Length(); i++) {
    
96.             T value; R.getData(i, value);
    
97.             cout << "#" << i + 1 << ":\t" << value << endl;
    
98.         }
    
99.         return out;
    
100.     }
     
101.     int Search(const T &x) const {
     
102.         for(size_t i = 0; i < this->Length(); i++) {
     
103.             T value; this->getData(i, value);
     
104.             if(value == x) return i;
     
105.         }
     
106.         return -1;
     
107.     }
     
108.     void Sort() {
     
109.         for(size_t i = 0; i < this->Length(); ++i) {
     
110.             for(size_t j = i + 1; j < this->Length(); ++j) {
     
111.                 T a, b;
     
112.                 this->getData(i, a);
     
113.                 this->getData(j, b);
     
114.                 if(a > b) {
     
115.                     this->setData(i, b);
     
116.                     this->setData(j, a);
     
117.                 }
     
118.             }
     
119.         }
     
120.     }
     
121. };
     
122. 
     
123. // 这个函数做什么用的？
     
124. // 判断索引i是否存在？
     
125. // 你直接调用Length函数不就可以了？
     
126. /*
     
127. template <typename T> int SeqList<T>::Locate(int i) const {
     
128.     if(i >= 1 && i <= last + 1)
     
129.         return i;
     
130.     else
     
131.         return 0;
     
132. }
     
133. */
     
134. 
     
135. // 下面这两个函数做什么用的？
     
136. /*
     
137. template <typename T> void SeqList<T>::input() {
     
138.     cout << "Input the size of the list which will be created:";
     
139.     while(1) {
     
140.         assert(cin >> last);
     
141.         last--;
     
142.         if(last < 0) {
     
143.             cout << "Input error, the size must be positive!\n";
     
144.             cout << "Input the size again:";
     
145.         } else if(last > maxSize - 1) { //改一改可以扩大
     
146.             cout << "Input error, the size must be less than maxSize!\n";
     
147.             cout << "Input the size again:";
     
148.         } else
     
149.             break;
     
150.     }
     
151.     cout << "\nInput the data for each element to create the list:" << endl;
     
152.     for(int i = 0; i <= last; i++) {
     
153.         cout << "#" << i + 1 << ":";
     
154.         assert(cin >> data);
     
155.     }
     
156. }
     
157. 
     
158. template <typename T> void SeqList<T>::output() {
     
159.     cout << "\nThe size of the list is:" << last + 1 << endl;
     
160.     for(int i = 0; i <= last; i++)
     
161.         cout << "#" << i + 1 << ":\t" << data << endl;
     
162. }
     
163. */
     
164. 
     
165. #endif
     
166. 
     
167. // main.cpp
     
168. #include <iostream>
     
169. //#include "SeqList.h"
     
170. #include <cassert>
     
171. #include <fstream>
     
172. #include <string>
     
173. 
     
174. using namespace std;
     
175. 
     
176. template <typename T>
     
177. SeqList<T> mul(const SeqList<T> &list1, const SeqList<T> &list2) {
     
178.     SeqList<int> list3(list1.Size() + list2.Size());
     
179.     for(int i = 0; i < list1.Size(); i++)
     
180.         for(int j = 0; j < list2.Size(); j++) {
     
181.             int x, y;
     
182.             list1.getData(i, x);
     
183.             list2.getData(j, y);
     
184.             int z = 0;
     
185.             z += x * y;
     
186.             list3.setData(i + j, z);
     
187.         }
     
188. 
     
189.     int t = 0;
     
190.     for(int i = 0; i < list3.Size(); i++) //处理进位
     
191.     {
     
192.         int p;
     
193.         list3.getData(i, p);
     
194.         t += p;
     
195.         int m = t % 10;
     
196.         list3.setData(i, m);
     
197.         t /= 10;
     
198.     }
     
199. 
     
200.     while(list3.Size() > 1 && (list3.last) == 0) //去掉最高位的0
     
201.     {
     
202.         int q;
     
203.         list3.Remove(list3.last, q);
     
204.     }
     
205.     return list3;
     
206. }
     
207. 
     
208. string multiply(string num1, string num2) {
     
209.     SeqList<int> list1, list2;
     
210.     for(int i = num1.size() - 1; i >= 0; i--) {
     
211.         int x = num1[i] - '0';
     
212.         list1.setData(list1.last, x);
     
213.     }
     
214.     for(int i = num2.size() - 1; i >= 0; i--) {
     
215.         int y = num2[i] - '0';
     
216.         list2.setData(list2.last, y);
     
217.     }
     
218.     SeqList<int> L;
     
219.     L = mul(list1, list2); //这一行报错了
     
220. 
     
221.     string res = "";
     
222.     for(int i = L.Size() - 1; i >= 0; i--) {
     
223.         int p;
     
224.         res += to_string(L.getData(i, p));
     
225.     }
     
226. 
     
227.     return res;
     
228. }
     
229. 
     
230. int main() {
     
231.     SeqList<int> l1, l2, l3;
     
232.     return 0;
     
233. }
     

复制代码

lhgzbxhz

典型的左右值不分问题
operator=()函数签名里写的的是一个SeqList<T>&类型的参数，接收一个左值引用
然而调用时mul()函数返回的是一个临时变量，也就是一个右值，无法进行转换
operator=()重载是有规则的，复制赋值运算符就写const SeqList<T>& ,移动赋值运算符就写SeqList<T>&& ,你这样SeqList<T>&显得不伦不类。
（关于移动赋值运算符和复制赋值运算符的区别，这个讲起来没完没了，建议上百度深入了解一下）
如果不想了解就无脑改成const SeqList<T>&