PV913ClassesTalkAssorted

#include <iostream>


class Test
{
    int num{100};
    char symbol{'A'};
public:
    /*Test() : Test(-100500, 'Z') {};
    Test(int pNum, char pSymb) : num{ -pNum }, symbol{ pSymb } {};*/
    char getSymbol()const { return symbol; }
    int getNum()const { return num; };
};

class pbRecord
{
    char* name;
    uint32_t nameSize;
public:
    pbRecord() : name{ nullptr } {};
    /*pbRecord() : name{ new char[50]{} } {};*/
    pbRecord(const char* namePar)
        : name{ new char[strlen(namePar)+1] }
    {
            strcpy_s(name, strlen(namePar) + 1, namePar);
    }
    void setName(const char* namePar)
    {
        delete[] name;


        name = new char[strlen(namePar) + 1];
        strcpy_s(name, strlen(namePar) + 1, namePar);
    };

    void clearName() { delete[] name; name = nullptr; };

    ~pbRecord() { delete[] name; };
};




class Fraction
{
    int numerator;
    int denominator;
    int gcd(int a, int b);
    void reduce();
public:
    Fraction(const Fraction& fract)
        : numerator{ fract.numerator }, denominator{ fract.denominator }
    {
        reduce();
        std::cout << "Fraction COPY constructed for " << this << '\n';
    };
    Fraction(int num, int denom)
        : numerator{ num }, denominator{ denom ? denom : 1 }
    {
        reduce();
        std::cout << "Fraction constructed for " << this << '\n';
    };
    Fraction() : Fraction(1, 1) {};
    ~Fraction() { std::cout << "Fraction destructed for " << this << '\n'; };
    void setNumerator(int num) { numerator = num; reduce(); };
    int getNumerator() const { return numerator; };
    void setDenominator(int denom) { denominator = denom ? denom : 1; reduce(); };
    int getDenominator() const { return denominator; };
    void print() const;
    Fraction& mul(const Fraction fract) { numerator *= fract.numerator; denominator *= fract.denominator; return *this; };
    Fraction& mul(int num) { numerator *= num; return *this; };
    Fraction& div(const Fraction fract) { numerator *= fract.denominator; denominator *= fract.numerator; return *this; };
    Fraction& div(int num) { denominator *= num; return *this; };
    //Fraction operator*(const Fraction& rhs) const;
    friend Fraction operator*(const Fraction& lhs, const Fraction& rhs); // a * b
    friend Fraction operator*(const Fraction& lhs, int rhs); // a * x
    friend Fraction operator*(int lhs, const Fraction& rhs); // y * b
    friend Fraction operator/(const Fraction& lhs, const Fraction& rhs);
    friend Fraction operator+(const Fraction& lhs, const Fraction& rhs);
    friend Fraction operator-(const Fraction& lhs, const Fraction& rhs);
    friend std::ostream& operator<<(std::ostream& out, const Fraction& rhs);
    //friend std::istream& operator>>(std::istream& in, Fraction& rhs);
};

//Fraction Fraction::operator*(const Fraction& rhs) const
//{
//   return Fraction{ numerator * rhs.numerator,  denominator * rhs.denominator };
//}

Fraction operator*(const Fraction& lhs, const Fraction& rhs)
{
    return Fraction{ lhs.numerator * rhs.numerator,  lhs.denominator * rhs.denominator };
}

Fraction operator*(const Fraction& lhs, int rhs)
{
    return Fraction{ lhs.numerator * rhs,  lhs.denominator };
}

Fraction operator*(int lhs, const Fraction& rhs)
{
    return rhs * lhs;
}

Fraction operator/(const Fraction& lhs, const Fraction& rhs)
{
    return Fraction{ lhs.numerator * rhs.denominator, lhs.denominator * rhs.numerator };
}

Fraction operator+(const Fraction& lhs, const Fraction& rhs)
{
    return Fraction{ lhs.numerator * rhs.denominator + rhs.numerator * lhs.denominator, rhs.denominator * lhs.denominator };
}

