Проблема с выводом на экран

[Александр222]

При выводе на экран получается:FN1 + FN1 = 0, 19, 0
FN1 - FN1 = 0, 1, 0

А должно: FN1 + FN1 = 16, 19, 23
FN1 - FN1 = -2, 1, 4

Не могу понять, в чем проблема. Как можно решить. В коде, все, что связано с Fraction верно. Начиная с FrazzyNumber выходит такая проблема

main.cpp

#include <iostream>
#include "Pair.h"
 
 
int main() {
 
    /*Fraction R1 (999, 23);
      Fraction R2 (58, 34);
      Fraction Answer;
 
      R1.Addition(R2, Answer);
      R1.Subtraction(R2, Answer);
      R1.Multiplication(R2, Answer);
      R1.Division(R2, Answer);
 
      std::cout << "R1 + R2 = " << Answer << std::endl;
      std::cout << "R1 - R2 = " << Answer << std::endl;
      std::cout << "R1 * R2 = " << Answer << std::endl;
      std::cout << "R1 / R2 = " << Answer << std::endl;
      std::cout << "R1 > R2 : " << R1.Greater(R2) << std::endl;
      std::cout << "R1 = R2 : " << R1.Equal(R2) << std::endl;
     */
    try {
        
        FazzyNumber FN1(10, 9, 2, 1, 2, 1);
        FazzyNumber FN2;
        FazzyNumber ANSWER;
 
        FN1.Addition(FN2, ANSWER);
        std::cout << "FN1 + FN1 = " << ANSWER << std::endl;
 
        FN1.Subtraction(FN2, ANSWER);
        std::cout << "FN1 - FN1 = " << ANSWER << std::endl;
    }
    catch (const std::runtime_error& e) {
        std::cout << "Mistake:" << std::endl << e.what() << std::endl;
        return 0;
    }
    return 0;
 
}

Pair.h

#include <memory>
#include <iostream>
#include <functional>
 
class Pair {
public:
    int X;
    int Y;
    int x1;
    int y1;
    int x2;
    int y2;
    void SetX(int);
    void SetY(int);
 
    int GetX() const;
    int GetY() const;
 
    Pair();
    Pair(int, int);
    Pair(const Pair& other);
 
    virtual void  Addition(const Pair&, Pair&) = 0;
    virtual void Subtraction(const Pair&, Pair&) = 0;
    virtual void Multiplication(const Pair&, Pair&) = 0;
    virtual void Division(const Pair&, Pair&) = 0;
 
    virtual bool Greater(Pair&) = 0;
    virtual bool Equal(Pair&) = 0;
 
    friend std::ostream& operator<<(std::ostream&, std::unique_ptr<Pair>&);
    friend std::istream& operator>>(std::istream&, Pair&);
};
 
class Fraction : public Pair {
public:
    Fraction();
    Fraction(int X, int Y);
    Fraction(const Fraction& other);
 
    void Addition(const  Pair&, Pair&);
    void Subtraction(const  Pair&, Pair&);
    void Multiplication(const  Pair&, Pair&);
    void Division(const  Pair&, Pair&);
 
    bool Greater(Pair&);
    bool Equal(Pair&);
 
    friend std::ostream& operator << (std::ostream& out, const Fraction& F);
};
 
class FazzyNumber : public Pair {
    int x1 = 0;
    int y1 = 0;
    int x2 = 0;
    int y2 = 0;
public:
 
    FazzyNumber();
    FazzyNumber(int X, int Y, int x1, int y1, int x2, int y2);
    FazzyNumber(const FazzyNumber& other);
 
    void Addition(const  Pair&, Pair&);
    void Subtraction(const  Pair&, Pair&);
    void Multiplication(const  Pair&, Pair&);
    void Division(const  Pair&, Pair&);
 
    bool Greater(Pair&);
    bool Equal(Pair&);
 
    friend std::ostream& operator << (std::ostream& out, const FazzyNumber& FN);
    friend std::istream& operator>>(std::istream& in, FazzyNumber& FN);
};

