Ошибки в основной программе с использованием классов

Question

У меня только несколько ошибок одного типа в моей основной программе. Мой профессор колледжа не отвечает на мои письма, поэтому я должен обратиться к вам, ребята. В моей основной программе у меня есть несколько ошибок, несколько схожих с этим: «запрос для члена, который имеет тип неклассов». Program01 в основном тестирует каждую функцию в ListType.h, OListType.h и UListType.h, чтобы убедиться, что все работает правильно. Любая помощь, которую вы можете предоставить своевременно, будет оценена по достоинству.

Вот ListType.h:

#ifndef LISTTYPE_H_INCLUDED 
#define LISTTYPE_H_INCLUDED 
#include <iostream> 

class ListType { 
public: 
ListType(size_t=10); 
ListType(const ListType&); 
virtual ~ListType(); 
virtual bool insert(int)=0; 
virtual bool eraseAll(); 
virtual bool erase(int)=0; 
virtual bool find(int) const=0; 
size_t size() const; 
bool empty() const; 
bool full() const; 
friend std::ostream& operator << (std::ostream&, const ListType&); 
const ListType& operator= (const ListType&); 
protected: 
int *items; 
size_t capacity; 
size_t count; 
}; 


#endif // LISTTYPE_H_INCLUDED 

Вот ListType.cpp:

#include "ListType.h" 

ListType::ListType (size_t a) { 
capacity = a; 
count = 0; 
items = new int [capacity]; 
} 

ListType::ListType(const ListType& newlist) { 
capacity = newlist.capacity; 
count = newlist.count; 
items = new int [capacity]; 

for (size_t i = 0; i < count; ++i) 
    items[i] = newlist.items[i]; 
} 

ListType::~ListType() { 
delete [] items; 
} 

bool ListType::eraseAll() { 
count = 0; 
return 0; 
} 

size_t ListType::size() const { 
return (count); 
} 

bool ListType::empty() const { 
return (count == 0); 
} 

bool ListType::full() const { 
return (count == capacity); 
} 


std::ostream& operator << (std::ostream& out, const ListType& my_list) { 
if (!my_list.empty()) { 

for (size_t i = 0; i < my_list.count; ++i){ 
     out << my_list.items[i] << ','; 
    } 
} 
return out; 
} 

const ListType& ListType::operator= (const ListType& rightObject) { 
if (this != & rightObject) { 
    delete [] items; 
    capacity = rightObject.capacity; 
    count = rightObject.count; 

    items = new int[capacity]; 

    for (size_t i = 0; i < count; ++i) { 
     items[i] = rightObject.items[i]; 
    } 
} 
return *this; 
} 

Вот UListType.h:

#ifndef ULISTTYPE_H_INCLUDED 
#define ULISTTYPE_H_INCLUDED 
#include <iostream> 

class UListType: public ListType { 
public: 
UListType(size_t=10); 
bool insert(int); 
bool erase(int); 
bool find(int) const; 
}; 


#endif // ULISTTYPE_H_INCLUDED 

Вот UListType.cpp:

#include "ListType.h" 
#include "UListType.h" 


UListType::UListType (size_t c): ListType(c) {} 


bool UListType::insert(int item) { 
if (full()) { 
    int *newitems; 
    capacity *=2; 
    newitems = new int[capacity]; 
    for (size_t i =0; i < count; ++i){ 
     newitems[i] = items[i]; 
    } 
    delete [] items; 
    items = newitems; 
} 
items[count++] = item; 
return true; 
} 


bool UListType::erase(int item) { 
bool result = false; 
size_t i=0; 
while (i < count && items [i] != item) { 
    ++i; 
} 
if (i < count) { 
    items[i] = items[-- count]; 
    result = true; 
} 
return result; 
} 


bool UListType::find(int item) const { 
size_t i = 0; 
while (i < count && items [i] != item) { 
    ++i; 
} 
return i < count; 
} 

Вот OListType.h:

#ifndef OLISTTYPE_H_INCLUDED 
#define OLISTTYPE_H_INCLUDED 
#include <iostream> 

class OListType: public ListType { 
public: 
OListType(size_t=10); 
bool insert(int); 
bool erase(int); 
bool find(int) const; 
}; 


#endif // OLISTTYPE_H_INCLUDED 

Вот OListType.cpp:

#include "ListType.h" 
#include "OListType.h" 

OListType::OListType(size_t c): ListType(c) {} 


