Initialisieren Sie mehrere konstante Klassenmitglieder mit einem Funktionsaufruf C ++

Wenn ich zwei verschiedene konstante Elementvariablen habe, die beide basierend auf demselben Funktionsaufruf initialisiert werden müssen, gibt es eine Möglichkeit, dies zu tun, ohne die Funktion zweimal aufzurufen?

Zum Beispiel eine Bruchklasse, bei der Zähler und Nenner konstant sind.

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

Dies führt zu Zeitverschwendung, da die GCD-Funktion zweimal aufgerufen wird. Sie können auch ein neues Klassenmitglied definieren gcd_a_bund zuerst die Ausgabe von gcd der Ausgabe in der Initialisierungsliste zuweisen. Dies würde jedoch zu einer Verschwendung von Speicher führen.

Gibt es im Allgemeinen eine Möglichkeit, dies ohne verschwendete Funktionsaufrufe oder Speicher zu tun? Können Sie vielleicht temporäre Variablen in einer Initialisierungsliste erstellen? Vielen Dank.

Gibt es im Allgemeinen eine Möglichkeit, dies ohne verschwendete Funktionsaufrufe oder Speicher zu tun?

Ja. Dies kann mit einem delegierenden Konstruktor erfolgen , der in C ++ 11 eingeführt wurde.

Eine Delegation von Konstruktor ist eine sehr effiziente Art und Weise temporäre Werte für den Bau benötigt zu erwerben , bevor alle Membervariablen initialisiert werden.

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

Die Mitgliedsvariablen werden in der Reihenfolge initialisiert, in der sie in der Klassendeklaration deklariert sind. Daher können Sie (mathematisch) Folgendes tun:

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

Sie müssen keine anderen Konstruktoren aufrufen oder erstellen.

@Drew Dormann gab eine ähnliche Lösung wie ich es mir vorgestellt hatte. Da OP niemals erwähnt, dass der ctor nicht geändert werden kann, kann dies aufgerufen werden mit Fraction f {a, b, gcd(a, b)}:

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

Nur auf diese Weise gibt es keinen zweiten Aufruf einer Funktion, eines Konstruktors oder auf andere Weise, sodass keine Zeit verschwendet wird. Und es wird kein Speicher verschwendet, da ohnehin ein temporärer Speicher erstellt werden müsste. Sie können ihn also auch gut nutzen. Es vermeidet auch eine zusätzliche Aufteilung.