For a project I'm working at, I've created a C++ library that encapsulates data structures. For each data structure, I've created custom iterators to navigate through data elegantly. Everything went fine until I've tried template specialization on those classes, when I stumbled upon this build error: error: invalid use of incomplete type.
I've banged my head for more than a week on this and found nothing helpful on the net, so I thought maybe some of you can help me with this...
The whole problem simplified:
template<typename T>
class DataStructureIterator;
// OK
template<typename T>
class DataStructure {
friend class DataStructureIterator<T>;
public:
typedef DataStructureIterator<T> iterator;
...
iterator begin() {
return iterator(this);
}
iterator end(){
return iterator(count);
}
};
// ERROR: "Invalid use of incomplete type" (on ANY specialization attempt)
template<>
class DataStructure<double> {
friend class DataStructureIterator<double>;
public:
typedef DataStructureIterator<double> iterator;
...
iterator begin() {
return iterator(this);
}
iterator end(){
return iterator(count);
}
};
template<typename T>
class DataStructureIterator { ... }
Example:
template<typename T>
struct DoublyLinkedListEntry {
T value;
DoublyLinkedListEntry* next;
DoublyLinkedListEntry* previous;
};
template<typename T>
class DoublyLinkedListIterator;
template<typename T>
class DoublyLinkedList {
friend class DoublyLinkedListIterator<T>;
public:
typedef DoublyLinkedListIterator<T> iterator;
DoublyLinkedList() {
head = nullptr;
tail = nullptr;
count = 0;
}
~DoublyLinkedList() {
empty();
}
void add(const T& value) {
DoublyLinkedListEntry<T>* element = new DoublyLinkedListEntry<T>;
element->value = value;
element->next = nullptr;
element->previous = tail;
if(head==nullptr) {
head = element;
} else {
tail->next = element;
}
tail = element;
++ count;
}
iterator begin() {
return iterator(this);
}
iterator end(){
return iterator(count);
}
private:
void empty(){
DoublyLinkedListEntry<T>* temp = head;
DoublyLinkedListEntry<T>* del = temp;
while(del != nullptr) {
temp = temp->next;
delete del;
del = temp;
}
}
DoublyLinkedListEntry<T>* head;
DoublyLinkedListEntry<T>* tail;
std::size_t count;
};
template<>
class DoublyLinkedList<double> {
friend class DoublyLinkedListIterator<double>;
public:
typedef DoublyLinkedListIterator<double> iterator;
DoublyLinkedList() {
head = nullptr;
tail = nullptr;
count = 0;
}
~DoublyLinkedList() {
empty();
}
void add(double& value) {
DoublyLinkedListEntry<double>* element = new DoublyLinkedListEntry<double>;
element->value = value;
element->next = nullptr;
element->previous = tail;
if(head==nullptr) {
head = element;
} else {
tail->next = element;
}
tail = element;
++ count;
}
iterator begin() {
return iterator(this);
}
iterator end(){
return iterator(count);
}
private:
void empty(){
DoublyLinkedListEntry<double>* temp = head;
DoublyLinkedListEntry<double>* del = temp;
while(del != nullptr) {
temp = temp->next;
delete del;
del = temp;
}
}
DoublyLinkedListEntry<double>* head;
DoublyLinkedListEntry<double>* tail;
std::size_t count;
};
template<typename T>
class DoublyLinkedListIterator {
public:
DoublyLinkedListIterator(){
list = nullptr;
current_item = nullptr;
offset = 0;
}
DoublyLinkedListIterator(DoublyLinkedList<T>* list){
this->list = list;
current_item = list->head;
offset = 0;
}
DoublyLinkedListIterator(std::size_t total){
list = nullptr;
current_item = nullptr;
offset = total;
}
~DoublyLinkedListIterator(){}
const T operator*(){
return current_item->value;
}
bool operator!=(const DoublyLinkedListIterator<T>& it) const {
return offset!=it.offset;
}
DoublyLinkedListIterator<T>& operator++(){
if(current_item!=nullptr) {
current_item = current_item->next;
}
++offset;
return *this;
}
private:
DoublyLinkedList<T>* list;
DoublyLinkedListEntry<T>* current_item;
std::size_t offset;
};
Build error:
In file included from ../src/Learning.cpp:11:0:
../src/DoublyLinkedList.h: In member function ‘DoublyLinkedList<double>::iterator DoublyLinkedList<double>::begin()’:
../src/DoublyLinkedList.h:107:20: error: return type ‘DoublyLinkedList<double>::iterator {aka class DoublyLinkedListIterator<double>}’ is incomplete
iterator begin() {
^
../src/DoublyLinkedList.h:108:24: error: invalid use of incomplete type ‘DoublyLinkedList<double>::iterator {aka class DoublyLinkedListIterator<double>}’
return iterator(this);
^
../src/DoublyLinkedList.h:22:7: error: declaration of ‘DoublyLinkedList<double>::iterator {aka class DoublyLinkedListIterator<double>}’
class DoublyLinkedListIterator;
^
../src/DoublyLinkedList.h: In member function ‘DoublyLinkedList<double>::iterator DoublyLinkedList<double>::end()’:
../src/DoublyLinkedList.h:111:17: error: return type ‘DoublyLinkedList<double>::iterator {aka class DoublyLinkedListIterator<double>}’ is incomplete
iterator end(){
^
../src/DoublyLinkedList.h:112:25: error: invalid use of incomplete type ‘DoublyLinkedList<double>::iterator {aka class DoublyLinkedListIterator<double>}’
return iterator(count);
^
../src/DoublyLinkedList.h:22:7: error: declaration of ‘DoublyLinkedList<double>::iterator {aka class DoublyLinkedListIterator<double>}’
class DoublyLinkedListIterator;
The error message is pretty clear.
class DoublyLinkedListIterator<double> is an incomplete type when you try to create instances of the class in the following functions:
iterator begin() {
return iterator(this);
}
iterator end(){
return iterator(count);
}
You can resolve this using either of the following methods.
Move the definition of template<typename T> class DoublyLinkedListIterator before the definition of template<> class DataStructure<double>.
Don't define the above functions inline. Only declare them. Define them after the definition of template<typename T> class DoublyLinkedListIterator.
Collected from the Internet
Please contact [email protected] to delete if infringement.
Comments