Initialiser plusieurs membres de classe constants à l'aide d'un seul appel de fonction C ++

Si j'ai deux variables de membres constants différentes, qui doivent toutes deux être initialisées en fonction du même appel de fonction, existe-t-il un moyen de le faire sans appeler la fonction deux fois?

Par exemple, une classe de fraction où le numérateur et le dénominateur sont constants.

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

Cela se traduit par une perte de temps, car la fonction GCD est appelée deux fois. Vous pouvez également définir un nouveau membre de classe gcd_a_b, et affecter d'abord la sortie de gcd à celle de la liste d'initialisation, mais cela entraînerait un gaspillage de mémoire.

En général, existe-t-il un moyen de le faire sans appels de fonctions ou mémoire gaspillés? Pouvez-vous peut-être créer des variables temporaires dans une liste d'initialisation? Je vous remercie.

En général, existe-t-il un moyen de le faire sans appels de fonctions ni mémoire gaspillés?

Oui. Cela peut être fait avec un constructeur délégué , introduit en C ++ 11.

Un constructeur délégué est un moyen très efficace d'acquérir les valeurs temporaires nécessaires à la construction avant l' initialisation des variables membres.

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

Les vars membres sont initialisés par l'ordre dans lequel ils sont déclarés dans la classe decleration, vous pouvez donc effectuer les opérations suivantes (mathématiquement)

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

Pas besoin d'appeler un autre constructeur ou même de le faire.

@Drew Dormann a donné une solution similaire à ce que j'avais en tête. Puisque OP ne mentionne jamais de ne pas pouvoir modifier le ctor, cela peut être appelé avec Fraction f {a, b, gcd(a, b)}:

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

Seulement de cette façon, il n'y a pas de second appel à une fonction, constructeur ou autre, donc ce n'est pas une perte de temps. Et ce n'est pas une mémoire perdue, car un temporaire devrait être créé de toute façon, vous pouvez donc aussi en faire bon usage. Cela évite également une division supplémentaire.