Inicialize vários membros da classe constante usando uma chamada de função C ++

Se eu tiver duas variáveis ​​de membros constantes diferentes, que precisam ser inicializadas com base na mesma chamada de função, existe uma maneira de fazer isso sem chamar a função duas vezes?

Por exemplo, uma classe de fração em que numerador e denominador são constantes.

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;
};

Isso resulta em perda de tempo, pois a função GCD é chamada duas vezes. Você também pode definir um novo membro da classe,gcd_a_b , e primeiro atribuir a saída do gcd à da lista de inicializadores, mas isso levaria à perda de memória.

Em geral, existe uma maneira de fazer isso sem chamadas de função desperdiçadas ou memória? Você pode criar variáveis ​​temporárias em uma lista de inicializadores? Obrigado.

Em geral, existe uma maneira de fazer isso sem chamadas de função desperdiçadas ou memória?

Sim. Isso pode ser feito com um construtor de delegação , introduzido no C ++ 11.

Um construtor de delegação é uma maneira muito eficiente de adquirir valores temporários necessários para a construção antes que qualquer variável membro seja inicializada.

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;
};

Os vars de membros são inicializados pela ordem em que são declarados na decleração de classe, portanto, você pode fazer o seguinte (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;
}

Não há necessidade de chamar outros construtores ou até mesmo fazê-los.

@Drew Dormann deu uma solução semelhante ao que eu tinha em mente. Como o OP nunca menciona não poder modificar o ctor, isso pode ser chamado com Fraction f {a, b, gcd(a, b)}:

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

Só assim, não há segunda chamada para uma função, construtora ou outra, portanto não há perda de tempo. E não é uma perda de memória, já que um temporário teria que ser criado de qualquer maneira, então você também pode fazer bom uso dele. Também evita uma divisão extra.