Pair.cpp

#include "Pair.h"
#include <iostream>
 
#include <cmath>
 
Pair::Pair() : X{ 0 }, Y{ 0 }{};
Pair::Pair(int X, int Y) : X{ X }, Y{ Y } {};
Pair::Pair(const Pair& other) : X{ other.X }, Y{ other.Y } {};
 
void Pair::SetX(int X) { X = X; }
void Pair::SetY(int Y) { Y = Y; }
 
int Pair::GetX() const { return X; }
int Pair::GetY() const { return Y; }
 
std::ostream& operator<<(std::ostream& out, std::unique_ptr<Pair>& p_num) {
    out << "[ " << p_num->GetX() << " : " << p_num->GetY() << " ]";
    return out;
}
 
std::istream& operator>>(std::istream& in, Pair& num) {
    in >> num.X >> num.Y;
    return in;
}
 
Fraction::Fraction() : Pair() {};
Fraction::Fraction(int X, int Y) : Pair(X, Y) {};
Fraction::Fraction(const Fraction& other) : Pair(other) {};
 
void Fraction::Addition(const  Pair& other, Pair& answer) {
    answer.X = (X * other.Y) + (other.X * Y);
    answer.Y = Y * other.Y;
}
 
void Fraction::Subtraction(const Pair& other, Pair& answer) {
    answer.X = (X * other.Y) - (other.X * Y);
    answer.Y = Y * other.Y;
}
 
void Fraction::Multiplication(const Pair& other, Pair& answer) {
    answer.X = X * other.X;
    answer.Y = Y * other.Y;
}
 
void Fraction::Division(const Pair& other, Pair& answer) {
    answer.X = X * other.Y;
    answer.Y = Y * other.X;
}
 
bool Fraction::Greater(Pair& value) {
    int Fraction1;
    int Fraction2;
    Fraction1 = (X / Y);
    Fraction2 = (value.X / value.Y);
    return Fraction1 > Fraction2;
}
 
bool Fraction::Equal(Pair& value) { return (X / Y) == (value.X / value.Y); }
 
std::ostream& operator<<(std::ostream& out, const Fraction& F) {
    out << F.X << ", " << F.Y;
    return out;
}
 
FazzyNumber::FazzyNumber() : Pair() {};
FazzyNumber::FazzyNumber(int X, int Y, int x1, int y1, int x2, int y2) : Pair(X, Y), x1(x1), y1(y1), x2(x2), y2(y2) {};
FazzyNumber::FazzyNumber(const FazzyNumber& other) : Pair(other) {}
 
void FazzyNumber::Addition(const Pair& other, Pair& answer) {
 
    answer.x1 = ((X + other.Y + Y + other.X) - (other.x1 + y1) - (other.y1 + x1));
    answer.X = (X + other.Y) + (Y + other.X);
    answer.y1 = ((X + other.Y + Y + other.X) + (x2 + other.y2) + (y2 + other.x2));
    
 
}
 
void FazzyNumber::Subtraction(const Pair& other, Pair& answer) {
    answer.x1 = ((X + other.Y - Y + other.X - (other.x1 + y1) - (other.y1 + x1)));
    answer.X = X + other.Y - Y + other.X;
    answer.y1 = ((X + other.Y - Y + other.X) + (x2 + other.y2) + (y2 + other.x2));
}
 
void FazzyNumber::Multiplication(const Pair& X, Pair& Y) {
    /*x = X.X * Y.X;
    e1 = X.X * Y.X - Y.X * X.e1 - X.X * Y.e1 + X.e1 * Y.e1;
    e2 = X.X * Y.X + Y.X * X.e2 + X.X * Y.e2 + X.e2 * Y.e2;*/
}
 
