intn.cpp

#include <iostream>

class intn{
    int data;
    int base;
    public:
        intn(int d = 0, int b = 0);
        intn(const intn &);

        void set_data(int d){data = d; check();};
        void set_base(int b){base = b; check();};

        int get_data(void) const {return data;};
        int get_base(void) const {return base;};

        intn & check(void);

        intn & inc(int k = 1);
        intn & dec(int k = 1);

        intn & operator=(const intn & right);

        friend const intn & operator+(const intn & i); // унарныц плюс
    friend const intn operator-(const intn & i); // унарный минус
    friend const intn& operator++(intn & i); // префиксный инкремент
    friend const intn operator++(intn & i, int); // постфиксный инкремент
    friend const intn& operator--(intn & i); // префиксный декремент
    friend const intn operator--(intn & i, int); // постфиксный декремент

        friend const intn operator+(const intn & left, const intn & right); // бинарный плюс
        friend const intn operator-(const intn & left, const intn & right); // бинарный минус
        friend const intn operator*(const intn & left, const intn & right); // бинарное умножить
        friend const intn operator/(const intn & left, const intn & right); // бинарное взятие целой части при делении
        friend const intn operator%(const intn & left, const intn & right); // бинарное взятие остатка при делении

    friend intn & operator+=(intn & left, const intn & right); // присваивание с инкрементацией
        friend intn & operator-=(intn & left, const intn & right); // присваивание с декрементацией
        friend intn & operator*=(intn & left, const intn & right); // присваивание с умножением
        friend intn & operator/=(intn & left, const intn & right); // присваивание с взятием целой части при делении
        friend intn & operator%=(intn & left, const intn & right); // присваивание с взятием остатка от деления

    friend bool operator==(const intn & left, const intn & right);  // равно
        friend bool operator!=(const intn & left, const intn & right);  // не равно
        friend bool operator<=(const intn & left, const intn & right);  // меньше либо равно
        friend bool operator>=(const intn & left, const intn & right);  // больше либо равно
        friend bool operator< (const intn & left, const intn & right);  // меньше
        friend bool operator> (const intn & left, const intn & right);  // больше
};

using namespace std;

int main(){
    const int n = 5;
    intn a(2, n), b(3, n);
    cout << (++a).get_data() << endl;
    cout << b.get_data() << endl;

    cout << (a+b).get_data() << endl;
}

intn & intn::operator=(const intn & right){
    if (this != &right) {
        data = right.data;
        base = right.base;
    }

    return *this;
}

const intn operator+(const intn & left, const intn & right){ // бинарный плюс
    return intn(left.data+right.data, left.base);
}

const intn operator-(const intn & left, const intn & right){ // бинарный минус
    return intn(left.data-right.data, left.base);
}

const intn operator*(const intn & left, const intn & right){ // бинарное умножить
    return intn(left.data*right.data, left.base);
}

const intn operator/(const intn & left, const intn & right){ // бинарное взятие целой части при делении
    return intn(left.data / right.data, left.base);
}

const intn operator%(const intn & left, const intn & right){ // бинарное взятие остатка при делении
    return intn(left.data % right.data, left.base);
}

intn & operator+=(intn & left, const intn & right){ // присваивание с инкрементацией
    return left.inc(right.data);
}

intn & operator-=(intn & left, const intn & right){// присваивание с декрементацией
    return left.dec(right.data);
}

intn & operator*=(intn & left, const intn & right){ // присваивание с умножением
    left.data *= right.data;
    return left.check();
}

intn & operator/=(intn & left, const intn & right){ // присваивание с взятием целой части при делении
    left.data /= right.data;
    return left.check();
}

intn & operator%=(intn & left, const intn & right){ // присваивание с взятием остатка от деления
    left.data %= right.data;
    return left.check();
}

bool operator==(const intn & left, const intn & right){  // равно
    return (left.data == right.data);
}

bool operator!=(const intn & left, const intn & right){ // не равно
    return (left.data != right.data);
}

bool operator<=(const intn & left, const intn & right){ // меньше либо равно
    return (left.data <= right.data);
}

bool operator>=(const intn & left, const intn & right){ // больше либо равно
    return (left.data >= right.data);
}

bool operator< (const intn & left, const intn & right){ // меньше
    return (left.data < right.data);
}

bool operator> (const intn & left, const intn & right){// больше
    return (left.data > right.data);
}

//унарный плюс ничего не делает.
const intn & operator+(const intn & i) {
    return i;
}

const intn operator-(const intn & i) {
    return intn(-i.data, i.base);
}

//префиксная версия возвращает значение после инкремента
const intn & operator++(intn & i) {
    return i.inc();
}

//постфиксная версия возвращает значение до инкремента
const intn operator++(intn & i, int) {
    intn oldValue(i.data, i.base);
    i.inc();
    return oldValue;
}

//префиксная версия возвращает значение после декремента
const intn & operator--(intn & i) {
    return i.dec();
}

//постфиксная версия возвращает значение до декремента
const intn operator--(intn & i, int) {
    intn oldValue(i.data, i.base);
    i.dec();
    return oldValue;
}

intn::intn(const intn & i){
    data = i.data;
    base = i.base;
}

intn::intn(int d, int b){
    data = d;
    base = b;
    check();
}

intn & intn::inc(int k){
    data += k;
    return check();
}

intn & intn::dec(int k){
    data -= k;
    return check();
}

intn& intn::check(void){
    if (!base) return *this;

    if (data >= base)
        data %= base;
    else if (data < 0)
        data = base - (-data) % base;

    return *this;
}