C++: unresolved external symbol

Error   1   error LNK2019: unresolved external symbol "public: __thiscall TreeNode::TreeNode(void)" (??0TreeNode@@QAE@XZ) referenced in function "public: __thiscall Or::Or(class TreeNode,class TreeNode)" (??0Or@@QAE@VTreeNode@@0@Z)   

#include <iostream>
#include "TreeNode.h"
#include "Table.h"

using namespace std;

TreeNode::TreeNode(TreeNode* Left, TreeNode* Right)
{
    LeftPtr = Left;
   RightPtr = Right;
}

Or::Or(TreeNode *Left,TreeNode *Right)
{
      LeftPtr = Left;
      RightPtr = Right;
}

Not::Not(TreeNode* Left,TreeNode* Right)
{
      LeftPtr = Left;
      RightPtr = NULL;
}
Xor::Xor(TreeNode* Left,TreeNode* Right)
{
      LeftPtr = Left;
      RightPtr = Right;
}
And::And(TreeNode* Left,TreeNode* Right)
{
      LeftPtr = Left;
      RightPtr = Right;
}
Variable::Variable(int Index, Table T)
{
   Value = T.GetVariableValue(Index);
};

bool Variable::Evaluate()
{
   return Value;
};

bool And::Evaluate()
{
   return (LeftPtr->Evaluate() && RightPtr->Evaluate());
};

bool Or::Evaluate()
{
   return (LeftPtr->Evaluate() || RightPtr->Evaluate());
};

bool Xor::Evaluate()
{
   return (LeftPtr->Evaluate() ^ RightPtr->Evaluate());
};

bool Not::Evaluate()
{
   return (!LeftPtr->Evaluate());
};




treenode.h


#ifndef __TREENODE_H__
#define __TREENODE_H__

#include <iostream>
#include "Table.h"

using namespace std;

class TreeNode
   
{
protected:
   TreeNode* LeftPtr;
   TreeNode* RightPtr;
public:
   TreeNode();
   TreeNode(TreeNode*, TreeNode*);
   virtual ~TreeNode(void)
   {
      delete [] LeftPtr;
      delete [] RightPtr;
   }
   virtual bool Evaluate(void)
   {
      return false;
   }
};

class Variable :public TreeNode

{
public:
   Variable(int, Table);
   bool Evaluate();
   virtual ~Variable()
   {
      delete [] LeftPtr;
      delete [] RightPtr;
   }
private:
   bool Value;
};

class Or : public TreeNode

{
public:
   Or(TreeNode* ,TreeNode* );
   virtual ~Or()
   {
      delete [] LeftPtr;
      delete [] RightPtr;
   };
   bool Evaluate();
private:

};

class Xor : public TreeNode

{   
public:
   Xor(TreeNode* ,TreeNode* );
   virtual ~Xor()
   {
      delete [] LeftPtr;
      delete [] RightPtr;
   };
   bool Evaluate();
private:

};

class Not : virtual public TreeNode
{

public:
   Not(TreeNode *,TreeNode *);
   virtual ~Not()
   {
      delete [] LeftPtr;
      delete [] RightPtr;
   };
   bool Evaluate();
private:

};

class And : public TreeNode
{
   
public:
   And(TreeNode *, TreeNode *);
   virtual ~And()
   {
      delete [] LeftPtr;
      delete [] RightPtr;
   };
   bool Evaluate();
private:

};

#endif


main


#include<iostream>
#include"Table.h"
#include"TreeNode.h"

const int N = 3;

void main()
{
   
   
Table *table = new Table(N);
table->SetVariable(0,true);
table->SetVariable(1,true);
table->SetVariable(2,true);

TreeNode* root = new Or (new Variable (0,*table),new Variable (1,*table));
   
}

#ifndef __TABLE_H__
#define __TABLE_H__



class Table
{
public:
   Table(int);
   ~Table();
   void SetVariable(const int IndexOfVariable, const bool NewValue);
   bool GetVariableValue(const int IndexOfVariable);
private:
   bool *ptrTable;
};

#endif


#include "Table.h"

Table::Table(int n)
{
   ptrTable = new bool[n];
}

Table::~Table()
{
   delete ptrTable;
}

void Table::SetVariable(const int IndexOfVariable, const bool NewValue)
{
   ptrTable[IndexOfVariable] = NewValue;
}

bool Table::GetVariableValue(const int IndexOfVariable)
{
   return(ptrTable[IndexOfVariable]);
};