#ifndef DATATYPES_H
#define DATATYPES_H

#include <QString>

    class NDataTypes
    {
    public:
        NDataTypes() {this->_id = -1; this->_name = "";}
        virtual ~NDataTypes() { }

        qint32 ID() const {return this->_id;}
        void setID(qint32 ID) {this->_id = ID;}
        QString Name() const {return this->_name;}
        void setName(QString Name) {if (Name != NULL) this->_name = Name; else this->_name = "";}

    protected:
        //если идентификатор равен -1, значит это либо временная переменная, либо константное значение
        qint32 _id;
        //константные или временные значения имен не имеют, только переменные.
        QString _name;
    };

    class NSimpleDataTypes : public NDataTypes
    {
    public:
        NSimpleDataTypes() : NDataTypes() {this->_constvalue = false;}

        bool ConstValue() const {return this->_constvalue;}
        void setConstValue(bool ConstValue) {this->_constvalue = ConstValue;}

    protected:
        //это указывает на константное значение
        bool _constvalue;
    };


#endif // DATATYPES_H

include <cmath>
#include "data-types.h"

class NNumeric : public NSimpleDataTypes
{
public:
    NNumeric(double Value = 0) : NSimpleDataTypes() {this->_isreal = true; this->setValue(Value);}

    //две строки ниже позволяют передать стековой переменной значения из указательной
    NNumeric(NNumeric* Numeric) {this->_id = Numeric->ID(); this->_constvalue = Numeric->ConstValue(); this->_name = Numeric->Name(); this->_isreal = Numeric->IsReal(); this->_value = Numeric->Value();}
    void operator= (NNumeric* a) {this->setID(a->ID()); this->setConstValue(a->ConstValue()); this->setName(a->Name()); this->setIsReal(a->IsReal()); this->setValue(a->Value());}
    //строк ниже поозволяет указательной переменной передать значения из стековой
    operator NNumeric*() {NNumeric* a = new NNumeric(); a->setID(this->ID()); a->setConstValue(this->ConstValue()); a->setName(this->Name()); a->setIsReal(this->IsReal()); a->setValue(this->Value()); return a;}

    double round() const {return floor(this->Value() + 0.5);}
    double fractional() const {return this->Value() < 0.0 ? this->Value() - ceil(this->Value()) : this->Value() - floor(this->Value());}
    double integer() const {return this->Value() < 0.0 ? ceil(this->Value()) : floor(this->Value());}

    void setIsReal(bool IsReal) {this->_isreal = IsReal;}
    //Если ложно, то значение принимается и выдается (при печати числа на экране)
    // с отсечение дробной части числа и соблюдением границ типа qint32.
    bool IsReal() const {return this->_isreal;}
    void setValue(double Value) {if (!this->IsReal()) Value = this->CheckingInt32Borders(Value); else Value = this->CheckingFloatBorders(Value); this->_value = Value;}
    double Value() const {return double(this->CheckingFloatBorders(this->_value));}

    operator QString() {return QString::number(this->_value);}
    operator double() {return double(this->CheckingFloatBorders(this->Value()));}
    operator float() {return this->CheckingFloatBorders(this->Value());}
    operator qint32() {return this->CheckingInt32Borders(this->_value);}
    void operator++(int) {if (!this->IsReal()) this->_value = this->CheckingInt32Borders(this->_value+1); else this->_value = this->CheckingFloatBorders(this->_value+1);}
    void operator--(int) {if (!this->IsReal()) this->_value = this->CheckingInt32Borders(this->_value-1); else this->_value = this->CheckingFloatBorders(this->_value-1);}

private:

    long double Int32Max() const {return 2147483647;}
    long double Int32Min() const {return -2147483647;}
    long double FloatMax() const {return 2.147483647e9;}
    long double FloatMin() const {return 2.147483647e-9;}
    float CheckingFloatBorders (double Value) const
    {
        //В этой функции +/-inf приравниваются к max и min границам.
        double d = fabs(Value);
        bool usign = Value >= 0.0;

        if (d >= this->FloatMax())
            return (usign) ? this->FloatMax() : -this->FloatMax();

        if (d <= this->FloatMin() && d > 0.0)
            return (usign) ? this->FloatMin() : -this->FloatMin();

        return float(Value);
    }
    qint32 CheckingInt32Borders(double Value) const
    {
        if (Value >= Int32Max()) return Int32Max();

        if (Value <= Int32Min()) return Int32Min();

        return qint32(Value);
    }


    double _value;
    bool _isreal;
};

NNumeric a, b, c;
NNumeric *a1, *b2;
a = 12;
b = .7;
c = double(a) + double(b);
c = double(a) / double(b);
a1 = c;
b2 = new NNumeric(3.55);
a = b2;

NDataTypes* dt = new NDataTypes();
dt = b2;
b = dynamic_cast<NNumeric*>(dt);