void FazzyNumber::Division(const Pair& X, Pair& Y) {
    /* if (Y.X <= 0) throw std::runtime_error("Division by 0");
     x = X.X / Y.X;
 
    // if ((X.X - Y.X < 0.0001) && (Y.X + Y.e2 > -0.0001)) throw std::runtime_error("Division by 0");
     e1 = (X.X - Y.X) / (Y.X + Y.e2);
 
     //if ((X.X + X.e2) < 0.0001 && (Y.X - Y.e1) > -0.0001) throw std::runtime_error("Division by 0");
     e2 = (X.X + X.e2) / (Y.X - Y.e1);  */
}
 
bool FazzyNumber::Greater(Pair& value) {
    int FazzyNumber1;
    int FazzyNumber2;
    FazzyNumber1 = (X / Y);
    FazzyNumber2 = (value.X / value.Y);
    return FazzyNumber1 > FazzyNumber2;
}
 
bool FazzyNumber::Equal(Pair& value) { return (X / Y) == (value.X / value.Y); };
 
std::ostream& operator<<(std::ostream& out, const FazzyNumber& FN) {
    out << FN.x1 << ", " << FN.X << ", " << FN.y1;
    return out;
}
 
std::istream& operator>>(std::istream& in, FazzyNumber& FN)
{
    in >> FN.X >> FN.Y;
    return in;
}

[BDA]

Ответ почти совпал. Поменял следующее.
В main:

FazzyNumber FN1(2, 10, 2);
FazzyNumber FN2(1, 9, 1);

В pair.cpp:

FazzyNumber::FazzyNumber() : Pair() {};
FazzyNumber::FazzyNumber(int e1, int A, int e2) : Pair(e1, e2), A(A) {};
FazzyNumber::FazzyNumber(const FazzyNumber& other) : Pair(other) {}

void FazzyNumber::Addition(const Pair& other, Pair& answer)
{
    const FazzyNumber& other2 = dynamic_cast<const FazzyNumber&>(other);
    FazzyNumber& answer2 = dynamic_cast<FazzyNumber&>(answer);
    answer2.A = A + other2.A;
    answer.X = X + other.X;
    answer.Y = Y + other.Y;
}

void FazzyNumber::Subtraction(const Pair& other, Pair& answer)
{
    const FazzyNumber& other2 = dynamic_cast<const FazzyNumber&>(other);
    FazzyNumber& answer2 = dynamic_cast<FazzyNumber&>(answer);
    answer2.A = A - other2.A;
    answer.X = X + other.X;
    answer.Y = Y + other.Y;
}
...
std::ostream& operator<<(std::ostream& out, const FazzyNumber& FN) {
    out << (FN.A - FN.X) << ", " << FN.A << ", " << (FN.A + FN.Y);
    return out;
}

std::istream& operator>>(std::istream& in, FazzyNumber& FN)
{
    int tmp;
    in >> tmp >> FN.A;
    FN.X = FN.A - tmp;
    in >> tmp;
    FN.Y = FN.A - tmp;
    return in;
}

В pair.h:

class Pair {
public:
    int X;
    int Y;
    void SetX(int);
    void SetY(int);
...
class FazzyNumber : public Pair {
    int A;
public:

    FazzyNumber();
    FazzyNumber(int e1, int A, int e2);

[Александр222]

BDA, Как раз у Вас получается правильный ответ) 16, 19, 22. Спасибо!

[Александр222]

BDA, Пока дописывал код, возник небольшой вопрос.
Когда мы пишем конструктор FazzyNumber::FazzyNumber(int e1, int A, int e2) : Pair(e1, e2), A(A) {};
Мы указываем Pair(e1, e2), а не Pair(X, Y), как в Fraction. То есть такая запись все-таки возможна?. Просто я думал, что мы везде указываем Pair(X, Y).

[BDA]

Я так понимаю, что главное, это совпадение количества и типов аргументов с каким-либо конструктором Pair, а не имена.

[Александр222]

BDA, Спасибо!

[Desc]

Вы прямо так-и телепаты..
Я вот вот из первого поста не понял поставленной задачи..

[BDA]

Просто в предыдущих темах ТСа есть необходимая информация.