两个不同的类双链表和对类不能一起工作

问题描述 投票：-1回答：1

我正在编写一个类似于boggle的程序，但这样的难度要小得多。我的程序程序旨在接收字母行数（所有相同数量的字母），然后在单独的行上接收字母。按照我要猜的单词数量和我猜的单词之后的每一行继续;如下图所示：

5
SRENG
OLIOA
VISKE
THAOR
PDTAL
4
LORE
NOSE
ROILS
SAILORS

输出显然是明显的，但是没有什么特别需要，找到哪些单词，哪些单词与成功单词的方向不一致：

如：

LORE
"FOUND!"
"W, NE, E"

所以现在这里让我感到困惑。我有我的主程序，称为scramble.cc，其中包含解决实际问题的所有代码，而我使用的其他程序是pair.h，pair.cc，list.h和list.cc（当然我的编译器）我的对代码：

#include <iostream>
#include <cstdlib>
#ifndef PAIR
#define PAIR

using namespace std;

struct Pair{
 int r, c;
 Pair(size_t r1, size_t c1);
 Pair();
 void print(ostream & ostr)const;
 size_t get(size_t index);
};
ostream & operator<<(ostream & ostr, const Pair & p);
bool operator==(const Pair & p1, const Pair & p2);
bool operator!=(const Pair & p1, const Pair & p2);

#endif

派人.曹操

#include <iostream>
#include <cstdlib>
#include "pair.h"
using namespace std;

Pair::Pair(size_t r1, size_t c1)
{
 r=r1;
 c=c1;
}

Pair::Pair()
{
r=c=0;
}

void Pair::print(ostream & ostr) const
{
 ostr << r << "," << c;
}

ostream & operator<<(ostream & ostr, const Pair & p)
{
 p.print(ostr)
 return ostr;
}

bool operator==(const Pair & p1, const Pair & p2)
{
 return p1.r == p2.r and p1.c == p2.c
}

bool operator!=(const Pair & p1, const Pair & p2)
{
 return not(p1==p2)
}

我的List.h：

#include <cstdlib>
#include <iostream>
#include "pair.h"
using namespace std;
class List
{
 public:
  typedef Pair ElementType;
  typedef int ElementType //this is what I used before putting in pair.h/.cc

 List();
 ~List();
 List(const List & orig)
 void add(const ElementType & item, size_t index);
 void removeAt(size_t index);
 void remove(const ElementType & item)
 size_t find(const ElementType & item) const;
 ELementType get(size_t index) const;
 size_t getSize() const;
 void output(std::ostream & ostr) const;

private:
 struct Node{
  Node *prev;
  ELementType data;
  Node*next;
  Node();
  Node(Node *p, Node *n);
  Node(Node *p, const ElementType & d, Node *n);
};

void _setCurrentIndex(size_t index) const;

size_t size;
mutable size_t currentIndex;
Node *front;
Node *rear;
mutable Node *current;

};

我的list.cc代码：

#include <iostream>
#include <cassert>
#include <cstdlib>
#include "list.h"

using namespace std;

List::Node::Node()
{
 prev = next = NULL;
}

List:: List()
{
 front = new Node()
 rear = new Node()
 front->next = rear;
 rear->prev = front;

 currentIndex=0;
 current = front->next;
 size=0;
}

