Zainicjuj wiele stałych elementów klasy za pomocą jednego wywołania funkcji C ++

Jeśli mam dwie różne stałe zmienne składowe, które należy zainicjować na podstawie tego samego wywołania funkcji, czy istnieje sposób, aby to zrobić bez dwukrotnego wywołania funkcji?

Na przykład klasa ułamkowa, w której licznik i mianownik są stałe.

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

Powoduje to stratę czasu, ponieważ funkcja GCD jest wywoływana dwukrotnie. Możesz także zdefiniować nowego członka klasy gcd_a_bi najpierw przypisać wyjście gcd do tego na liście inicjalizatora, ale wtedy doprowadziłoby to do marnowania pamięci.

Czy istnieje sposób, aby to zrobić bez marnowania wywołań funkcji lub pamięci? Czy możesz stworzyć tymczasowe zmienne na liście inicjalizatora? Dziękuję Ci.

Czy istnieje sposób, aby to zrobić bez marnowania wywołań funkcji lub pamięci?

Tak. Można to zrobić za pomocą konstruktora delegującego , wprowadzonego w C ++ 11.

Konstruktor delegujący to bardzo skuteczny sposób na uzyskanie wartości tymczasowych potrzebnych do konstrukcji przed zainicjowaniem jakichkolwiek zmiennych składowych.

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

Zmienne składowe są inicjowane według kolejności, w której zostały zadeklarowane podczas deklowania klas, dlatego można wykonać następujące czynności (matematyczne)

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

Nie ma potrzeby wywoływania innych konstruktorów ani nawet ich tworzenia.

@Drew Dormann podał rozwiązanie podobne do tego, co miałem na myśli. Ponieważ OP nigdy nie wspomina o niemożności modyfikacji ctor, można to wywołać za pomocą Fraction f {a, b, gcd(a, b)}:

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

Tylko w ten sposób nie ma drugiego wywołania funkcji, konstruktora lub w inny sposób, więc nie jest to stracony czas. I nie jest to zmarnowana pamięć, ponieważ tymczasowe i tak musiałoby zostać utworzone, więc równie dobrze możesz z niej skorzystać. Pozwala to również uniknąć dodatkowego podziału.