Inserting values into two BSTs sorted differently - c++

Question

For a project I'm working on in school I have to insert a pointer to one object into two BSTs. One BST is sorted by the APN(a unique key), and the other is sorted by price(non unique). We are using templates, so I asked my professor how to accomplish this and she said to use function pointers. When I tried to do so, I came across a few errors I don't know how to resolve.
The object is defined as
class House
{
private:
string APN; // Unique key
int price; // Non-unique key
string address;
int bedrooms;
double bathrooms;
int sqFt;
}
In main, after I've created the object I try to run.
uniqueTree->insert(newHouse, comparePrimaryKey);
nonUniqueTree->insert(newHouse, compareSecondaryKey);
Where each function is defined as
int comparePrimaryKey(const House* &left, const House* &right)
{
if(left->getAPN() < right->getAPN())
return -1;
else
return 1;
}
int compareSecondaryKey(const House* &left, const House* &right)
{
if(left->getPrice() < right->getPrice()) // right > left
return -1;
else // right < left
return 1;
}
But I get an error saying
"Cannot initialize a parameter of type 'int (*)(House *const &, House *const &)
with an lvalue of type 'int (const House *&, const House *&)'"
There is a BinaryNode object pointer called rootPtr in the Binary Tree file, and insert is defined as a purely virtual function.
BinaryNode<ItemType>* rootPtr;
virtual bool insert(const ItemType & newData, int compare(const
ItemType&, const ItemType&)) = 0;
The binary node class:
template<class T>
class BinaryNode
{
private:
T item; // Data portion
BinaryNode<T>* leftPtr; // Pointer to left child
BinaryNode<T>* rightPtr; // Pointer to right child
public:
// constructors
BinaryNode(const T & anItem) {item = anItem; leftPtr = 0; rightPtr = 0;}
BinaryNode(const T & anItem,
BinaryNode<T>* left,
BinaryNode<T>* right) {item = anItem; leftPtr = left; rightPtr = right;}
// mutators
void setItem(const T & anItem) {item = anItem;}
void setLeftPtr(BinaryNode<T>* left) {leftPtr = left;}
void setRightPtr(BinaryNode<T>* right) {rightPtr = right;}
// accessors
T getItem() const {return item;}
BinaryNode<T>* getLeftPtr() const {return leftPtr;}
BinaryNode<T>* getRightPtr() const {return rightPtr;}
bool isLeaf() const {return (leftPtr == 0 && rightPtr == 0);}
};
In the BST file, insert is defined as
template<class ItemType>
bool BinarySearchTree<ItemType>::insert(const ItemType &newEntry, int
compare(const ItemType &, const ItemType &))
{
BinaryNode<ItemType>* newNodePtr = new BinaryNode<ItemType>(newEntry);
BinaryTree<ItemType>::rootPtr = _insert(BinaryTree<ItemType>::rootPtr,
newNodePtr, compare(newNodePtr->getItem(), BinaryTree<ItemType>::rootPtr()->getItem()));
return true;
}
I am also getting an error at the BinaryTree::rootPtr line saying that
Called object type 'BinaryNode<House *> *' is not a function or function pointer

Answer 1

here is a simple program that solve your first problem, i added the definitions of some function so that i can test your class and functions.
#include <iostream>
#include <string>
class House
{
private:
std::string APN; // Unique key
int price; // Non-unique key
std::string address;
int bedrooms;
double bathrooms;
int sqFt;
public:
House(std::string apn, int prix)
{
APN = apn;
price = prix;
}
std::string getAPN(void)
{
return APN;
}
int getPrice()
{
return price;
}
};
int comparePrimaryKey( House *const &left, House *const &right)
{
if(left->getAPN() < right->getAPN())
return -1;
else
return 1;
}
int compareSecondaryKey( House *const &left, House *const &right)
{
if(left->getPrice() < right->getPrice()) // right > left
return -1;
else // right < left
return 1;
}
// Main function for the program
int main( )
{
int PrimaryKey =0;
int SecondaryKey=0;
House right("droite",2050);
House left("gauche",2000);
PrimaryKey = comparePrimaryKey(&left, &right);
SecondaryKey = compareSecondaryKey(&left, &right);
std::cout<< PrimaryKey << std::endl;
std::cout << SecondaryKey << std::endl;
std::system("PAUSE");
return 0;
}