BST Insert

[CubiksRube]

Been working on a program, that is supposed to read in data from a text file; first/last name, ssn, mom ssn, dad ssn, and friends. Reading in the values is not a problem. We are supposed to insert a 'person' object into the tree using the insert function. We previously made a BST program and using that code, just tweaking it.

We are also supposed to be using a template<class ItemType>.
When calling the function tree.insert()

I get the error message BinaryTree<int>::Insert(int)': cannot convert argument 1 from Person<int> to int.

Have tried changing argument types in the function itself and still coming with this error. Any help would be greatly appreciated, so thank you ahead of time!!

"Person.h"
#ifndef PERSON_H
#define PERSON_H

#include <iostream>
#include <string>
#include <fstream>

using namespace std;
template <class ItemType>
class Person
{
private:
	int ssn;
	int fatherSSN;
	int motherSSN;
	int friendSSN;
	string firstName;
	string lastName;

public:
	Person();
	int getSSN();
	void setSSN(int);
	string getFullName();
	void  setFullName(string, string);
	int getFatherSSN();
	void setFatherSSN(int);
	int  getMotherSSN();
	void setMotherSSN(int);
	int getFriends();
	void setFriends(int);
};



template <class ItemType>
Person<ItemType>::Person()
{
	BinaryTree<int> tree;
	Person<int> person;
	string first, last;
	int friends, momSSN, dadSSN, ssn1;

	fstream inFile;
	while (!inFile.eof())
	{
		inFile.open("CommunityFile.txt");
		inFile >> first >> last;
		inFile >> ws;
		person.setFullName(first, last);
		inFile >> ssn1;
		inFile >> ws;
		person.setSSN(ssn1);
		inFile >> dadSSN;
		inFile >> ws;
		person.setFatherSSN(dadSSN);
		inFile >> momSSN;
		inFile >> ws;
		person.setMotherSSN(momSSN);
		inFile >> friends;
		inFile >> ws;
		person.setFriends(friends);
		tree.Insert(person);   //this seems to be the problem of the code here.
	}

	
	tree.Print();
}

template <class ItemType>
void Person<ItemType>::setSSN(int ssn1)
{
	ssn = ssn1;
}
template <class ItemType>
int Person<ItemType>::getSSN()
{
	return ssn;
}
template <class ItemType>
void Person<ItemType>::setFullName(string first, string last)
{
	firstName = first;
	lastName = last;
}
template <class ItemType>
string Person<ItemType>::getFullName()
{
	return firstName, lastName;
}
template <class ItemType>
void Person<ItemType>::setFatherSSN(int dadSSN)
{
	fatherSSN = dadSSN;
}
template <class ItemType>
int Person<ItemType>::getFatherSSN()
{
	return fatherSSN;
}
template <class ItemType>
void Person<ItemType>::setMotherSSN(int momSSN)
{
	motherSSN = momSSN;
}
template <class ItemType>
int Person<ItemType>::getMotherSSN()
{
	return motherSSN;
}
template <class ItemType>
void Person<ItemType>::setFriends(int friends)
{
	friendSSN = friends;
}
template <class ItemType>
int Person<ItemType>::getFriends()
{
	return friendSSN;
}

#endif 

"BST.H"
#ifndef BST_H
#define BST_H

#include <iostream>
#include <fstream>
#include <new>
#include "Person.h"

using namespace std;

class Node {
public:
	Node* Right;
	Node* Left;
	int Value;
};

template<class ItemType>
class BinaryTree
{
public:
	BinaryTree();
	BinaryTree(char *Name);
	~BinaryTree();

	int GetCount();
	bool Search(int Value);
	void Insert(int Value);    //function prototype with error 
	void Delete(int Value);
	void Print();
	Node getRoot();

private:
	int Count(Node* Tree);
	bool SearchNode(Node* Tree, int Value);
	void InsertNode(Node * &Tree, int Value);
	void PrintNodeInorder(Node * Tree);
	void DestroyNode(Node * Tree); //for Destructor
	Node *Root;
};

//void GetPredecessor(Node* tree, int& data);
//void DeleteNode(Node*& Tree);
//void DeleteNode(Node*& Tree, int value);

//-----------------------------------------------------------
// Constructor function.
//-----------------------------------------------------------
template<class ItemType>
BinaryTree<ItemType>::BinaryTree()
{
	Root = NULL;
}

