Question

I am writing a program that is like boggle, but that has much less difficulty. My program program is meant to receive the number of Lines of Letters (all same amount of letters) and then receive on separate lines the Letters. Proceeded by the number of words I am going to guess and each line after words I am going to guess;
such as shown below:

5
SRENG
OLIOA
VISKE
THAOR
PDTAL
4
LORE
NOSE
ROILS
SAILORS

The output would be board obviously, but nothing special is needed for that and which words were found and which ones weren’t along with the direction of the words that succeded:

Such as:

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

So now here is where it gets confusing for me. I have my main program which is called scramble.cc that includes all the code for solving the actually problem, while the other programs that I am using are pair.h, pair.cc, list.h, and list.cc (of course my compiler as well)
My pair code:

#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

pair.cc

#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)
}

My 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;

};

My list.cc code:

#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++;
      }
    }
  }
}

My scramble.cc:

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

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

int main()
{

}

My 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

So that is my code, I had to write that out all by hand b/c the program I use doesn’t do copy and paste so please forgive me if there are small errors(such as forgetting ; or misspelling).

So my biggest problem is when I try to make Pairs and put them into a List it freaks out by giving me errors of being unable to convert Pair to size_t in functions such as Find. There are also tons of undefined references List::List(), List::~List(), Pair::Pair(unsigned long, unsigned long), List::add(Pair const&, unsigned long), List::getSize() const, List::removeAt(unsigned long).

So can anyone please help me out here on what I need to do to my List class and pair? I goal is to store Pairs in the List and be able to remove them that is my main objective for this.

Answer 1

As a piece of advice, you should include significantly less code in future posts. You are more likely to get help if you’ve narrowed the problem down to a specific piece of code. Additionally, exact error messages are very helpful.

As for the problem you describe,

it freaks out by giving me errors of being unable to convert Pair to
size_t in functions such as Find

Your problem is with this code :

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

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

Note that List::get returns a List::ElementType and List::find returns a size_t. Therefore, the statement return get(i); is attempting to return a List::ElementType in a function that expects a size_t to be returned. You most likely want that to be return i; instead.