bool OListType::insert(int item) { 
size_t i = count; 
if (full()) { 
    int *newitems; 
    capacity *=2; 
    newitems = new int[capacity]; 
    for(size_t j=0; j < count; ++j) { 
     newitems[j] = items[i]; 
    } 
    delete [] items; 
    items = newitems; 
} 

while (i > 0 && items[i-1] > item){ 
     items[count++] = item; 
    } 
return true; 
} 

bool OListType::erase(int item) { 
bool found=false; 
size_t i=0, j= count-1, mid; 
while (i <= j && !(found)){ 
    mid = (i + j)/2; 
    if (item < items [mid]) 
     j = mid - 1; 
    else if (item > items [mid]) 
     i = mid + 1; 
    found = items [mid] == item; 
} 
if (found) { 
    for (i = mid; i < count - 1; ++i) { 
     items [i] = items [i +1]; 
    } 
     --count; 
} 
return found; 
} 

bool OListType::find (int item) const { 
bool found=false; 
size_t i=0, j= count-1, mid; 
while (i <= j && !(found)){ 
    mid = (i + j)/2; 
    if (item < items [mid]) 
     j = mid - 1; 
    else if (item > items [mid]) 
     i = mid + 1; 
    found = items [mid] == item; 
} 
return found; 
} 

Вот Program01.cpp:

#include "ListType.h" 
#include "UListType.h" 
#include "OListType.h" 
#include <iostream> 

using namespace std; 

int main() { 
OListType list[5] = {165, 16, 118, 212, 104}; 
UListType ranlist[10] = {243, 300, 154, 153, 592, 124, 195, 217, 289, 405}; 
UListType UListAssignmentTest; 
OListType OListAssignmentTest; 

cout << "The Ordered List before operations:" << endl; 
cout << list << endl << endl; 

if(list.empty())          **<-- HERE BE THE ERROR** 
    cout << "The list is empty, therefore it is true."; 
else 
    cout << "The list is full or partially full, therefore it is false"; 
cout << endl << endl; 

if(list.full()) 
    cout << "The list is full, therefore it is true."; 
else 
    cout << "The list is partially full or empty, therefore it is false"; 
cout << endl << endl; 

list.insert(25); 
cout << endl << endl; 

cout << "The Ordered list after Insert:" << endl; 
cout << list << endl << endl; 

list.find(25); 
cout << endl << endl; 

list.find(30); 
cout << endl << endl; 

list.erase(25); 
cout << endl << endl; 

cout << "The Ordered List after Erase:" << endl; 
cout << list << endl << endl; 

cout << "The Unordered List before operations:" << endl; 
cout << ranlist << endl << endl; 

if(ranlist.empty()) 
    cout << "The list is empty, therefore it is true."; 
else 
    cout << "The list is full or partially full, therefore it is false"; 
cout << endl << endl; 

if(ranlist.full()) 
    cout << "The list is full, therefore it is true."; 
else 
    cout << "The list is partially full or empty, therefore it is false"; 
cout << endl << endl; 

ranlist.insert(25); 
cout << endl << endl; 

cout << "The Unordered List after Insert:" << endl; 
cout << ranlist << endl << endl; 

ranlist.find(25); 
cout << endl << endl; 

ranlist.find(30); 
cout << endl << endl; 

ranlist.erase(25); 
cout << endl << endl; 

cout << "The Unordered List after Erase:" << endl; 
cout << ranlist << endl << endl; 

cout << "Testing Ordered List Assignment Operator" << endl; 
OListAssignmentTest = list; 
cout << OListAssignmentTest << endl << endl; 

cout << "Testing Unordered List Assignment Operator" << endl; 
UListAssignmentTest = ranlist; 
cout << UListAssignmentTest << endl << endl 

cout << "Testing Ordered List Copy Constructor" << endl; 
OListType OListVariable = list; 
cout << OListVariable << endl << endl; 

cout << "Testing Unordered List Copy Constructor" << endl; 
UListType UListVariable = ranlist; 
cout << UListVariable << endl << endl; 

cout << "Testing Erase All for OList" << endl; 
list.eraseAll(); 
cout << "OList values now: " << list.empty() << endl << endl; 

cout << "Testing Erase All for UList" << endl; 
ranlist.eraseAll(); 
cout << endl << "UList values now: " << ranlist.empty() << endl; 

return 0; 
} 

Answer 1

OListType list[5] = {165, 16, 118, 212, 104}; 

Эта строка объявляет массив из 5 типов OListType. Это не кажется правильным.

Вы хотите объявить один OLIstType и вставить в него 5 значений. Если нет, просим пояснить, что должна обозначать эта линия.

Здесь, вероятно, что вы должны сделать:

OListType list; 
list.insert(165); 
list.insert(16); // etc...