Как правильно перегрузить оператор [] =

int & A::operator []( int i ) {
    return m_array[i] = num;
}

#include "Var.h"
 
void main() {
 
 
    Var first;
    //Var second = 10;
    //int a = 88;
    //first = 10.6;
    //first = first + 1;
    /*first = "aaa";
    if(first < "aaa") {
        cout<<"good";
    }*/
    //first*=2;
 
    first._array();
    first[0] = 199;
 
    //first.show();
    cout<<"\n\n\n";
    system("pause");
 
}

#include <iostream>
#include <string>
 
using namespace std;
 
class Var{
 
public:
 
    Var(void);
    ~Var(void);
 
    Var(const int&);
    Var(const double&);
    Var(const string&);
    Var(const char*);
    Var(const Var&);
 
    Var & operator = (const int&);
    Var & operator = (const double&);
    Var & operator = (const string&);
    Var & operator = (const char*);
    Var & operator = (const Var&);
 
    Var operator + (const int&);
    Var operator + (const double&);
    Var operator + (const string&);
    Var operator + (const char*);
    Var operator + (const Var&);
 
    bool operator == (const int&);
    bool operator == (const double&);
    bool operator == (const string&);
    bool operator == (const char*);
    bool operator == (const Var&);
 
    bool operator >= (const int&);
    bool operator >= (const double&);
    bool operator >= (const string&);
    bool operator >= (const char*);
    bool operator >= (const Var&);
 
    bool operator <= (const int&);
    bool operator <= (const double&);
    bool operator <= (const string&);
    bool operator <= (const char*);
    bool operator <= (const Var&);
 
    bool operator < (const int&);
    bool operator < (const double&);
    bool operator < (const string&);
    bool operator < (const char*);
    bool operator < (const Var&);
 
    bool operator > (const int&);
    bool operator > (const double&);
    bool operator > (const string&);
    bool operator > (const char*);
    bool operator > (const Var&);
 
    bool operator != (const int&);
    bool operator != (const double&);
    bool operator != (const string&);
    bool operator != (const char*);
    bool operator != (const Var&);
 
 
    Var operator - (const int&);
    Var operator - (const double&);
    Var operator - (const Var&);
 
    Var operator * (const int&);
    Var operator * (const double&);
    Var operator * (const Var&);
 
    Var operator / (const int&);
    Var operator / (const double&);
    Var operator / (const Var&);
 
 
    Var & operator += (const int&);
    Var & operator += (const double&);
    Var & operator += (const string&);
    Var & operator += (const char*);
    Var & operator += (const Var&);
 
 
    Var & operator -= (const int&);
    Var & operator -= (const double&);
    Var & operator -= (const string&);
    Var & operator -= (const char*);
    Var & operator -= (const Var&);
 
    Var & operator *= (const int&);
    Var & operator *= (const double&);
    Var & operator *= (const string&);
    Var & operator *= (const char*);
    Var & operator *= (const Var&);
 
    Var & operator /= (const int&);
    Var & operator /= (const double&);
    Var & operator /= (const string&);
    Var & operator /= (const char*);
    Var & operator /= (const Var&);
 
    int & operator [] (const int&);
 
    void show();
    void _array(); //делает из обьекта массив или наоборот
    int & add_new_element_to_array( const int& );
    
 
private:
    int vector;
    int count_vector;
    Var * Link;
    int num;
    double dnum;
    string str;
 
 
};

#include "Var.h"
 
Var::Var(void){
    this->num=INT_MIN;
    this->dnum= DBL_MIN;
    this->str = "";
    this->vector = 0;
    this->Link = 0;
    this->count_vector = 0;
};
 
Var::~Var(void){
};
 
 
//start-------------------------------оператоp (=)----------------------------start//
Var &Var::operator = (const int& i){
    this->num=i;
    this->dnum= DBL_MIN;
    this->str = "";
    return *this;
}
Var& Var::operator = (const double& i){
    this->dnum=i;
    this->num=INT_MIN;
    this->str = "";
    return *this;
}
Var &Var::operator = (const string& st){
    this->str=st;
    this->num=INT_MIN;
    this->dnum= DBL_MIN;
    return *this;
}
Var &Var::operator = (const Var& cl){
 
    this->num = cl.num;
    this->dnum = cl.dnum;
    this->str = cl.str;
    return *this;
}
 