List::~List()
{
 _setCurrentIndex(0);
 while(current)
  {
   Node *temp = current;
   current = current -> next;
   delete temp;
  }
//not showing deep copy function b/c it isn't important for this program
void List::add(const ElementType & item, size_t index)
{
 assert(0<=index && index <= size);
 _setCurrentIndex(index);
 size++;

 Node *born = new Node;
 born->data = item;
 born->prev = current->prev;
 born->prev->next = current;
 born->prev = born;
 current = born;
}

void List::removeAt(size_t index)
{
 assert(0<=index<=getSize());
 _setCurrentIndex(index);

 Node *old = current;
 current->prev->next = current->next;
 current->next->prev = current->prev;
 delete old;
 size--;
}

void List::remove(const ElementType & item)
{
 for(size_t i=0; i<size; i++)
  {
  _setCurrentIndex(i);
   if(find(item)<getSize())
    {
     Node *tempOld = current;
     current->next->prev = current->prev;
     current->prev->next = current->next;
     current = current->next;

     delete tempOld;
     size--;
    }
  }
}

size_t List::find(const ElementType & item) const
{
 for(size_t i=0; i<size; i++)
  {
   _setCurrentIndex(i)
   if(get(i) == item)
    return get(i);
  }
 return getSize();
}

List::ElementType List::get(size_t index) const
{
 assert(0 <= index < size);
 _setCurrentIndex(index);
 assert(current->next != NULL);
 return current->data;
}

size_t List::getSize() const
{
 return size;
}

void List::output(std::ostream & ostr) const
{
 for(size_t i=0; i<size; i++) 
  {
  _setCurrentIndex(i);
  ostr << current->data << " ";
  }
 ostr << endl;
}

void List:: _setCurrentIndex(size_t index) const
{
 int x;
 if(currentIndex > index)
  x = currentIndex - index;
 else
  x = index-currentIndex;

 if(index < (sizez_t)x)
  {
  current = front->next;
  curentIndex=0;
  while(currentIndex != index)
   {
   current = current->next;
   currentIndex++;
   }
  }
 else if((size-index) < (size_t)x)
  {
   current = rear;
   currentIndex = size;
   while(currentIndex != index)
    {
     current = current->prev;
     currentIndex--;
    }
  }
 else
  {
   if(currentIndex > index)
    {
    while(currentIndex!=index)
     {
      current = current->prev;
      currentIndex--;
     }
    }
   else
    {
     while(currentIndex!=index)
      {
       current = current->next;
       currentIndex++;
      }
    }
  }
}

我的scramble.cc：

#include <iostream>
#include <cstdlib>
#include "list.h"
#include "pair.h"
using namespace std;

List history;
Pair p1 = Pair(1,1);

int main()
{

}

我的Makefile

scramble: scramble.o list.o pair.o
     g++ -o scramble scramble.o list.o pair.o
scramble.o: scramble.cc list.h pair.h
     g++ -c scramble.cc
list.o: list.cc list.h pair.h
     g++ -c list.cc
pair.o pair.cc pair.h
     g++ -c pair.cc

所以这是我的代码，我不得不手工写出所有b / c我使用的程序没有复制和粘贴所以请原谅我，如果有小错误（如遗忘;或拼写错误）。

所以我最大的问题是，当我尝试制作Pairs并将它们放入List中时，它会因为无法将Pair转换为size_t等Find等功能而导致错误。还有大量未定义的参考文献List::List()，List::~List()，Pair::Pair(unsigned long, unsigned long)，List::add(Pair const&, unsigned long)，List::getSize() const，List::removeAt(unsigned long)。

那么有人可以帮我解决一下我需要对List类和对进行的操作吗？我的目标是在列表中存储Pairs并能够删除它，这是我的主要目标。

c++ list std-pair
1个回答
1
投票

作为一条建议，您应该在以后的帖子中包含更少的代码。如果您将问题缩小到特定的代码段，则更有可能获得帮助。此外，确切的错误消息非常有用。

至于你描述的问题，

它给我带来了错误，因为我无法在Find等函数中将Pair转换为size_t

你的问题是这个代码：

size_t List::find(const ElementType & item) const
{
   ...
   if(get(i) == item)
    return get(i); 
   ...
}

List::ElementType List::get(size_t index) const

请注意，List::get返回List::ElementType，List::find返回size_t。因此，语句return get(i);试图在函数中返回List::ElementType，该函数期望返回size_t。你很可能希望这是return i;而不是。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.