C++ и кроссплатформенность

#include "avl.h"
 
 
int main(int argc, char * argv[])
{
    setlocale(LC_ALL,"Russian");
    int n,a,choice,findele,delele, l;
    ifstream In(argv[1]);
    Out.open(argv[2]);
    nodeptr root,root1,min,max; 
    char ch='y';
    bstree bst;
    root = NULL;
    root1=NULL;
    while(!In.eof())
    {
        In>>n;
        l = bst.insert(n,root);
        if( l == 1)
        {
            cout<<"\nНовый элемент добавлен успешно"<<endl;
            Out<<"\nНовый элемент добавлен успешно";
        }
        else
        {
            cout<<"\nЭлемет "<<n<<" существует!"<<endl;
            Out<<"\nЭлемет "<<n<<" существует!"<<endl;
        }
    }
    In.close();
    kk = bst.bsheight(root);
    cout<<"\n\t\t\t\tАВЛ Дерево\n"<<endl;
    do
    {
        cout<<"\t\t:::::::::::::::::::::::::::::::::::::::::"<<endl;
        cout<<"\t\t::::1 Вставить новый узел::::::::::::::::"<<endl;
        cout<<"\t\t::::2 Найти минимальный элемент::::::::::"<<endl;
        cout<<"\t\t::::3 Найти максимальный элемент:::::::::"<<endl;
        cout<<"\t\t::::4 Поиск по значению::::::::::::::::::"<<endl;
        cout<<"\t\t::::5 Удалить элемент::::::::::::::::::::"<<endl;
        cout<<"\t\t::::6 Префиксный обход в глубину:::::::::"<<endl;
        cout<<"\t\t::::7 Инфиксный обход в глубину::::::::::"<<endl;
        cout<<"\t\t::::8 Постфиксный обход в глубину::::::::"<<endl;
        cout<<"\t\t::::9 Обход в ширину:::::::::::::::::::::"<<endl;
        cout<<"\t\t::::10 Показать высоту дерева::::::::::::"<<endl;
        cout<<"\t\t::::0 Выход::::::::::::::::::::::::::::::"<<endl;
        cout<<"\t\t:::::::::::::::::::::::::::::::::::::::::\n"<<endl;
        
        cout<<"\nВыберите нужное действие и нажмите Enter: ";
        cin>>choice;
        
        switch(choice)
        {
            case 1:
                cout<<"\n\t\tДобавление нового узла"<<endl;
                cout<<"Введите элемент: ";
                cin>>a; 
                l = bst.insert(a,root);
                if( l == 1)
                {
                    cout<<"\nНовый элемент добавлен успешно"<<endl;
                    Out<<"\nНовый элемент добавлен успешно";
                }
                else
                {
                    cout<<"\nЭлемет "<<a<<" существует!"<<endl;
                    Out<<"\nЭлемет "<<a<<" существует!"<<endl;
                }
                cout<<endl;
                break;
            case 2:
                if (root !=NULL)
                {
                    min=bst.findmin(root);
                    Out<<"\nМинимальный элемент в дереве: "<<min->element;
                }
                break;
            case 3:
                if (root !=NULL)
                {
                    max=bst.findmax(root);
                    Out<<"\nМаксимальный элемент в дереве: "<<max->element;
                }
                break;
            case 4:
                cout<<"\nВведите искомый элемент: ";
                cin>>findele;
                if (root != NULL)
                {
                    bst.find(findele,root);
                }
                break;
            case 5:
                cout<<"\nКакой узел удалять? : ";
                cin>>delele;
                bst.del(delele,root);
                cout<<endl;
                break;
            case 6:
                Out<<"\nПрефиксный обход в глубину: ";
                bst.preorder(root);
                break;
            case 7:
                Out<<"\nИнфиксный обход в глубину: ";
                bst.inorder(root);
                break;
            case 8:
                Out<<"\nПостфиксный обход в глубину: ";
                bst.postorder(root);
                break;
            case 9:
                Out<<"\nОбход в ширину: ";
                bst.width(root);
                break;
            case 10:
                cout<<"\n\t\tВЫСОТА\n"<<endl;
                cout<<"\nДерево имеет высоту: "<<bst.bsheight(root)<<endl;
                break;
            case 0:
                cout<<"\n\tБлагодарим вас за использование програмы"<<endl;
                break;
            default:
                cout<<"\nОшибка ввода!"<<endl;
                break;
        }
        system("pause");
        system("cls");
    }while(choice != 0);
    Out.close();
    
    return 0;
}

#ifndef __AVL_H_
#define __AVL_H_
#pragma once
 
#include <fstream>
#include <iostream>
#include <queue>
 
using namespace std;
 
int kk;
ofstream Out;
 
struct node
{
    int element;
    node *left;
    node *right;
    int height;
};
typedef struct node *nodeptr;
class bstree
{
    public:
        void print (int z, node * root, short x, short y, short a, char c);
        int insert(int,nodeptr &);
        void del(int, nodeptr &);
        int deletemin(nodeptr &);
        void find(int,nodeptr &);
        nodeptr findmin(nodeptr);
        nodeptr findmax(nodeptr);
        void makeempty(nodeptr &);
        void copy(nodeptr &,nodeptr &);
        nodeptr nodecopy(nodeptr &);
        void preorder(nodeptr);
        void inorder(nodeptr);
        void postorder(nodeptr);
        void width(nodeptr);
        int bsheight(nodeptr);
        nodeptr srl(nodeptr &);
        nodeptr drl(nodeptr &);
        nodeptr srr(nodeptr &);
        nodeptr drr(nodeptr &);
        int maxx(int,int);
        int nonodes(nodeptr);
};
 
// Inserting a node
int bstree::insert(int x,nodeptr &p)
{
    int y;
    if (p == NULL)
    {
        y = 1;
        p = new node;
        p->element = x;
        p->left=NULL;
        p->right = NULL;
        p->height=0;
        if (p==NULL)
        {
            cout<<"Недостаточно места\n"<<endl;
            Out<<"Недостаточно места\n"<<endl;
        }
    }
    else
    {
        y = 1;
        if (x<p->element)
        {
            y = insert(x,p->left);
            if ((bsheight(p->left) - bsheight(p->right))==2)
            {
                if (x < p->left->element)
                {
                    p=srl(p);
                }
                else
                {
                    p = drl(p);
                }
            }
        }
        else if (x>p->element)
        {
            y = insert(x,p->right);
            if ((bsheight(p->right) - bsheight(p->left))==2)
            {
                if (x > p->right->element)
                {
                    p=srr(p);
                }
                else
                {
                    p = drr(p);
                }
            }
        }
        else
        {
            y = 0;
            return y;
        }
    }
int m,n,d;
m=bsheight(p->left);
n=bsheight(p->right);
d=max(m,n);
p->height = d + 1;
return y;
}
// Finding the Smallest
nodeptr bstree::findmin(nodeptr p)
{
    if (p==NULL)
    {
        cout<<"В дереве нет элементов\n"<<endl;
        Out<<"В дереве нет элементов\n"<<endl;
        return p;
    }
    else
    {
        while(p->left !=NULL)
        {
            p=p->left;
        }
        return p;
    }
}
// Finding the Largest node
nodeptr bstree::findmax(nodeptr p)
{
    if (p==NULL)
    {
        cout<<"В дереве нет элементов\n"<<endl;
        Out<<"В дереве нет элементов\n"<<endl;
        return p;
    }
    else
    {
        while(p->right !=NULL)
        {
            p=p->right;
        }
        return p;
    }
}
// Finding an element
void bstree::find(int x,nodeptr &p)
{
    if (p == NULL)
    {
        Out<<"\nПростите, но элемента "<<x<<" не существует";
    }
    else
    {
        if (x < p->element)
        {
            find(x,p->left);
        }
        else
        {
            if (x > p->element)
            {
                find(x,p->right);
            }
            else
            {
                Out<<"\nЭлемент "<<x<<" существует";
            }
        }
    }
}
// Copy a tree
void bstree::copy(nodeptr &p,nodeptr &p1)
{
    makeempty(p1);
    p1 = nodecopy(p);
}
// Make a tree empty
void bstree::makeempty(nodeptr &p)
{
    nodeptr d;
    if (p != NULL)
    {
        makeempty(p->left);
        makeempty(p->right);
        d=p;
        free(d);
        p=NULL;
    }
}
// Copy the nodes
nodeptr bstree::nodecopy(nodeptr &p)
{
    nodeptr temp;
    if (p==NULL)
    {
        return p;
    }
    else
    {
        temp = new node;
        temp->element = p->element;
        temp->left = nodecopy(p->left);
        temp->right = nodecopy(p->right);
        return temp;
    }
}
// Deleting a node
void bstree::del(int x,nodeptr &p)
{
    nodeptr d;
    if (p==NULL)
    {
        cout<<"Простите, но такого элемента нет\n"<<endl;
        Out<<"Простите, но элемента, который вы хотите удалить, нет\n"<<endl;
    }
    else if ( x < p->element)
    {
        del(x,p->left);
    }
    else if (x > p->element)
    {
        del(x,p->right);
    }
    else if ((p->left == NULL) && (p->right == NULL))
    {
        d=p;
        Out<<"Элемент "<<p->element<<" удален\n"<<endl;
        free(d);
        p=NULL;
        cout<<"Элемент удален\n"<<endl;
    }
    else if (p->left == NULL)
    {
        d=p;
        Out<<"Элемент "<<p->element<<" удален\n"<<endl;
        free(d);
        p=p->right;
        cout<<"Элемент удален\n"<<endl;
    }
    else if (p->right == NULL)
    {
        d=p;
        Out<<"Элемент "<<p->element<<" удален\n"<<endl;
        p=p->left;
        free(d);
        cout<<"Элемент удален\n"<<endl;
    }
    else
    {
        Out<<"Элемент "<<p->element<<" удален\n"<<endl;
        p->element = deletemin(p->right);
        cout<<"Элемент удален\n"<<endl;
    }
}
int bstree::deletemin(nodeptr &p)
{
    int c;
    if (p->left == NULL)
    {
        c=p->element;
        p=p->right;
        return c;
    }
    else
    {
        c=deletemin(p->left);
        return c;
    }
}
void bstree::preorder(nodeptr p)
{
    if (p!=NULL)
    {
        Out<<p->element<<" ";
        preorder(p->left);
        preorder(p->right);
    }
}
// Inorder Printing
void bstree::inorder(nodeptr p)
{
    if (p!=NULL)
    {
        inorder(p->left);
        Out<<p->element<<" ";
        inorder(p->right);
    }
}
// PostOrder Printing
void bstree::postorder(nodeptr p)
{
    if (p!=NULL)
    {
        postorder(p->left);
        postorder(p->right);
        Out<<p->element<<" ";
    }
}
void bstree::width(nodeptr p)
{
    queue<nodeptr> myQueue;
    myQueue.push(p);
    while(!myQueue.empty())
    {
        if(myQueue.front()->left != NULL)
        {
            myQueue.push(myQueue.front()->left);
        }
        if(myQueue.front()->right != NULL)
        {
            myQueue.push(myQueue.front()->right);
        }
        Out<<myQueue.front()->element<<" ";
        myQueue.pop();
    }
    cout<<myQueue.size();
}
int bstree::maxx(int value1, int value2)
{
    return ((value1 > value2) ? value1 : value2);
}
int bstree::bsheight(nodeptr p)
{
    int t;
    if (p == NULL)
    {
        return -1;
    }
    else
    {
        t = p->height;
        return t;
    }
}
nodeptr bstree:: srl(nodeptr &p1)
{
    nodeptr p2;
    p2 = p1->left;
    p1->left = p2->right;
    p2->right = p1;
    p1->height = max(bsheight(p1->left),bsheight(p1->right)) + 1;
    p2->height = max(bsheight(p2->left),p1->height) + 1;
    return p2;
}
nodeptr bstree:: srr(nodeptr &p1)
{
    nodeptr p2;
    p2 = p1->right;
    p1->right = p2->left;
    p2->left = p1;
    p1->height = max(bsheight(p1->left),bsheight(p1->right)) + 1;
    p2->height = max(p1->height,bsheight(p2->right)) + 1;
    return p2;
}
nodeptr bstree:: drl(nodeptr &p1)
{
    p1->left=srr(p1->left);
    return srl(p1);
}
nodeptr bstree::drr(nodeptr &p1)
{
    p1->right = srl(p1->right);
    return srr(p1);
}
int bstree::nonodes(nodeptr p)
{
    int count=0;
    if (p!=NULL)
    {
        nonodes(p->left);
        nonodes(p->right);
        count++;
    }
    return count;
}
 
#endif

#ifdef _WIN32
#define CLEAR "cls"
#else //In any other OS
#define CLEAR "clear"
#endif
getch();
system(CLEAR);