Var &Var::operator = (const char* ch){
    this->num=INT_MIN;
    this->dnum= DBL_MIN;
    string result(ch);
    this->str=result;
    return *this;
}
 
 
 
//end -------------------------------оператоp (=)----------------------------end//
 
 
 
//start-------------------------------оператор присваения----------------------------start//
Var::Var(const int& i){
    this->num=i;
    this->dnum= DBL_MIN;
    this->str = "";
}
Var::Var(const double& i){
    this->dnum=i;
    this->num=INT_MIN;
    this->str = "";
}
Var::Var(const string& st){
    this->str=st;
    this->num=INT_MIN;
    this->dnum= DBL_MIN;
}
Var::Var(const Var& cl){
 
    this->num = cl.num;
    this->dnum = cl.dnum;
    this->str = cl.str;
}
Var::Var(const char* ch){
    this->num=INT_MIN;
    this->dnum= DBL_MIN;
    string result(ch);
    this->str=result;
}
 
 
 
//end -------------------------------оператор присваения----------------------------end//
 
 
//start-------------------------------оператоp (+)----------------------------start//
Var Var::operator + (const int& i){
 
    Var temp;
    if(this->num != INT_MIN){
        temp.num = this->num+i;
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum+i;
    }else{
        string result = this->str + to_string(i);
        temp.str = result;
 
    }
    return temp;
}
 
Var  Var::operator + (const double& i){
    Var temp;
    if(this->num != INT_MIN){
        temp.num = INT_MIN;
        temp.dnum = (double)this->num+i;
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum+i;
    }else{
        string result = this->str + to_string(i);
        temp.str = result;
    }
    return temp;
}
 
Var  Var::operator + (const string& str){
    Var temp;
    temp.str = this->str+str;
    return temp;
}
 
 
Var  Var::operator +(const char* ch){
    Var temp;
    string result(ch);
    temp.str = this->str+result;
    return temp;
}
 
Var Var::operator + (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            temp.num = this->num+cl.num;
        }else if( cl.dnum != DBL_MIN){
            temp.num = INT_MIN;
            temp.dnum = (double)this->num+cl.dnum;
        }else{
            temp.num = this->num;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
            temp.dnum = this->dnum+cl.num;
        }else if( cl.dnum != DBL_MIN){
            temp.dnum = this->dnum+cl.dnum;
        }else{
            temp.dnum = this->dnum;
        }
    }else{
        if(cl.num != INT_MIN){
            string result = this->str + to_string(cl.num);
            temp.str = result;
            temp.dnum = this->dnum+cl.num;
        }else if( cl.dnum != DBL_MIN){
            string result = this->str + to_string(cl.dnum);
            temp.str = result;
        }else{
            temp.str = this->str+cl.str;
        }
 
    }
    return temp;
}
//end-------------------------------оператоp (+)----------------------------end//
 
 
 
//start-------------------------------оператоp (-) ----------------------------start//
Var Var::operator - (const int& i){
    Var temp;
    if(this->num != INT_MIN){
        temp.num = this->num-i;
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum-i;
    }else{
        temp.str = this->str;
    }
    return temp;
}
 
Var  Var::operator - (const double& i){
    Var temp;
    if(this->num != INT_MIN){
        temp.num =INT_MIN;
        temp.dnum = (double)this->num-i;
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum-i;
    }else{
        temp.str = this->str;
    }
    return temp;
}
Var Var::operator - (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            temp.num = this->num-cl.num;
        }else if( cl.dnum != DBL_MIN){
            temp.num = INT_MIN;
            temp.dnum = (double)this->num-cl.dnum;
        }else{
            temp.num = this->num;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
            temp.dnum = this->dnum-cl.num;
        }else if( cl.dnum != DBL_MIN){
            temp.dnum = this->dnum-cl.dnum;
        }else{
            temp.dnum = this->dnum;
        }
    }else{
        temp.str = this->str;
    }
    return temp;
}
//end-------------------------------оператоp (-) ----------------------------end//
 
//start-------------------------------оператоp (*) ----------------------------start//
Var Var::operator * (const int& i){
    Var temp;
    if(this->num != INT_MIN){
        temp.num = this->num*i;
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum*i;
    }else{
        temp.str = this->str;
    }
    return temp;
}
 
