Question

所以我已经在代码上工作了两个多星期而且进展不顺利。这是说明，代码在它下面，以及错误：

任务1：创建此类的一个实例。（排序列表;他还有关于如何启动代码的其他说明，但它已经由我在下面的代码中完成，例如typedef ...）您还需要从一个数据文件中读取数据：float.dat ，其中包含以下数字：

5.5

6.2

7.1

8.0

9.0

10.0

1.0

2.0

3.3

4.4

float.dat中的数据包含浮点数，应插入到SortedList的对象中。请注意，您对float.dat中的数据值没有任何先验知识，但我们假设数据文件中有10个元素。

任务2：使用GetNextItem（）以计算机屏幕上的排序顺序打印列表中的所有元素。

任务3：使用GetNextItem（）以排序顺序将列表中的所有元素输出到数据文件output.dat。

任务4：设计测试用例以演示InsertItem（），DeleteItem（）和RetrieveItem（）是否按预期工作。

这是代码：

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

#define MAX_ITEMS  10
typedef   float  ItemType;

class SortedList
{
private:
    int length;
    ItemType values[MAX_ITEMS];
    int currentPos;
    enum RelationType { LESS, GREATER, EQUAL };

public:

    SortedList() {length = 0; currentPos = -1;}

    int getLength() {return length;}

    RelationType ComparedTo(ItemType x) 
    {
        if (length > x.getLength())
            return LESS;
        else if (length == x.getLength())
            return GREATER;
        else
            return EQUAL;
    }

    void MakeEmpty() {length = 0;}

    void InsertItem(ItemType x) 
    {   
        int first = 0, last = length --;
        bool moreToSearch = (first <= last);
        int location = 0;
        int midpoint= (first + last) / 2;

        while (moreToSearch) 
        {
            switch (x.ComparedTo(values[location])) 
            {
            case LESS:      //search in 1st half
                moreToSearch = (first <= last);
                break;
            case GREATER:
                location++;
                moreToSearch = (location < length);
                break;
            }
        }
        for (int index = length; length > location; index--) 
        {
            values[index] = values[index - 1];
        }
        values[location] = x;
        length++;
    }

    void DeleteItem(ItemType x) 
    {
        int location = 0;
        while (x.ComparedTo(values[location]) != EQUAL)
            location++;
        for (int index = location ++; index < length; index++)
            values[index --] = values[index];
        length--;
    }

    void RetrieveItem(ItemType &x, bool & found) 
    {
        int midpoint;
        int first = 0, last = length - 1;
        bool moreToSearch = (first <= last);
        found = false;
        int index = 0;
        while (moreToSearch && !found) 
        {
            midpoint = (first + last) / 2;

            switch (x.ComparedTo(values[index++])) 
            {
            case LESS:      //search in 1st half
                moreToSearch = (first <= last);
                last = midpoint - 1;
                break;
            case GREATER:   //Search in 2nd half
                first = midpoint + 1;
                moreToSearch = (first <= last);
                break;
            case EQUAL: //x has been found
                found = true;
                break;
            }
        }
    }

    int LengthIs() {return length;}

    void ResetList() {currentPos = -1;}

    bool IsFull() 
    {
        if (length < 9)
            return false;
        else
            return true;
    }

    void GetNextItem(ItemType &x) 
    {
        currentPos++;
        x = values[currentPos];
        cout << x;
    }   
};

