เริ่มต้นสมาชิกคลาสคงที่หลายคนโดยใช้การเรียกฟังก์ชันหนึ่ง C ++

หากฉันมีตัวแปรสมาชิกคงที่แตกต่างกันสองตัวซึ่งทั้งสองต้องเริ่มต้นใหม่โดยใช้การเรียกฟังก์ชันเดียวกันมีวิธีการทำเช่นนี้โดยไม่ต้องเรียกใช้ฟังก์ชันสองครั้งหรือไม่

ตัวอย่างเช่นคลาสเศษส่วนที่ตัวเศษและตัวหารเป็นค่าคงที่

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

ส่งผลให้เสียเวลาเนื่องจากฟังก์ชั่น GCD ถูกเรียกสองครั้ง คุณสามารถกำหนดสมาชิกคลาสใหม่gcd_a_bและก่อนกำหนดเอาต์พุตของ gcd ให้กับรายการนั้นในรายการ initializer แต่สิ่งนี้จะนำไปสู่การสูญเสียความจำ

โดยทั่วไปแล้วมีวิธีการทำเช่นนี้โดยไม่ต้องใช้ฟังก์ชั่นการโทรหรือหน่วยความจำที่สูญเปล่า คุณสามารถสร้างตัวแปรชั่วคราวในรายการ initializer ได้หรือไม่? ขอบคุณ.

โดยทั่วไปแล้วมีวิธีการทำเช่นนี้โดยไม่ต้องใช้ฟังก์ชั่นการโทรหรือหน่วยความจำที่สูญเปล่า

ใช่. สิ่งนี้สามารถทำได้ด้วยตัวสร้างการมอบหมายที่แนะนำใน C ++ 11

ตัวสร้างการมอบหมายเป็นวิธีที่มีประสิทธิภาพมากในการรับค่าชั่วคราวที่จำเป็นสำหรับการก่อสร้างก่อนที่ตัวแปรสมาชิกใดจะเริ่มต้น

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

สมาชิก vars จะเริ่มต้นตามลำดับที่ประกาศไว้ในคลาส decleration ดังนั้นคุณสามารถทำสิ่งต่อไปนี้ได้ (ทางคณิตศาสตร์)

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

ไม่จำเป็นต้องเรียกสิ่งก่อสร้างอื่นหรือทำให้พวกเขา

@Drew Dormann ให้ทางออกคล้ายกับสิ่งที่ฉันมีในใจ เนื่องจาก OP ไม่เคยกล่าวถึงไม่สามารถแก้ไข ctor ได้จึงสามารถเรียกใช้ด้วยFraction f {a, b, gcd(a, b)}:

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

ด้วยวิธีนี้จะไม่มีการเรียกฟังก์ชันที่สองตัวสร้างหรืออื่น ๆ ดังนั้นจึงไม่เสียเวลา และมันก็ไม่ได้สูญเปล่าไปเพราะหน่วยความจำชั่วคราวจะต้องสร้างต่อไปดังนั้นคุณอาจจะใช้มันให้เป็นประโยชน์ นอกจากนี้ยังหลีกเลี่ยงการแบ่งพิเศษ