Var  Var::operator * (const double& i){
    Var temp;
    if(this->num != INT_MIN){
        temp.num = INT_MIN;
        temp.dnum = (double)this->num*i;
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum*i;
    }else{
        temp.str = this->str;
    }
    return temp;
}
Var Var::operator * (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            temp.num = this->num*cl.num;
        }else if( cl.dnum != DBL_MIN){
            temp.num = INT_MIN;
            temp.dnum = (double)this->num*cl.dnum;
        }else{
            temp.num = this->num;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
            temp.dnum = this->dnum*cl.num;
        }else if( cl.dnum != DBL_MIN){
            temp.dnum = this->dnum*cl.dnum;
        }else{
            temp.dnum = this->dnum;
        }
    }else{
        temp.str = this->str;
    }
    return temp;
}
//end-------------------------------оператоp (*) ----------------------------end//
 
//start-------------------------------оператоp (/) ----------------------------start//
Var Var::operator / (const int& i){
    Var temp;
    if(this->num != INT_MIN){
        if(!(this->num%i)){
            temp.num = this->num/i;
        }else{
            temp.num = INT_MIN;
            temp.dnum = (double)this->num/i;
        }
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum/i;
    }else{
        temp.str = this->str;
    }
    return temp;
}
 
Var  Var::operator / (const double& i){
    Var temp;
    if(this->num != INT_MIN){
        temp.num = INT_MIN;
        temp.dnum = (double)this->num/i;
    }else if(this->dnum != DBL_MIN){
        temp.dnum = this->dnum/i;
    }else{
        temp.str = this->str;
    }
    return temp;
}
Var Var::operator / (const Var& cl){
 
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(!(this->num%cl.num)){
                temp.num = this->num/cl.num;
            }else{
                temp.num = INT_MIN;
                temp.dnum = (double)this->num/cl.num;
            }
        }else if( cl.dnum != DBL_MIN){
            temp.num = INT_MIN;
            temp.dnum = (double)this->num/cl.dnum;
        }else{
            temp.num = this->num;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
            temp.dnum = this->dnum/cl.num;
        }else if( cl.dnum != DBL_MIN){
            temp.dnum = this->dnum/cl.dnum;
        }else{
            temp.dnum = this->dnum;
        }
    }else{
        temp.str = this->str;
    }
    return temp;
}
//end-------------------------------оператоp (/) ----------------------------end//
 
//start-------------------------------оператоp (==)----------------------------start//
bool Var::operator == (const int& i){
    if(this->num == i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator == (const double& i){
    if(this->dnum == i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator == (const string& str){
    if(this->str == str) {
        return true;
    }else{
        return false;
    }
}
 
 
bool  Var::operator == (const char* ch){
 
    string result(ch);
    if(this->str==result) {
        return true;
    }else{
        return false;
    }
 
}
 
bool Var::operator == (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(this->num == cl.num){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.dnum != DBL_MIN){
            if(this->dnum == cl.dnum){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else{
        if(this->str == cl.str){
            return true;
        }else{
            return false;
        }
    }
 
}
//end-------------------------------оператоp (==)----------------------------end//
 
 
//start-------------------------------оператоp (>=)----------------------------start//
bool Var::operator >= (const int& i){
    if(this->num >= i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator >= (const double& i){
    if(this->dnum >= i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator >= (const string& str){
    if(this->str.length() >= str.length()) {
        return true;
    }else{
        return false;
    }
}
 
 
bool  Var::operator >= (const char* ch){
 
    string result(ch);
    if(this->str.length()>=result.length()) {
        return true;
    }else{
        return false;
    }
 
}
 
bool Var::operator >= (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(this->num >= cl.num){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.dnum != DBL_MIN){
            if(this->dnum >= cl.dnum){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else{
        if(this->str.length() >= cl.str.length()){
            return true;
        }else{
            return false;
        }
    }
 
}
//end-------------------------------оператоp (>=)----------------------------end//
 
//start-------------------------------оператоp (<=)----------------------------start//
bool Var::operator <= (const int& i){
    if(this->num <= i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator <= (const double& i){
    if(this->dnum <= i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator <= (const string& str){
    if(this->str.length() <= str.length()) {
        return true;
    }else{
        return false;
    }
}
 
 
bool  Var::operator <= (const char* ch){
 
    string result(ch);
    if(this->str.length()<=result.length()) {
        return true;
    }else{
        return false;
    }
 
}
 
bool Var::operator <= (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(this->num <= cl.num){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.dnum != DBL_MIN){
            if(this->dnum <= cl.dnum){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else{
        if(this->str.length() <= cl.str.length()){
            return true;
        }else{
            return false;
        }
    }
 
}
//end-------------------------------оператоp (<=)----------------------------end//
 
//start-------------------------------оператоp (<)----------------------------start//
bool Var::operator < (const int& i){
    if(this->num < i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator < (const double& i){
    if(this->dnum < i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator < (const string& str){
    if(this->str.length() < str.length()) {
        return true;
    }else{
        return false;
    }
}
 
 
bool  Var::operator < (const char* ch){
 
    string result(ch);
    if(this->str.length()<result.length()) {
        return true;
    }else{
        return false;
    }
 
}
 
bool Var::operator < (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(this->num < cl.num){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.dnum != DBL_MIN){
            if(this->dnum < cl.dnum){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else{
        if(this->str.length() < cl.str.length()){
            return true;
        }else{
            return false;
        }
    }
 
}
//end-------------------------------оператоp (<)----------------------------end//
 
//start-------------------------------оператоp (>)----------------------------start//
bool Var::operator > (const int& i){
    if(this->num > i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator > (const double& i){
    if(this->dnum > i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator > (const string& str){
    if(this->str.length() > str.length()) {
        return true;
    }else{
        return false;
    }
}
 
 
bool  Var::operator > (const char* ch){
 
    string result(ch);
    if(this->str.length()>result.length()) {
        return true;
    }else{
        return false;
    }
 
}
 
bool Var::operator > (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(this->num > cl.num){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.dnum != DBL_MIN){
            if(this->dnum > cl.dnum){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else{
        if(this->str.length() > cl.str.length()){
            return true;
        }else{
            return false;
        }
    }
 
}
//end-------------------------------оператоp (>)----------------------------end//
 
//start-------------------------------оператоp (!=)----------------------------start//
bool Var::operator != (const int& i){
    if(this->num != i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator != (const double& i){
    if(this->dnum != i) {
        return true;
    }else{
        return false;
    }
}
 
bool  Var::operator != (const string& str){
    if(this->str.length() != str.length()) {
        return true;
    }else{
        return false;
    }
}
 
 
bool  Var::operator != (const char* ch){
 
    string result(ch);
    if(this->str.length()!=result.length()) {
        return true;
    }else{
        return false;
    }
 
}
 
bool Var::operator != (const Var& cl){
 
    Var temp;
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(this->num != cl.num){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.dnum != DBL_MIN){
            if(this->dnum != cl.dnum){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }else{
        if(this->str.length() != cl.str.length()){
            return true;
        }else{
            return false;
        }
    }
 
}
//end-------------------------------оператоp (!=)----------------------------end//
 
 
//start-------------------------------оператоp (+=)----------------------------start//
Var & Var::operator += (const int& i){
 
    if(this->num != INT_MIN){
        this->num+=i;
    }else if(this->dnum != DBL_MIN){
        this->dnum+=i;
    }else{
        this->str += to_string(i);
 
 
    }
    return *this;
}
 
Var & Var::operator += (const double& i){
    if(this->num != INT_MIN){
        this->dnum = (double)this->num+i;
        this->num = INT_MIN;
    }else if(this->dnum != DBL_MIN){
        this->dnum+=i;
    }else{
        this->str += to_string(i);
 
    }
    return *this;
}
 
Var  & Var::operator += (const string& str){
    this->str+=str;
    return *this;
}
 
 
Var  & Var::operator +=(const char* ch){
    string result(ch);
    this->str+=result;
    return *this;
}
 
Var & Var::operator += (const Var& cl){
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            this->num+=cl.num;
        }else if( cl.dnum != DBL_MIN){
            this->dnum = (double)this->num+cl.dnum;
            this->num = INT_MIN;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
            this->dnum+=cl.num;
        }else if( cl.dnum != DBL_MIN){
            this->dnum+=cl.dnum;
        }
    }else{
        if(cl.num != INT_MIN){
            this->str += to_string(cl.num);
 
            this->dnum+=cl.num;
        }else if( cl.dnum != DBL_MIN){
            this->str += to_string(cl.dnum);
 
        }else{
            this->str+=cl.str;
        }
 
    }
    return *this;
}
//end-------------------------------оператоp (+=)----------------------------end//
 
//start-------------------------------оператоp (-=)----------------------------start//
Var & Var::operator -= (const int& i){
    
    if(this->num != INT_MIN){
        this->num-=i;
    }else if(this->dnum != DBL_MIN){
        this->dnum-=i;
    }
    return *this;
}
 
Var  & Var::operator -= (const double& i){
    
    if(this->num != INT_MIN){
        this->dnum = (double)this->num-i;
        this->num = INT_MIN;
    }else if(this->dnum != DBL_MIN){
        this->dnum-=i;
    }
    return *this;
}
Var & Var::operator -= (const Var& cl){
 
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            this->num-=cl.num;
        }else if( cl.dnum != DBL_MIN){
            this->dnum = (double)this->num-cl.dnum;
            this->num = INT_MIN;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
            this->dnum-=cl.num;
        }else if( cl.dnum != DBL_MIN){
            this->dnum-=cl.dnum;
        }
    }
    return *this;
}
//end-------------------------------оператоp (-=)----------------------------end//
 
//start-------------------------------оператоp (*=) ----------------------------start//
Var & Var::operator *= (const int& i){
 
    if(this->num != INT_MIN){
        this->num*=i;
    }else if(this->dnum != DBL_MIN){
        this->dnum*=i;
    }
    return *this;
}
 
Var & Var::operator *= (const double& i){
 
    if(this->num != INT_MIN){
        this->dnum = (double)this->num*i;
        this->num =INT_MIN;
    }else if(this->dnum != DBL_MIN){
        this->dnum*=i;
    }
    return *this;
}
Var & Var::operator *= (const Var& cl){
 
 
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            this->num*=cl.num;
        }else if( cl.dnum != DBL_MIN){
            this->dnum = (double)this->num*cl.dnum;
            this->num =INT_MIN;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
            this->dnum*=cl.num;
        }else if( cl.dnum != DBL_MIN){
            this->dnum*=cl.dnum;
        }
    }
    return *this;
}
//end-------------------------------оператоp (*=) ----------------------------end//
 
 
//=start-------------------------------оператоp (/=) ----------------------------start/=/=
Var & Var::operator /= (const int& i){
    
    if(this->num != INT_MIN){
        if(!(this->num%i)){
             this->num/=i;
        }else{
             this->dnum = (double)this->num/i;
             this->num = INT_MIN;
        }
    }else if(this->dnum != DBL_MIN){
         this->dnum/=i;
    }
    return *this;
}
 
Var  & Var::operator /= (const double& i){
    
    if(this->num != INT_MIN){
         this->dnum = (double)this->num/i;
         this->num = INT_MIN;
    }else if(this->dnum != DBL_MIN){
         this->dnum/=i;
    }
    return *this;
}
Var & Var::operator /= (const Var& cl){
 
 
    
    if(this->num != INT_MIN){
        if(cl.num != INT_MIN){
            if(!(this->num%cl.num)){
                 this->num/=cl.num;
            }else{
                  this->dnum = (double)this->num/cl.num;
                  this->num = INT_MIN;
            }
        }else if( cl.dnum != DBL_MIN){
             this->dnum =  (double)this->num/cl.dnum;
             this->num = INT_MIN;
        }
    }else if(this->dnum != DBL_MIN) {
        if(cl.num != INT_MIN){
             this->dnum/=cl.num;
        }else if( cl.dnum != DBL_MIN){
             this->dnum/=cl.dnum;
        }
    }
    return *this;
}
//=end-------------------------------оператоp (/=) ----------------------------end/=/=
//----------------------------------------------------
 
void Var::show(){
    if(this->num !=INT_MIN){
        cout<<this->num;
    }else if(this->dnum !=DBL_MIN){
        cout<<this->dnum;
    }else{
        cout<<this->str;
    }
    cout<<"\n\n\n";
}
 
void Var::_array(){
    if(this->vector == 0){
this->vector = 1;
    }else{
this->vector = 0;
    }
}
 
int &Var::add_new_element_to_array(const int&i ){
 
    Var * Link = new Var;
    Link->num = INT_MIN;
    Link->dnum = DBL_MIN;
    Link->str = "";
    Link->Link = this->Link;
    this->Link = Link;
    this->count_vector++;
    return Link->num;
}
 
 
//start------------------------------------operator []-----------------------------------start//
 
int & Var::operator [] (const int &i){
    return add_new_element_to_array( i );
}
 
//end------------------------------------operator []----------------------------------end//

Var  & Var::operator /= (const double& i){
    
    if(this->num != INT_MIN){
         this->dnum = (double)this->num/i;
         this->num = INT_MIN;
    }else if(this->dnum != DBL_MIN){
         this->dnum/=i;
    }
    return *this;
}