Can You tell me what I am doing wrong, please?

[The wizard91]

I am to implement a Binary search class for assignment but I am bumping into so many errors that I don't even know how to fix it. I am searching on the net for answers and trying whatever I see out or just guessing stuff of desperation any suggestion would be great thanks in advance. I usually do not seek for help with we just transitioned from Python to c++ and it is really painful to understand its complexities. Here are the three methods that I am working with.
There are some changes since I kept working on it...

//TreeNode header file
// TreeNode.h
#ifndef __TREENODE__H__
#define __TREENODE__H__
#include <iostream>
#include <cstdlib> // for NULL

class TreeNode{
	
	friend class BST;
	friend std::ostream& operator<<(std::ostream &os,const TreeNode &tnode );
	
public:
 TreeNode(int item, TreeNode* left = NULL, TreeNode* right = NULL);
 
 bool rightChild(int &c); 
 // returns False if no right child, otherwise c gets the value of the right child
 
 bool leftChild(int &c);
 // returns False if no left child, otherwise c gets the value of the left child
	
private:
 TreeNode(const TreeNode &tnode); // no Copy Constructor
 void operator=(const TreeNode &tnode); // no assignment operator
 int _item;
 TreeNode* _left;
 TreeNode* _right;
		
};

std::ostream& operator<<(std::ostream &os,const TreeNode &tnode );

//TreeNode omplemenation file

#include "TreeNode.h"
#include <cstdlib>

TreeNode::TreeNode(int item, TreeNode* left, TreeNode* right) {
	_item = item;
	_left = left;
	_right = right;
}

bool TreeNode::leftChild(int &c) {
	if (_left != NULL) { 
		c = _left -> _item;
		return true;}
	else {
		return false; }
}

bool TreeNode::rightChild(int &c) {
	if (_right != NULL) { 
		c = _right -> _item;
		return true;}
	else {
		return false; }
}

std::ostream& operator<<(std::ostream &os,const TreeNode &tnode ){
	os << " " << tnode._item << " ";

	return os;
}

// BST header file

// BST.h
#ifndef __BST__H__
#define __BST__H__
#include <iostream>
#include <cstdlib> // for NULL
#include <vector>
#include "TreeNode.h"

class BST{
	friend std::ostream& operator<<(std::ostream &os,const BST &tree );
	
public:	
	BST() { _root = NULL; numberOfNodes = 0; } // creates empty tree
	~BST(); // destructor, uses dealloc
	
	bool insert(const int &item); // returns False if not possible to insert (eg. duplicates are not allowed)
	int getNumberOfNodes() const { return numberOfNodes;};
	bool find(const int &target) const;
	void Delete(int target);
		
private:
	void _subtreeAddItems (const TreeNode *node, std::vector<int> &tmp) const; // helper for ostream operation
	void dealloc(TreeNode *node); // recursuve function deallocating the TreeNodes
	TreeNode *_root;
	size_t _height; // height of the tree
	size_t numberOfNodes; // keeps track of number of nodes in the tree
	BST _subtreeDelete(TreeNode *node, int &target);
	int _subtreeDeleteMax(const *node);
		
};

std::ostream& operator<<(std::ostream &os,const BST &tree ); 
	// uses _subtreeAddItems

#endif


// BST implementation file

#endif
#include <cstdlib>
#include <iostream>
//#include <string>
#include <vector>
#include "BST.h"

using namespace std;

BST::~BST(){ // destructor
	if (_root != NULL) { 
		dealloc(_root);
	}
}

void BST::dealloc(TreeNode *node) // helper method
{ // deallocates all nodes in the binary search tree recursively
  TreeNode *lnode, *rnode;

  lnode = node->_left;
  rnode = node->_right;
  
  if (lnode != NULL) {dealloc(lnode);}
  if (rnode != NULL) {dealloc(rnode);}
  
  delete node;
}

bool BST::insert(const int &item)
{
	if (_root == NULL) { // handle empty tree case
		_root = new TreeNode(item);
	}
	
	else{
		TreeNode *node;
		node = _root; // start at root
		
		while (true)
		{
			if (item == node->_item){ // found a duplicate
				return false; 
			}			
			
			if (item < node->_item){ // item goes in the left subtree because target is less than the element in current node
				if (node->_left != NULL){ // left subtree is not empty
					node = node -> _left; // proceed to the left until it is None
				}
				else { // now is empty (we have reahed the leftmost node) subtree, insert here
					node -> _left = new TreeNode(item);
					break;
				}
				
			}
			// our target is bigger than the element at current node, therefore, go to the right
			else { // item goes in the right subtree
				if (node->_right != NULL){ // left subtree is not empty
					node = node -> _right; 
				}
				else { // empty subtree, insert here
					node -> _right = new TreeNode(item);
					break;
				}
			}
		}
		
	}
	
	++numberOfNodes;
}

