Inicializar múltiples miembros de clase constante utilizando una función llamada C ++

Si tengo dos variables de miembros constantes diferentes, que deben inicializarse en función de la misma llamada a la función, ¿hay alguna manera de hacerlo sin llamar a la función dos veces?

Por ejemplo, una clase de fracción donde el numerador y el denominador son 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;
};

Esto da como resultado una pérdida de tiempo, ya que la función GCD se llama dos veces. También podría definir un nuevo miembro de clase gcd_a_b, y primero asignar la salida de gcd a eso en la lista de inicializadores, pero luego esto conduciría a un desperdicio de memoria.

En general, ¿hay alguna manera de hacer esto sin llamadas de función o memoria desperdiciadas? ¿Quizás puede crear variables temporales en una lista de inicializador? Gracias.

En general, ¿hay alguna manera de hacer esto sin llamadas de función o memoria desperdiciadas?

Si. Esto se puede hacer con un constructor delegante , introducido en C ++ 11.

Un constructor delegar es una forma muy eficiente de adquirir valores temporales necesarios para la construcción antes de cualquier se inicializan las variables miembro.

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

Las variables miembro se inicializan por el orden en que se declaran en la declinación de la clase, por lo tanto, puede hacer lo siguiente (matemáticamente)

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

No es necesario llamar a otros constructores o incluso hacerlos.

@Drew Dormann dio una solución similar a lo que tenía en mente. Como OP nunca menciona que no se puede modificar el ctor, esto se puede llamar con Fraction f {a, b, gcd(a, b)}:

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

Solo de esta manera no hay una segunda llamada a una función, constructor o de otra manera, por lo que no se pierde tiempo. Y no es un desperdicio de memoria ya que de todos modos tendría que crearse un temporal, por lo que también puede aprovecharlo. También evita una división extra.