C++结构函数，返回一个新的结构，动态分配并接受一个结构

Question

我想写一个函数，返回一个新的动态分配 结构指针，我遇到了返回指针的问题。 我已经得到这个工作，如果我只是返回一个结构。但我无法弄清楚如何传回分数。任何帮助都会很棒。

struct fraction 
{ 
    int n; 
    int d; 
    int gcd = 0; 
}; 

class Worker 
{ 
private: 
    fraction * fract = new fraction; 

public: 

    Worker(); 
    // prototypes 
    fraction* gcd(fraction *); 
}; 

fraction Worker:: *gcd(fraction *f) 
{ 


    int n= f->n; 
    int d = f->d; 
    int r = 0; 
    do 
    { 
     r = n % d; 
     n = d; 
     d = r; 
    } while (d > 0); 
    fract->d = f->d; 
    fract->n = f->n; 
    fract->gcd = n; 

    return fract; 

} 

Answer 1

struct Fraction { 
    int numerator; 
    int denominator; 

    Fraction() {} 
    Fraction(int numerator, int denominator) : 
     num(numerator), 
     den(denominator) 
    {} 
}; // Fraction 

class FractionWithGCD { 
private: 
    Fraction m_fraction; 
    int  m_gcd; 

public: 
    FractionWithGCD(); // Default 
    FractionWithGCD(int numerator, int denominator); 
    FractionWithGCD(Fraction& fraction); 

    int getGCD() const { return m_gcd; } 
    Fraction getFraction() const { return m_fraction; } 

    void calculateGCD(int numerator, int denominator); 
    void calculateGCD(Fraction& fraction); 

private: 
    void calculate(int numerator, int denominator); 

}; // FractionWithGCD 

// ------------------------------------------------------------------------- 
// FractionWithGCD() - Default Constructor 
// User needs to use either calculateGCD function they will both create member 
// variable fraction and calculate the GCD of that fraction storing the values. 
FractionWithGCD::FractionWithGCD() : 
m_gcd(0) { 
} // FractionWithGCD 

// ------------------------------------------------------------------------- 
// FractionWithGCD() - Takes Two Integers - Will construct a fraction 
// variable and calculate the GCD upon construction  
FractionWithGCD::FractionWithGCD(int numerator, int denominator) : 
m_gcd(0) { 
    calculate(numerator, denominator); 
} // FractionWithGCD 

// ------------------------------------------------------------------------- 
// FractionWithGCD() - Takes a Fraction struct, saves it and calculates the GCD. 
FractionWithGCD::FractionWithGCD(Fraction& fraction) : 
m_gcd(0) { 
    calculate(fraction.numerator, fraction.denominator); 
} // FractionWithGCD 

// ------------------------------------------------------------------------- 
// calculateGCD() - Calls private member calculate() - If this function is called 
// again, the current fraction and GCD will be overwritten. 
void FractionWithGCD::calculateGCD(int, numerator, int denominator) { 
    calculate(numerator, denominator); 
} // calculateGCD 

// ------------------------------------------------------------------------- 
// calculateGCD() - Calls private member calculate() - If this function is called 
// again, the current fraction and GCD will be overwritten. 
void FractionWithGCD::calculateGCD(Fraction& fraction) { 
    calculate(fraction.numerator, calculate.denominator); 
} // calculateGCD 

// ------------------------------------------------------------------------- 
// calculate() - Private Method - Responsible For Checking If Fraction Is 
// Valid That The Denominator Is Not 0, Saved The Fraction To Member Variable 
// And Does All The Work To Calculate The GSD And Saves It Into Member Variable 
void FractionWithGCD::calculate(int numerator, int denominator) { 
    // Check Denominator For 0 To Prevent Possible Division By 0 
    if (denominator == 0) { 
     std::cout << "Error: Division By 0." << std::endl; 
     return; 
    } 
    // Save Our Fraction 
    m_fraction.numerator = numerator; 
    m_fraction.denominator = denominator; 

    // Temp Stack Variables To Work With 
    int remainder = 0; 

    do { 
     remainder = numerator % denominator; 
     numerator = denominator; 
     denominator = remainder; 
    } while (denominator > 0); 

    m_gcd = numerator; 

} // Calculate