Fraction operator-(const Fraction& lhs, const Fraction& rhs)
{
    return Fraction{ lhs.numerator * rhs.denominator - rhs.numerator * lhs.denominator, rhs.denominator * lhs.denominator };
}

//Fraction operator*(const Fraction& lhs, const Fraction& rhs)
//{
//    return Fraction{ lhs.getNumerator() * rhs.getNumerator(),  lhs.getDenominator() * rhs.getDenominator() };
//}

//std::ostream& operator<<(std::ostream& out, const Fraction& rhs)
//{
//    out << '(' << rhs.numerator << " / " << rhs.denominator << ')';
//    return out;
//}

std::ostream& operator<<(std::ostream& out, const Fraction& rhs)
{
    if (rhs.numerator == rhs.denominator)
    {
        out << 1;
        return out;
    }

    if (rhs.denominator == 1)
    {
        out << rhs.numerator;
        return out;
    }

    out << '(' << rhs.numerator << " / " << rhs.denominator << ')';
    return out;
}
//
//std::istream& operator>>(std::istream& in, Fraction& rhs)
//{
//    in >> rhs.numerator;
//    in >> rhs.denominator;
//    rhs.denominator = (rhs.denominator ? rhs.denominator : 1);
//    rhs.reduce();
//    return in;
//}

int Fraction::gcd(int a, int b)
{
    while (b)
    {
        a %= b;
        std::swap(a, b);
    }
    return a;
}

void Fraction::reduce()
{
    int gcdVal{ gcd(numerator, denominator) };
    numerator /= gcdVal;
    denominator /= gcdVal;

    if (denominator < 0 and numerator < 0)
    {
        denominator *= -1;
        numerator *= -1;
    }
}
void Fraction::print() const
{
    std::cout << '(' << numerator << " / " << denominator << ")";
};

inline int max(int a, int b) { return a > b ? a : b; };

int main()
{
    struct stringM
    {
        char* string;
        int size;
    };

    stringM text[100];


    char** text{ new char* [100]{} };
    int* textSize{ new int[100]{} };
    text[0] = new char[100]{ "Hello, c++!" };
    textSize[0] = 100;

    std::cout << text[0] << '\n';
    text[1] = new char[100]{ "Hello, c++! Again! Additional string!" };
    std::cout << text[1] << '\n';
    //text[0][0] = '\0';
    delete[] text[0];
    text[0] = nullptr;
    text[0] = new char[100]{ "Hello, c#!! :) :)" };
    std::cout << text[0] << '\n';


    return 0;


    //int a,sum;
    //std::cin >> a;
    //for (int i = a; i < 100; i++)
    //{
    //    sum += i; // sum = sum + i;
    //}
    //std::cout << sum << '\n';

    Test tst;
    std::cout << tst.getNum();
    std::cout << tst.getSymbol();

    return 0;


    int e{ 10 };
    int r{ 20 };
    //int z = max(e, r);
    int z = e > r ? e : r;



    const Fraction a{ 2,16 };
    const Fraction b{ 2,4 };
    Fraction k{ 5,8 };
    int x{ 42 };
    Fraction c{ 4,8 };


    //c = operator*(a,b);
    //c = a.operator*(b);
    /*c = a * b;
    c = a * x;*/

    std::cout << "x = " << x << '\n';


    c = a * b * k;


    std::cout << '\n';

    //c.print();

    std::cout << "Fraction a = " << a << '\n';
    std::cout << "Fraction b = " << b << '\n' << "Fraction k = " << k << '\n';
    std::cout << "Fraction c = " << c << '\n';

    std::cout << '\n';

    std::cout << "Fraction a = ";
    a.print();
    std::cout << '\n' << "Fraction b = ";
    b.print();
    std::cout << '\n' << "Fraction k = ";
    k.print();
    std::cout << '\n' << "Fraction c = ";
    c.print();
    std::cout << '\n';

    std::cout << '\n';
}