int main()
{
    SortedList x;

    ifstream inFile; ofstream output;
    string line;
    bool allAboutLists;
    int i = 0;
    int size = 0;

    inFile.open("float.txt");

    float values[10];
    while (!inFile.eof())   // write or read data from inFile into values
    {
        inFile >> values[i];
        i++;
        size++;         // this will count how many values there are in the array
        x.InsertItem(values[i]);
        ++i;
    }

    x.ResetList();

    cout << "The following is the list that's been made:" << endl << endl;

    x.InsertItem(64);
    //x.printlist();
    cout << endl;
    x.DeleteItem(64);
    //x.printlist();

    x.RetrieveItem(7.1, allAboutLists); 
    cout << endl;

    cout << endl << "The length is: "; x.LengthIs(); cout << endl;

    cout << "Is the list full?: " << boolalpha << x.IsFull() << endl;
    cout << "The next item is: ";
    for (int i = 0; i < 10; i++)
    {
        cout << x.GetNextItem << endl;
    }
    x.ResetList();

    inFile.close();

    output.open("output.txt");

    for (int f = 0; f < 10; f++)
    {
        output << x.GetNextItem << endl;
    }

    system("pause");
    return 0;
}

并且编译器一直这样说：

（25）错误C2228：＆＃39; .getLength＆＃39;必须有class / struct / union [他们的意思是x。它的红色衬在下面，对于剩下的那些剩下的等等。]
（27）错误C2228：＆＃39; .getLength＆＃39;必须有class / struct / union
（44）错误C2228：左边的＆＃39;。比较＆＃39;必须有class / struct / union
（66）：错误C2228：左边的＆＃39;。比较＆＃39;必须有class / struct / union - 而且，主要的7.1有关于引用类型错误的事情。

我非常匆忙，因为我现在已经工作了两个星期，它让我疯狂！我已经完成了所看到的代码，而且只需要知道要更改的内容，因为我正在关注我一直在搜索和研究的所有内容但它并不好。如此精确的细节或代码专门从我的和固定的，我们将不胜感激。

谢谢！

Answer 1

您将x作为ItemType传递float。

float没有这些方法......看起来你想将它作为SortedList

传递

Answer 2

比较功能需要两个参数才能进行比较。您可能希望将其称为CompareToLocation而不是ComparisonTo。

RelationType CompareToLocation(ItemType x, size_t location){
    if(x < values[location]) return LESS;
    if(x == values[location]) return EQUAL;
    return GREATER;}

示例用法是：

result = CompareToLocation(x, location);
    // ...

Answer 3

您将ComparisonTo定义为SortedList的方法，但每次调用该函数时，都会在ItemType对象上调用它，这些对象实际上是浮点数。

正如您在方法的定义中所看到的，您试图再次使用float对象上的SortedList方法：

RelationType ComparedTo(ItemType x) 
{
   if (length > x.getLength())
      return LESS;
   else if (length == x.getLength())
      return GREATER;
   else
      return EQUAL;
}

你的问题不仅仅是一个编译问题，而是一个概念问题，因为你似乎并没有掌握你实际编码的内容。

我建议将您的声明和实现分开，这样您就可以一目了然地看到您的课程如何运作。您的类声明应如下所示：

class SortedList
{
private:
   int length;
   ItemType values[MAX_ITEMS];
   int currentPos;
   enum RelationType { LESS, GREATER, EQUAL };

public:

   SortedList();

   int getLength();

   RelationType ComparedTo(ItemType x) ;
   void MakeEmpty();
   void InsertItem(ItemType x) ;
   void DeleteItem(ItemType x);
   void RetrieveItem(ItemType &x, bool & found);
   int LengthIs();

   void ResetList();

   bool IsFull();

   void GetNextItem(ItemType &x);

};

你应该专注于每个方法，明确每个方法试图实现的目标，以及实现它需要什么（参数）。

例如：

RelationType ComparedTo(ItemType x) ;

您的SortedList类具有此函数，该函数接收ItemType（float）作为参数。

这是想要实现的目标？如何将整个有序列表与单个元素进行比较？单个数字如何对一组数字更大，更小或相等？

也许您真正想要做的是将参数X与列表中的元素进行比较？如果是这种情况，您如何知道列表中的哪个元素必须与参数X进行比较？您应该添加另一个参数，告诉您有序列表中的哪个元素将X与之比较。

我认为这并没有真正解决你的问题，但至少我希望这可以帮助你更好地理解你的问题。

排序列表：必须具有class / struct / union

3 个答案: