Я пытаюсь реализовать методы класса LinkedBag.Возникла проблема при реализации этих трех упомянутых методов в LinkedBag.cpp
. Я думаю об использовании этого указателя, но не уверен, как он работает.
// Node.h
Этозаголовочный файл для класса.В дополнение к элементу данных и следующему классу объявляются три конструктора, два метода доступа - один для элемента и следующий - и два метода мутатора - снова один для элемента и следующий
#ifndef NODE_
#define NODE_
template<class ItemType>
class Node
{
private:
ItemType item;
Node<ItemType>* next;
public:
Node();//default constructor
Node(const ItemType& anItem);
Node(const ItemType& anItem, Node<ItemType>* nextNodePtr);
void setItem(const ItemType& anItem);
void setNext(Node<ItemType>* nextNodePtr);
ItemType getItem() const ;
Node<ItemType>* getNext() const ;
};
#include "Node.cpp"
#endif
*/
//Файл Node.cpp
#include "Node.h"
template<class ItemType>
Node<ItemType>::Node() : next(nullptr)
{
}
template<class ItemType>
Node<ItemType>::Node(const ItemType& anItem) : item(anItem), next(nullptr)
{
}
template<class ItemType>
Node<ItemType>::Node(const ItemType& anItem, Node<ItemType>* nextNodePtr) :
item(anItem), next(nextNodePtr)
{
}
template<class ItemType>
void Node<ItemType>::setItem(const ItemType& anItem)
{
item = anItem;
}
template<class ItemType>
void Node<ItemType>::setNext(Node<ItemType>* nextNodePtr)
{
next = nextNodePtr;
}
template<class ItemType>
ItemType Node<ItemType>::getItem() const
{
return item;
}
template<class ItemType>
Node<ItemType>* Node<ItemType>::getNext() const
{
return next;
}
// bagInterface.h
#ifndef BAG_INTERFACE_
#define BAG_INTERFACE_
#include <vector>
template<class ItemType>
class BagInterface
{
public:
virtual int getCurrentSize() const = 0;
virtual bool isEmpty() const = 0;
virtual bool add(const ItemType& newEntry) = 0;
virtual bool remove(const ItemType& anEntry) = 0;
virtual void clear() = 0;
virtual int getFrequencyOf(const ItemType& anEntry) const = 0;
virtual bool contains(const ItemType& anEntry) const = 0;
virtual std::vector<ItemType> toVector() const = 0;
virtual ~BagInterface() { }
};
#endif
// LinkedBag.h
#ifndef LINKED_BAG_
#define LINKED_BAG_
#include "BagInterface.h"
#include "Node.h"
using std::vector;
template<class ItemType>
class LinkedBag : public BagInterface<ItemType>
{
private:
Node<ItemType>* headPtr;
int itemCount;
Node<ItemType>* getPointerTo(const ItemType& target) const;
public:
LinkedBag();
LinkedBag(const LinkedBag<ItemType>& aBag);
virtual ~LinkedBag();
int getCurrentSize() const;
bool isEmpty() const;
bool add(const ItemType& newEntry);
bool remove(const ItemType& anEntry);
void clear();
bool contains(const ItemType& anEntry) const;
int getFrequencyOf(const ItemType& anEntry) const;
vector<ItemType> toVector() const;
//this is the main part
//*******************************************************
LinkedBag<ItemType> bagUnion(const LinkedBag<ItemType> bag2);
LinkedBag<ItemType> intersection(const LinkedBag<ItemType> bag2);
LinkedBag<ItemType> difference(const LinkedBag<ItemType> bag2);
// ************************************************************
}; // end LinkedBag
#include "LinkedBag.cpp"
#endif
*/
// LinkedBag.cpp
#include"LinkedBag.h"
#include "Node.h"
using namespace std;
template<class ItemType>
Node<ItemType>* LinkedBag<ItemType>::getPointerTo(const ItemType& target) const//this method returns the pointer of the target
{
Node<ItemType>* curPtr = headPtr;
while (!found && (curPtr != nullptr))
{
if (target == curPtr->getItem())
found = true;
else
curPtr = curPtr->getNext();
}
return curPtr;
}
template < class ItemType>
LinkedBag<ItemType>::LinkedBag() : headPtr(nullptr), itemCount(0)
{
}
template<class ItemType>
LinkedBag<ItemType>::LinkedBag(const ItemType& aBag)
{
itemCount = aBag->itemCount;
Node<ItemType>* origChainPtr = aBag->headPtr
if (origChainPtr == nullptr)
headPtr = nullptr;
else
{
headPtr = new Node<ItemType>();
headPtr->setItem(origChainPtr ->getItem());
Node<ItemType>* newChainPtr = headPtr;
while (origPtr != nullptr )
{
origChainPtr = origChainPtr ->getNext();
ItemType nextItem = origChainPtr->getItem();
Node<ItemType>* newNodePtr = new Node<ItemType>(nextItem);
newChainPtr->setNext(newNodePtr);
newChainPtr = newChainPtr->getNext();
}
newChainPtr->setNext(nullptr);
}
}
template < class ItemType>//template class definition
bool LinkedBag<ItemType>::add(const ItemType& newEntry)//copy constructor
{
Node<ItemType>* newNodePtr = new Node<ItemType>();
newNodePtr->setItem(newEntry);
newNodePtr->setNext(headPtr);
headPtr = newNodePtr;
itemCount++;
return true;
}
template<class ItemType>
LinkedBag<ItemType>::~LinkedBag()
{
clear();
}
template < class ItemType>
int LinkedBag<ItemType>::getCurrentSize() const
{
return itemCount;
}
template < class ItemType>
bool LinkedBag<ItemType>::isEmpty() const
{
return itemCount == 0;
}
template < class ItemType>
bool LinkedBag<ItemType>::remove(const ItemType& anEntry)
{
Node<ItemType>* entryNodePtr = getPointerTo(anEntry);
bool canRemoveItem = !isEmpty() && (entryNodePtr != nullptr);
if (canRemoveItem)
{
entryNodePtr->setItem(headPtr->getItem());
Node<ItemType>* nodeToDeletePtr = headPtr;
headPtr = headPtr->getNext();
nodeToDeletePtr->setNext( nullptr );
delete nodeToDeletePtr;
nodeToDeletePtr = nullptr ;
itemCount--;
}
return canRemoveItem;
}
template < class ItemType>
void LinkedBag<ItemType>::clear()
{
while (headPtr != nullptr)
{
Node<ItemType>* nodeToDeletePtr = headPtr;
headPtr = headPtr->getNext();
nodeToDeletePtr->setNext( nullptr );
delete nodeToDeletePtr;
}
nodeToDeletePtr = nullptr;
itemCount = 0;
}
template <class ItemType>
bool contains(const ItemType& anEntry) const
{
}
template < class ItemType>
int LinkedBag<ItemType>::getFrequencyOf(const ItemType& anEntry) const
{
int frequency = 0;
int counter = 0;
Node<ItemType>* curPtr = headPtr;
while ((curPtr != nullptr) && (counter < itemCount))
{
if (anEntry == curPtr->getItem())
{
frequency++;
}
counter++;
curPtr = curPtr->getNext();
}
return frequency;
}
template<class ItemType>
bool LinkedBag<ItemType>::contains(const ItemType& anEntry)const
{
if (getFrequecyOf(anEntry) > 0)
return true;
else
return false;
}
template < class ItemType>
vector<ItemType> LinkedBag<ItemType>::toVector() const
{
vector<ItemType> bagContents;
fillVector(bagContents, headPtr);
return bagContents;
}
//*************************************************************
//need help in implementing the following functions
template <class ItemType>
LinkedBag<ItemType>LinkedBag<ItemType>:: bagUnion(const LinkedBag<ItemType> bag2)
{
LinkedBag<ItemType>* bag1 = this->headPtr;//maybe?
LinkedBag<ItemType> unionBag;
//clueless after this point
}
template <class ItemType>
LinkedBag<ItemType> LinkedBag<ItemType>::intersection(const LinkedBag<ItemType> bag2)
{
}
templalte<class ItemType>
LinkedBag<ItemType> LinkedBag<ItemType>::difference(const LinkedBag<ItemType> bag2)
{
}