C++

Forum

 
variables from base class out of scope in derived class

y19177 (20)
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
seeplus (6464)
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.
y19177 (20)
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
y19177 (20)
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
y19177 (20)
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
Topic archived. No new replies allowed.