variables from base class out of scope in derived class
Apr 21, 2021 at 4:50pm UTC
So I'm practing linked lists and created two class. linkedListType is the base class and unOrderedLinkedList (unOLList) is the derived class with no new variables but the definitions of the virtual functions.
When I compile I get error says variable in base class is out of scope in the function defined in unOLList header file.
Some code are listed below. Not sure where went wrong but thank any help in advance.
header file for linkedList:
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
template <class Type>
struct nodeType
{
Type info;
nodeType<Type> * link;
};
template <class Type>
class linkedListType
{
public :
const linkedListType<Type>& operator = (const linkedListType<Type>&);
void inlitializeList();
bool isEmpty() const ;
void print() const ;
int length() const ;
void destroyList();
Type front() const ;
Type back() const ;
virtual bool search (const Type & searchItem) const = 0 ;
virtual void inserFirst (const Type & newItem ) = 0;
virtual void insertLast (const Type & newItem) = 0;
virtual void deletItem(const Type & deleteItem) = 0;
virtual void deletSmallestItem () = 0;
virtual void deleteAll (const Type& item) = 0;
linkedListIterator<Type> begin();
linkedListIterator<Type> end();
linkedListType();
linkedListType(const linkedListType<Type> & otherList);
~linkedListType();
protected :
int count;
nodeType<Type>* first;
nodeType<Type>* last;
private :
void copyList(const linkedListType<Type> & otherList) ;
};
The header file for unOLList :
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
#ifndef unorderedLinkedListType_H
#define unorderedLinkedListType_H
#include "linkedListType.h"
template <class Type>
class unOLList : public linkedListType<Type>
{
public :
bool search (const Type& searchItem) const ;
void insertFirst (const Type& newItem);
void insertLast (const Type& newItem);
void deleteItem (const Type& deleteItem);
void deletSmallestItem ();
void deleteAll (const Type& item);
};
template <class Type>
bool unOLList<Type>::search (const Type& searchItem) const
{
nodeType<Type> * current;
bool found = false ;
current = first;
while (current != nullptr && !found)
{
if (current->info == searchItem)
{
found = true ;
}
else
{
current = current->link;
}
}
return found;
}
template <class Type>
void unOLList<Type>::insertFirst (const Type& newItem)
{
nodeType<Type>* newNode;
newNode = new nodeType<Type>;
newNode->info = newItem;
newNode->link = first;
first = newNode;
if (last == nullptr )
{
last = newNode;
}
count ++ ;
}
#endif
Last edited on Apr 21, 2021 at 4:50pm UTC
Apr 21, 2021 at 4:55pm UTC
Where are the class function definitions? As this is templated code, they can't be in a separate compilation unit to main() - or from where they are used.
Apr 21, 2021 at 5:00pm UTC
The non-virtual functions are all defined in the header "linkedListType.h". Only virtual functions are defined in "unorderedLinkedListType.h". Only two filed are used which are
"linkedListType.h" and
"unorderedLinkedListType.h" .
In the test main function file, I simply put
1 2 3 4 5 6 7 8 9 10 11 12
#include <iostream>
#include "linkedListType.h"
#include "unorderedLinkedListType.h"
int main ()
{
unOLList<int > llist ;
}
and also getting "unOLList<int> llist
object of abstract class type "unOLList<int>" is not allowed: -- pure virtual function "linkedListType<Type>::inserFirst [with Type=int]" has no overrider -- pure virtual function "linkedListType<Type>::deletItem [with Type=int]" has no overrider"
for this.
Thanks, I can post all files but it will take some space.
(VS code, windos)
Last edited on Apr 21, 2021 at 5:01pm UTC
Apr 21, 2021 at 5:04pm UTC
So the original files.
"linkedListType.h"
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 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
#ifndef linkedListType_H
#define linkedListType_H
#include <iostream>
#include <cassert>
template <class Type>
struct nodeType
{
Type info;
nodeType<Type> * link;
};
template <class Type>
class linkedListIterator
{
public :
linkedListIterator();
linkedListIterator(nodeType<Type> * ptr);
Type operator * ();
linkedListIterator<Type> operator ++();
bool operator == (const linkedListIterator<Type> & right) const ;
bool operator != (const linkedListIterator<Type> & right) const ;
private :
nodeType<Type> * current;
};
template <class Type>
linkedListIterator<Type>::linkedListIterator()
{
current = nullptr ;
}
template <class Type>
linkedListIterator<Type>::linkedListIterator(nodeType<Type> * ptr)
{
current = ptr;
}
template <class Type>
Type linkedListIterator<Type>::operator * ()
{
return current->info;
}
template <class Type>
linkedListIterator<Type> linkedListIterator<Type>::operator ++()
{
current = current->link;
return current;
}
template <class Type>
bool linkedListIterator<Type>:: operator == (const linkedListIterator<Type> & right) const
{
return (current == right.current);
}
template <class Type>
bool linkedListIterator<Type>:: operator != (const linkedListIterator<Type> & right) const
{
return (current != right.current);
}
template <class Type>
class linkedListType
{
public :
const linkedListType<Type>& operator = (const linkedListType<Type>&);
void inlitializeList();
bool isEmpty() const ;
void print() const ;
int length() const ;
void destroyList();
Type front() const ;
Type back() const ;
virtual bool search (const Type & searchItem) const = 0 ;
virtual void inserFirst (const Type & newItem ) = 0;
virtual void insertLast (const Type & newItem) = 0;
virtual void deletItem(const Type & deleteItem) = 0;
virtual void deletSmallestItem () = 0;
virtual void deleteAll (const Type& item) = 0;
linkedListIterator<Type> begin();
linkedListIterator<Type> end();
linkedListType();
linkedListType(const linkedListType<Type> & otherList);
~linkedListType();
protected :
int count;
nodeType<Type>* first;
nodeType<Type>* last;
private :
void copyList(const linkedListType<Type> & otherList) ;
};
template <class Type>
const linkedListType<Type>& linkedListType<Type>::operator = (const linkedListType<Type>& otherList)
{
if (this != &otherList)
{
copyList(otherList);
}
return *this ;
}
template <class Type>
void linkedListType<Type>::inlitializeList()
{
destroyList();
}
template <class Type>
bool linkedListType<Type>::isEmpty() const
{
return (first == nullptr );
}
template <class Type>
void linkedListType<Type>::print() const
{
nodeType<Type> * current;
current = first;
while (current != nullptr )
{
std::cout << current->info << " " ;
current = current->link;
}
}
template <class Type>
int linkedListType<Type>::length() const
{
return count;
}
template <class Type>
void linkedListType<Type>::destroyList()
{
nodeType<Type> * temp;
while (first != nullptr )
{
temp = first;
first = first->link;
delete temp;
}
last = nullptr ;
count = 0;
}
template <class Type>
Type linkedListType<Type>::front() const
{
assert(first != nullptr );
return (first->info);
}
template <class Type>
Type linkedListType<Type>::back() const
{
assert(last != nullptr );
return (last->info);
}
template <class Type>
linkedListIterator<Type> linkedListType<Type>::begin()
{
linkedListIterator<Type> temp (first);
return temp;
}
template <class Type>
linkedListIterator<Type> linkedListType<Type>::end()
{
linkedListIterator<Type> temp (last);
return temp;
}
template <class Type>
linkedListType<Type>::linkedListType()
{
first = nullptr ;
last = nullptr ;
count = 0;
}
template <class Type>
linkedListType<Type>::linkedListType(const linkedListType<Type> & otherList)
{
first = nullptr ;
copyList(otherList);
}
template <class Type>
linkedListType<Type>::~linkedListType()
{
destroyList();
}
template <class Type>
void linkedListType<Type>::copyList(const linkedListType<Type> & otherList)
{
if (first != nullptr || count != 0 || last != nullptr )
{
destroyList();
}
if (otherList.first == nullptr )
{
first = nullptr ;
last = nullptr ;
count = 0;
}
else
{
nodeType<Type> * current;
nodeType<Type> * newNode;
current = otherList.first;
first = new nodeType<Type>;
first->info = current->info;
first->link = nullptr ;
last = first;
count = otherList.count;
current = current->link;
while (current != nullptr )
{
newNode = new nodeType<Type>;
newNode->info = current->info;
newNode->link = nullptr ;
last->link = newNode;
last = newNode;
current = current->link;
}
}
}
#endif
Apr 21, 2021 at 5:05pm UTC
and the "unorderedLinkedListType.h"
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 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
#ifndef unorderedLinkedListType_H
#define unorderedLinkedListType_H
#include "linkedListType.h"
template <class Type>
class unOLList : public linkedListType<Type>
{
public :
bool search (const Type& searchItem) const ;
void insertFirst (const Type& newItem);
void insertLast (const Type& newItem);
void deleteItem (const Type& deleteItem);
void deletSmallestItem ();
void deleteAll (const Type& item);
};
template <class Type>
bool unOLList<Type>::search (const Type& searchItem) const
{
nodeType<Type> * current;
bool found = false ;
current = first;
while (current != nullptr && !found)
{
if (current->info == searchItem)
{
found = true ;
}
else
{
current = current->link;
}
}
return found;
}
template <class Type>
void unOLList<Type>::insertFirst (const Type& newItem)
{
nodeType<Type>* newNode;
newNode = new nodeType<Type>;
newNode->info = newItem;
newNode->link = first;
first = newNode;
if (last == nullptr )
{
last = newNode;
}
count ++ ;
}
template <class Type>
void unOLList<Type>::insertLast (const Type& newItem)
{
nodeType<Type> * newNode = new nodeType<Type>;
newNode->info = newItem;
newNode->link = nullptr ;
last->link = newNode;
last = newNode;
if (first == nullptr )
{
first = newNode;
}
count ++;
}
template <class Type>
void unOLList<Type>::deleteItem (const Type& deleteItem)
{
nodeType<Type> * current = nullptr ;
nodeType<Type> * previous = nullptr ;
bool found = false ;
if (first == nullptr )
{
std::cout << "The list is empty." << "\n" ;
}
else if (first->info == deleteItem)
{
current = first;
first = first->link;
last = nullptr ;
count --;
delete current;
}
else
{
current = first;
while (current!= nullptr && !found)
{
if (current->info == deleteItem)
{
found = true ;
}
else
{
previous = current;
current = current->link;
}
}
if (found)
{
previous->link = current->link;
delete current;
count --;
}
else
{
std::cout << "Item not found in the list." << "\n" ;
}
previous = nullptr ;
}
}
template <class Type>
void unOLList<Type>::deletSmallestItem ()
{
nodeType<Type> * marker = nullptr ;
nodeType<Type> * pre_marker = nullptr ;
nodeType<Type> * current = nullptr ;
nodeType<Type> * previous = nullptr ;
if (first == nullptr )
{
std::cout << "The list is empty. " << "\n" ;
}
marker = first;
current = first;
while (marker != nullptr )
{
pre_marker = marker;
marker = marker->link;
if (makrer->info < current->info)
{
current = marker;
previous = pre_marker;
}
}
if (current == first)
{
first = first->link;
if (last == current)
{
last = nullptr ;
}
}
else if (current == last)
{
last = previous;
previous->link = current->link;
}
eles
{
previous->link = current->link;
}
count--;
delete current;
}
template <class Type>
void unOLList<Type>::deleteAll (const Type& item)
{
nodeType<Type> * current = nullptr ;
nodeType<Type> * previous = nullptr ;
current = first;
while (current != nullptr )
{
if (current->info == item)
{
if (current == first)
{
first = first->link;
delete current;
count --;
current = first;
}
else if (current == last)
{
last = previous;
previous->link = nullptr ;
count --;
delete current;
}
else
{
previous->link = current->link;
count--;
delete current;
current = previous->link;
}
}
else
{
previous = current;
current = current->link;
}
}
}
#endif
Last edited on Apr 21, 2021 at 5:22pm UTC
Topic archived. No new replies allowed.