Раздельная компиляция

//ClassTree.h
 
#pragma once
 
class Node{
 
private:
    int id;
    Node *left;
    Node *right;
public: 
    Node * first();
    void search(Node *root, int digit);
    Node * insert(Node *root, int digit);
    void print_tree(Node *root, int level);
    int max_internal(Node *root);
    Node * delete_key(Node *root, int digit);
 
};

//ForClass.cpp
 
#include "ClassTree.h"
#include <iostream.h>
 
Node * Node::first(){
    cout << "Root's id: ";
    int temp = 0;
    cin >> temp;
    Node *pv = new Node;
    pv->id = temp;
    pv->left = 0;
    pv->right = 0;
    return pv;
}
 
void Node::search(Node *root, int digit){
    Node *pv = root;
    bool found = false;
    while (pv && !found){
        if (digit == pv->id){
            cout << "Digit " << digit << " was found!";
            found = true;
        }
        else if (digit < pv->id){ 
            pv = pv -> left;
        }
        else{
            pv = pv -> right;
        }
    }
    cout << "Digit " << digit << " was not found!";
}
 
Node * Node::insert(Node *root, int digit){
    Node *pv = root; 
    Node *prev = 0;
    while (pv){
        prev = pv;
        if (digit == pv->id){
            return pv;
        }
        else if (digit < pv->id){ 
            pv = pv -> left;
        }
        else{
            pv = pv -> right;
        }
    }
    Node *pnew = new Node;
    pnew->id = digit;
    pnew->left = 0;
    pnew->right = 0;
    if (digit < prev->id){
        prev->left = pnew;
    }
    else{
        prev->right = pnew;
    }
    return pnew;
 
}
 
void Node::print_tree(Node *root, int level){
    if (root){
        print_tree(root->left, level + 1);
        for (int i = 0; i < level; i++){
            cout << " ";
        }
        cout << root->id << endl; 
        print_tree(root->right, level +1); 
    }
}
 
int Node::max_internal(Node *root){
    int temp_max = root->id;
    Node *pv = root;
    while (pv){
        temp_max = pv->id;
        pv = pv -> right;
        if(pv->left == 0 && pv->right == 0){
            break;
        }
    }
    return temp_max;
}
 
 
Node * Node::delete_key(Node *root, int digit){
   Node* P, *v;
   if (!root){
      cout << "Tree is empty!\n";
      }
   else if (digit < root->id){
      root->left = delete_key(root->left, digit);
      }
   else if (digit > root-> id){
      root->right = delete_key(root->right, digit);
      }
   else{
      P = root;
      if (!root->right){
          root = root->left;
      }
      else if (!root->left){
         root = root->right;
      }
      else{
         v = root->left;
         if (v->right){
             while (v->right->right){
                 v = v->right;
             }
            root->id = v->right->id;
            P = v->right;
            v->right = v->right->left;
         }
         else{
            root->id = v->id;
            P = v;
            root->left = root->left->left;
         }
      }
   }
   return root;
}

//ForMain.cpp
 
#include "ClassTree.h"
#include <stdlib.h>
#include <iostream.h>
 
void generation(Node *root){
    int low_range = 0;
    cout << "Low range: ";
    cin >> low_range;
 
    int high_range = 0;
    cout << "High range: ";
    cin >> high_range;
 
    int amount = 0;
    cout << "Amount of nodes: ";
    cin >> amount;
 
    for(int i = 0; i < amount - 1; ++i){
        root->insert(root, ( rand() % (high_range - low_range) + low_range) );
    }
    cout << amount << " new digits was entered in the tree!\n";
}
 
bool menu(Node *root){
    int solution = 0;
    int temp = 0;
    cout << "\nMenu:\n1 - insert\n2 - print\n3 - delete key\n4 - max internal \
        \n5 - search\n6 - generation\nelse - exit.\nYour solution: ";
    cin >> solution;
    cout << endl;
    switch(solution){
    case 1:{
        cout << "\nNew digit: ";
        cin >> temp;
        root->insert(root, temp);
        break;
           }
    case 2:{
        root->print_tree(root, 0);
        break;
           }
    case 3:{
        cout << "\nDigit for delete: ";
        cin >> temp;
        root->delete_key(root, temp);
        break;
           }
    case 4:{
        cout << "Max internal: " << root->max_internal(root) << endl;
        break;
           }
    case 5:{
        cout << "\nDigit for search: ";
        cin >> temp;
        root->search(root, temp);
        break;
           }
    case 6:{
        generation(root);
        break;
           }
    default:{
        cout << "Exit." << endl;
        return false;
            }
    }
    return true;
}

//Main.cpp
#include "ClassTree.h"
 
bool menu(Node *root);
 
int main(){
 
    Node *P1 = P1->first();
 
    do{
    }while( menu(P1) );
    return 0;
}

#include <iostream>