C_CPP/04_UDEF/MP/main_04_UDEF_e.cpp

#include <iostream>
#include <algorithm>

const int bitsPerOctet = 8;

struct BinaryOctet {
    bool evenParity;
    char bitsAsDigits[bitsPerOctet]{};

    BinaryOctet(int x = 0);
    BinaryOctet(const BinaryOctet&) = default;
    const BinaryOctet operator--(int);
    const BinaryOctet operator++(int);
    bool operator!=(BinaryOctet &a);
    bool operator>=(BinaryOctet &a);
    BinaryOctet operator-(BinaryOctet a);
    BinaryOctet operator+(BinaryOctet a);
    BinaryOctet operator/(BinaryOctet &a);
};

BinaryOctet::BinaryOctet(int x) {
    for (char &bitsAsDigit : bitsAsDigits) {
        bitsAsDigit = '0';
    }

    int remainder;
    int temp = 0;
    while (x != 0) {
        remainder = x % 2;
        x /= 2;
        bitsAsDigits[temp] = static_cast<char>(remainder + '0');
        temp++;
    }

    std::reverse(std::begin(bitsAsDigits), std::end(bitsAsDigits));

    int ones = 0;
    for (char c : bitsAsDigits) {
        if (c == '1') ones++;
    }

    evenParity = ones % 2 == 0;
}

const BinaryOctet BinaryOctet::operator--(int) {
    return operator-(*new BinaryOctet(1));
}

const BinaryOctet BinaryOctet::operator++(int) {
    return operator+(*new BinaryOctet(1));
}

BinaryOctet BinaryOctet::operator+(BinaryOctet a) {
    BinaryOctet result;
    bool over = false;
    for (int i = bitsPerOctet - 1; i >= 0; --i) {
        //Arbeitsvariablen anlegen und char in int umwandeln für einfachere Rechnung
        int tmp;
        int aI = a.bitsAsDigits[i] - '0';
        int bI = bitsAsDigits[i] - '0';


        if(over) tmp = aI + bI + 1;
        else tmp = aI + bI;
        over = false;


        if(tmp >= 2) {
            over = true;
            if (tmp % 2 == 0) tmp = 0;
            else tmp = 1;
        }

        //Umwandlung in char und ins Ergebnis schreiben
        result.bitsAsDigits[i] = static_cast<char>(tmp + '0');
    }
    return result;
}

BinaryOctet BinaryOctet::operator-(BinaryOctet a) {
    BinaryOctet result;
    bool over = false;
    for(int i = bitsPerOctet - 1; i >= 0; --i) {
        int tmp;
        int aI = a.bitsAsDigits[i] - '0';
        int bI = bitsAsDigits[i] - '0';

        if(over) tmp = bI - aI - 1;
        else tmp = bI - aI;
        over = false;

        if(tmp < 0) {
            over = true;
            tmp = tmp + 1;
        }
        result.bitsAsDigits[i] = static_cast<char>(tmp + '0');
    }
    return result;
}

BinaryOctet BinaryOctet::operator/(BinaryOctet &a) {
    BinaryOctet result = *new BinaryOctet(0);

    while(*this >= a) {
        *this = *this - a;
        result = result + 1;
        std::cout << result.bitsAsDigits << std::endl;
    }
    return result;
}

bool BinaryOctet::operator!=(BinaryOctet &a) {
    if (a.evenParity !=evenParity) return false;
    for (int i = 0; i < bitsPerOctet; ++i) {
        if (a.bitsAsDigits[i] != bitsAsDigits[i]) return false;
    }
    return true;
}


//TODO: this
bool BinaryOctet::operator>=(BinaryOctet &a) {
    if(!operator!=(a)) return true;

    int aI = 0;
    for(int i = bitsPerOctet - 1; i >= 0; --i) {
        aI =+ (a.bitsAsDigits[i] - '0') * 2 ^ i;
    }

    int bI = 0;
    for(int i = bitsPerOctet - 1; i >= 0; --i) {
        bI += (bitsAsDigits[i] - '0') * 2 ^ i;
    }
    return bI >= aI;
}

BinaryOctet doCalculation(BinaryOctet a, BinaryOctet b) {
    BinaryOctet result;
    for (; a != b; b--) {
        a = a + 1;
        a = a / b;
    }
    result = a + b;
    return result;
}


// for println();
std::string as_string(BinaryOctet a) {
    std::string result = "(";
    for (char c : a.bitsAsDigits) {
        result += c;
    }
    result += ")";
    return result;
}


std::string as_string(BinaryOctet *a) {
    std::string result = "(";
    for (char c : a->bitsAsDigits) {
        result += c;
    }
    result += ")";
    return result;
}

// for std::cout
std::ostream &operator<<(std::ostream &os, const BinaryOctet &toBePrinted) {
    os << as_string(toBePrinted);
    return os;
}


std::ostream &operator<<(std::ostream &os, BinaryOctet *toBePrinted) {
    os << as_string(toBePrinted);
    return os;
}


int main(int argc, char **argv) {

    std::cout << "=========   init   ==========" << std::endl;
    BinaryOctet a = 0b00001111; //15
    std::cout << "a = " << a << std::endl;
    BinaryOctet b = 0b00000110;//6
    std::cout << "b = " << b << std::endl;
    auto *c = new BinaryOctet(5);
    std::cout << "c = " << c << std::endl;

    std::cout << "========   operator+   ===========" <<std::endl;
    std::cout << "a + b = " << a + b << std::endl;

    std::cout << "=========   operator-   ==========" << std::endl;
    std::cout << "a - b = " << a - b << std::endl;

    std::cout << "=========   operator/   ==========" << std::endl;
    std::cout << "a / b = " << a / b << std::endl;


    std::cout << "========   operator--   ============" << std::endl;
    BinaryOctet d = 0b111111111;
    d--;
    std::cout << "11111111-- = " << d-- << std::endl;

    std::cout << "==============   doCalculation   ================" << std::endl;
    std::cout << "result = " << doCalculation(a, b) << std::endl;
    return 0;
}