So I have a project due tuesday, it didn't seem too difficult, but when I sent my teacher my errors which are as follows
In file included from indexList.h:78,
from indexListApp.cpp:9:
*indexList.cpp:33: error: ISO C++ forbids declaration of `operator=' with no type*
indexList.cpp:33: error: prototype for `int indexList<T>::operator=(const indexList<T>&)' does not match any in class `indexList<T>'
indexList.h:28: error: candidate is: indexList<T>& indexList<T>::operator=(const indexList<T>&)
indexList.cpp:33: error: template definition of non-template `int indexList<T>::operator=(const indexList<T>&)'
She then replied
The prototype for the operator= is wrong. There should not be a T before the indexList on the return type
I've e-mailed her back but she has stopped replying, I don't know if anyone here will understand what she meant, as far as I can tell the operator= is right, it says there shouldn't be a T before the indexList on the return type, so I removed a T that was in front of the assignment operator overloader function. Removing that T creating the error with * * on either both sides of it, with the T there, the * * error doesn't appear
This is my header file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
#include <iostream>
using namespace std;
#ifndef INDEXLIST_H
#define INDEXLIST_H
template <class T>
class indexList
{
public:
indexList(int size = 10);
indexList(const indexList &rhs);
~indexList();
indexList &operator=(const indexList &rhs);
//Adds element to the end of the list
//If array is full, returns false
bool append(T value);
//Inserts an element at index indx, if indx valid
//moves values up before inserting
//If indx is invalid, returns false
bool insert(int indx, T value);
//Replaces the value at indx if indx is valid
//IF indx is not value, returns false
bool replace(int indx, T newValue);
//Removes a value from a specific indx, if indx valid
//remaining values are moved down
//IF indx not valid, return false
bool remove(int indx);
//Searchs for the value in the array
//Returns indx if found, -1 if not found
int search(T value) const;
//getSize
//Returns the number of elements currently in
//the array
int getSize() const;
private:
T *list;
int numberOfElements;
int maxSize;
};
//<< stream operator will write out the entire list
template <class T>
ostream &operator<<(ostream &outStream, const indexList<T> &lst);
#include "indexList.cpp"
#endif
|
And this is the implementation file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
#include "indexList.h"
#include <iostream>
using namespace std;
//constuctor:
template <class T>
indexList<T>::indexList(int size)
{
numberOfElements = 0;
maxSize = size;
list = new T[maxSize];
}
//copy constructor
template <class T>
indexList<T>::indexList(const indexList& rhs)
{
maxSize = rhs.maxSize;
numberOfElements = rhs.numberOfElements;
list = new T[maxSize];
*this = rhs; //creates deep copy
}
//overloading assignment operator
template <class T>
indexList<T>::operator=(const indexList& rhs)
{
if (this != &rhs);
{
maxSize = rhs.maxSize;
numberOfElements = rhs.numberOfElements;
delete[]list;
list = new T[maxSize];
for(int i = 0; i < maxSize; i++)
{
list[i] = rhs.List[i];
}
return *this;
}
}
template <class T>
indexList<T>::~indexList()
{
delete list;
}
//append
//Adds element to the end of the list
//If array is full, returns false
template <class T>
bool indexList<T>::append(T value)
{
if (maxSize > numberOfElements)
{
list[numberOfElements] = value;
numberOfElements ++;
return true;
}
else
return false;
}
//insert
//Inserts an element at index indx, if indx valid
//moves values up before inserting
//If indx is invalid, returns false
template <class T>
bool indexList<T>::insert(int indx, T value)
{
if (indx >= 0 && indx < numberOfElements && numberOfElements < maxSize)
{
for (int i=numberOfElements; i>indx; i--)
list[i] = list[i-1];
list[indx] = value;
numberOfElements ++;
return true;
}
else
return false;
}
//replace
//Replaces the value at indx if indx is valid
//IF indx is not value, returns false
template <class T>
bool indexList<T>::replace(int indx, T newValue)
{
if (indx >= 0 && indx <numberOfElements)
{
list[indx] = newValue;
return true;
}
else
return false;
}
//retrieve
//Retrieves the value at index indx, if indx valid
//If indx is not valid, returns false
template <class T>
bool indexList<T>::retrieve(int indx, T &value) const
{
if (indx >= 0 && indx < numberOfElements)
{
value = list[indx];
return true;
}
else
return false;
}
//remove
//Removes a value from a specific indx, if indx valid
//remaining values are moved down
//IF indx not valid, return false
template <class T>
bool indexList<T>::remove(int indx)
{
if (indx >= 0 && indx < numberOfElements)
{
for (int i= indx; i < numberOfElements-1; i++)
list[i] = list[i+1];
numberOfElements --;
return true;
}
else
return false;
}
//search
//Searchs for the value in the array
//Returns indx if found, -1 if not found
template <class T>
int indexList<T>::search(T value) const
{
for (int i=0; i<numberOfElements; i++)
{
if (list[i] == value)
return i;
}
return -1;
}
//getSize
//Returns the number of elements currently in
//the array
template <class T>
int indexList<T>::getSize() const
{
return numberOfElements;
}
//<< stream operator writes out entire list
template <class T>
ostream &operator<<(ostream &out, const indexList<T> &lst)
{
T element;
int count = lst.getSize();
for (int j=0; j<count; j++)
{
lst.retrieve(j, element);
out << "[" << j << "] " << element << endl;
}
return out;
}
|
If anyone has any idea, I would greatly appreciate it!
