Inizializza più membri di classe costanti utilizzando una chiamata di funzione C ++

Se ho due diverse variabili dei membri costanti, che devono entrambe essere inizializzate in base alla stessa chiamata di funzione, c'è un modo per farlo senza chiamare la funzione due volte?

Ad esempio, una classe di frazione in cui numeratore e denominatore sono costanti.

int gcd(int a, int b); // Greatest Common Divisor
class Fraction {
public:
    // Lets say we want to initialize to a reduced fraction
    Fraction(int a, int b) : numerator(a/gcd(a,b)), denominator(b/gcd(a,b))
    {

    }
private:
    const int numerator, denominator;
};

Ciò comporta una perdita di tempo, poiché la funzione GCD viene chiamata due volte. È inoltre possibile definire un nuovo membro della classe gcd_a_be assegnare prima l'output di gcd a quello nell'elenco di inizializzatori, ma ciò comporterebbe uno spreco di memoria.

In generale, c'è un modo per farlo senza sprecare chiamate di funzione o memoria? Puoi forse creare variabili temporanee in un elenco di inizializzatori? Grazie.

In generale, c'è un modo per farlo senza sprecare chiamate di funzione o memoria?

Sì. Questo può essere fatto con un costruttore delegato , introdotto in C ++ 11.

Un costruttore delegante è un modo molto efficiente per acquisire i valori temporanei necessari per la costruzione prima di inizializzare qualsiasi variabile membro.

int gcd(int a, int b); // Greatest Common Divisor
class Fraction {
public:
    // Call gcd ONCE, and forward the result to another constructor.
    Fraction(int a, int b) : Fraction(a,b,gcd(a,b))
    {
    }
private:
    // This constructor is private, as it is an
    // implementation detail and not part of the public interface.
    Fraction(int a, int b, int g_c_d) : numerator(a/g_c_d), denominator(b/g_c_d)
    {
    }
    const int numerator, denominator;
};

I membri membri vengono inizializzati dall'ordine in cui vengono dichiarati nella declerazione di classe, quindi è possibile effettuare le seguenti operazioni (matematicamente)

#include <iostream>
int gcd(int a, int b){return 2;}; // Greatest Common Divisor of (4, 6) just to test
class Fraction {
public:
    // Lets say we want to initialize to a reduced fraction
    Fraction(int a, int b) : numerator{a/gcd(a,b)}, denominator(b/(a/numerator))
    {

    }
//private:
    const int numerator, denominator;//make sure that they are in this order
};
//Test
int main(){
    Fraction f{4,6};
    std::cout << f.numerator << " / " << f.denominator;
}

Non c'è bisogno di chiamare altri costruttori o addirittura di farli.

@Drew Dormann ha dato una soluzione simile a quello che avevo in mente. Poiché OP non menziona mai la possibilità di modificare il ctor, questo può essere chiamato con Fraction f {a, b, gcd(a, b)}:

Fraction(int a, int b, int tmp): numerator {a/tmp}, denominator {b/tmp}
{
}

Solo in questo modo non c'è una seconda chiamata a una funzione, un costruttore o altro, quindi non è tempo perso. E non è uno spreco di memoria poiché un temporaneo dovrebbe essere creato comunque, quindi potresti anche farne buon uso. Evita anche una divisione extra.