//-----------------------------------------------------------
// Constructor function that reads tree from file.
//-----------------------------------------------------------
template<class ItemType>
BinaryTree<ItemType>::BinaryTree(char *Name)
{
	Root = NULL;

	// Open input file
	ifstream din;
	din.open(Name);
	if (din.fail())
		cout << "Error: could not open input file\n";

	// Read the data
	int Value;
	cin >> Value;
	while (!din.eof())
	{
		InsertNode(Root, Value);
		cin >> Value;
	}

	// Close the file
	din.close();
}


//-----------------------------------------------------------
// Destructor function Node function.
//-----------------------------------------------------------
template<class ItemType>
void BinaryTree<ItemType>::DestroyNode(Node * Tree)
{
	// Delete node and it's children
	if (Tree != NULL)
	{
		DestroyNode(Tree->Left);
		DestroyNode(Tree->Right);
		delete Tree;
	}
}

//-----------------------------------------------------------
// Destructor function.
//-----------------------------------------------------------
template<class ItemType>
BinaryTree<ItemType>::~BinaryTree()
{
	// Call tree destroy function
	DestroyNode(Root);
}

//-----------------------------------------------------------
// Search Node function.
//-----------------------------------------------------------
template<class ItemType>
bool BinaryTree<ItemType>::SearchNode(Node * Tree, int Value)
{
	// Data value not found 
	if (Tree == NULL)
		return false;

	// Data value found 
	else if (Tree->Value == Value)
		return true;

	// Recursively search for data value
	else if (Tree->Value > Value)
		return (SearchNode(Tree->Left, Value));
	else if (Tree->Value < Value)
		return (SearchNode(Tree->Right, Value));
	else
		return false;
}

//-----------------------------------------------------------
// Search for data in the binary tree.
//-----------------------------------------------------------
template<class ItemType>
bool BinaryTree<ItemType>::Search(int Value)
{
	// Call tree searching function
	return (SearchNode(Root, Value));
}

//-----------------------------------------------------------
// Insert Node function.
//-----------------------------------------------------------
template<class ItemType>
void BinaryTree<ItemType>::InsertNode(Node * &Tree, int Value)
{
	// Insert data into the tree
	if (Tree == NULL)
	{
		Tree = new Node();
		Tree->Value = Value;
		Tree->Left = NULL;
		Tree->Right = NULL;
		//return true;
	}

	// Recursively search for insertion position
	else if (Tree->Value > Value)
		 (InsertNode(Tree->Left, Value));
	else
		 (InsertNode(Tree->Right, Value));
}

//-----------------------------------------------------------
// Insert data into the binary tree.                                      this is is the function with the error
//-----------------------------------------------------------
template<class ItemType>
void BinaryTree<ItemType>::Insert(int Value)
{
	// Call tree insertion function
	 InsertNode(Root, <Person>Value);
}

//-----------------------------------------------------------
// Print Node function.  inorder 
//-----------------------------------------------------------
template<class ItemType>
void BinaryTree<ItemType>::PrintNodeInorder(Node * Tree)
{
	// Check terminating condition
	if (Tree != NULL)
	{
		// Print left subtree

		PrintNodeInorder(Tree->Left);

		// Print node value
		cout << " " << Tree->Value << " ";

		// Print right subtree
		PrintNodeInorder(Tree->Right);

	}
}


//-----------------------------------------------------------
// Print all records in the binary tree.
//-----------------------------------------------------------
template<class ItemType>
void BinaryTree<ItemType>::Print()
{
	// Call tree printing function
	cout << "Inorder: ";
	PrintNodeInorder(Root);
	cout << endl;
}

template<class ItemType>
Node BinaryTree<ItemType>::getRoot()
{
	return Root;
}

template<class ItemType>
void BinaryTree<ItemType>::Delete(int value)
{
	DeleteNode(Root, value);
}

#endif 

[coder777]

There is no reason for making the class Person a template.

You need templates for BinaryTree and especiall Node since Node holds the data to store:

template<class ItemType> // Note
class Node {
public:
	Node* Right;
	Node* Left;
	ItemType Value; // Note: This might be a pointer?
};

Each function of the binary tree the uses data (like Insert, InsertNode, etc.) needs the template parameter ItemType not int:

template<class ItemType>
void BinaryTree<ItemType>::Insert(const ItemType &data) // Note: ItemType
{
	// Call tree insertion function
	 InsertNode(Root, data); // Note
}

[CubiksRube]

What you suggested in the same errors of not being able to convert Person<int> to int