bool BST::find(const int &target) const{
	TreeNode *node;
	
	node = _root;
	
	while ((node!= NULL) && (node->_item != target)){
		if (target < node->_item){
			node = node->_left;
		}
		else {
			node = node -> _right;}
	}
	
	if (node == NULL) {return false;}
	else {return true;}
}

void BST::_subtreeAddItems (const TreeNode *node, vector<int> &tmp) const{
	if (node != NULL) {
		_subtreeAddItems(node->_left,tmp);
		tmp.push_back(node->_item);
		_subtreeAddItems(node->_right,tmp);
	}
	
}

void BST::Delete(int target)
{
	//TreeNode *node;
	//_root = node;
	int item;
	item = target;
	 *_root;
	*_root = _subtreeDelete(_root, item);
}
BST BST::_subtreeDelete(const TreeNode *node, int  &target)
{
	//*_root;
	_root = node;
	if (_root)// same as node != NULL. If it is empty.
	{
		return NULL;
	}
	if (item < _root->_item)
	{
		_root->_left = _subtreeDelete(_root->_left, item);
	}
	else if (item > _root->_item)
	{
		_root->_right = _subtreeDelete(_root->_right, item);
	}
	else
	{
		if (_root->_left == NULL)
		{
			_root = _root->_right;
		}
		else if (_root->_right)
		{
			_root = _root->_left;
		}
		else
		{
			_root->_item = _subtreeDelMax(_root);
		}
	return _root;
	}
}
int BST::_subtreeDelMax(TreeNode *node);
{
	//TreeNode *node;
	_root = node;
	int maxVal;
	if (_root->_right == NULL)
	{
		this->_left = _root->_left;
		return this->_item;
	}
	else
	{
		_root->_right = _root->_right;
		maxVal = _subtreeDelMax(_root->_right);
		return maxVal;
	}
}
std::ostream& operator<<(std::ostream &os,const BST &tree ){
	vector<int> tmp;
	
	tree._subtreeAddItems(tree._root,tmp); // recursive helper method
	
	for(vector<int>::iterator list_iter = tmp.begin(); list_iter != tmp.end(); list_iter++) {
    	os << *list_iter << "  " ; }

    os << endl;

	return os;

}

// Test code contatining the main

#include "TreeNode.h"
#include <cstdlib>

TreeNode::TreeNode(int item, TreeNode* left, TreeNode* right) {
	_item = item;
	_left = left;
	_right = right;
}

bool TreeNode::leftChild(int &c) {
	if (_left != NULL) { 
		c = _left -> _item;
		return true;}
	else {
		return false; }
}

bool TreeNode::rightChild(int &c) {
	if (_right != NULL) { 
		c = _right -> _item;
		return true;}
	else {
		return false; }
}

std::ostream& operator<<(std::ostream &os,const TreeNode &tnode ){
	os << " " << tnode._item << " ";

	return os;
}

[Handy Andy]

Hello The wizard91.

PLEASE ALWAYS USE CODE TAGS (the <> formatting button) when posting code.
It makes it easier to read your code and also easier to respond to your post.
http://www.cplusplus.com/articles/jEywvCM9/
http://www.cplusplus.com/articles/z13hAqkS/
Hint: You can edit your post, highlight your code and press the <> formatting button.
You can use the preview button at the bottom to see how it looks.

All I see is the .cpp file to define the member functions of the class. With knowing what the class looks like it is only a guess t what might be wrong. Seeing the class and what you started out with in main would be helpful.

Andy

[The wizard91]

Hello, Andy, I uploaded the entire file because I believe that the error is on declaring the types. Thanks for the format link it did help.

[AbstractionAnon]

Line 33: You're missing an #endif to terminate your include guard.

Line 108: extraneous #endif

Line 96: type is missing (TreeNode ?)

Line 211: This statement does nothing.

Line 212: _subtreeDelete returns a BST by value. You're trying to assign that to a TreeNode pointer (_root).

That's about as far as I could go without fixing the _subtreeDelete problem.

[The wizard91]

@ AbstractionAnon thanks.