หลีกเลี่ยงการเรียก Constructor ของตัวแปรสมาชิก

สิ่งที่คุณถามเป็นสิ่งต้องห้าม - และถูกต้องเช่นกัน เพื่อให้แน่ใจว่าสมาชิกทุกคนได้รับการเตรียมใช้งานอย่างถูกต้อง อย่าพยายามแก้ไข แต่พยายามจัดโครงสร้างชั้นเรียนของคุณที่พวกเขาจะใช้งานได้

ความคิด:

• C มีตัวสร้างที่ไม่ทำอะไรเลย
• C มีวิธีการเริ่มต้นที่ทำให้คลาสใช้งานได้
• C ติดตามว่าได้รับการเริ่มต้นอย่างถูกต้องหรือไม่ และส่งคืนข้อผิดพลาดที่เหมาะสมหากใช้โดยไม่เริ่มต้น

แล้วการใช้เทคนิคที่อธิบายไว้ใน QA นี้ล่ะ?

ป้องกันการเรียกไปยังคอนสตรัคเตอร์เริ่มต้นสำหรับอาร์เรย์ภายในคลาส

std::aligned_storage<sizeof(T[n]), alignof(T)>::type

หรือคุณสามารถลองใช้ union ก็ได้ AFAIK ยูเนี่ยนจะเริ่มต้นได้เฉพาะกับคอนสตรัคเตอร์ของสมาชิกที่มีชื่อคนแรกเท่านั้น< /ก>

union
{
   uint8_t _nothing = 0; 
   C c;
};

คุณไม่สามารถ.

ตัวแปรสมาชิกทั้งหมดจะถูกสร้างแบบเต็มเมื่อมีการป้อนบล็อคโค้ด construcotr ซึ่งหมายความว่าจะต้องมีการเรียกตัวสร้าง

แต่คุณสามารถแก้ไขข้อจำกัดนี้ได้

// Header-File
class A
{
    struct Initer
    {
         Initer(B& b)
             : m_b(b)
         {
             m_b.doSomething();
             m_b.doMore();
         }
         operator int()  // assuming getSomeValue() returns int.
         {
             return m_b.getSomeValue();
         }
         B& m_b;
    };
    public:
    A();

    private:   // order important.
    B m_B;
    C m_C;
};


// cpp-File
A::A()
: m_B(1)
, m_C(Initer(m_B))
{
}

ฉันไม่เห็นวิธีที่ดีในการบรรลุสิ่งที่คุณต้องการ นี่จะต้องเป็นวิธีแก้ปัญหา:

// Header-File
class A
{
    public:
    A();

    private:
    B m_B;
    C m_C;
    static int prepareC(B& b);
};

// cpp-File
A::A()
: m_B(1)
, m_C(prepareC(m_B))
{
}

int A::prepareC(B& b)
{
    b.doSomething();
    b.doMore();
    return b.getSomeValue();
}

โปรดตรวจสอบให้แน่ใจว่า m_B.doSomething(), m_B.doMore() และ m_B.getSomeValue() ไม่ได้สัมผัส m_C (ทางตรงหรือทางอ้อม)

ตามที่ @Tobias กล่าวถึงอย่างถูกต้อง โซลูชันนี้ขึ้นอยู่กับลำดับของการเริ่มต้น คุณต้องแน่ใจว่าคำจำกัดความของ m_B และ m_C อยู่ในลำดับนี้

อัปเดตโค้ดตามแนวคิดของ @ Loki

ตัวชี้ดูเหมือนเป็นวิธีแก้ปัญหาเดียวสำหรับฉัน วิธีแก้ปัญหาอื่นที่ฉันเห็นคือการมีคอนสตรัคเตอร์เริ่มต้นสำหรับ C ที่ไม่ทำอะไรเลยและมีวิธีการเริ่มต้นใน C ที่คุณเรียกตัวเองในภายหลัง

m_C.เริ่มต้น( m_B.getSomeValue() );

ง่ายที่สุดคือการจัดเก็บพอยน์เตอร์ไปที่ B และ C สิ่งเหล่านี้สามารถเริ่มต้นเป็น 0 โดยไม่ต้องสร้างใดๆ ระวังอย่ายกเลิกการอ้างอิงตัวชี้ว่างและลบออกในตัวทำลายล้างของ A (หรือใช้ std::unique_ptr/boost::scoped_ptr)

แต่ทำไมไม่เริ่มต้น m_B ก่อน (ผ่านการเรียกคอนสตรัคเตอร์ที่เหมาะสม ไม่ใช่ใน A::A() แล้วใช้อินสแตนซ์ B ที่เตรียมใช้งานแล้วนั้นเพื่อเริ่มต้น m_C มันจะเรียกร้องให้มีการเขียนใหม่เล็กน้อย แต่ฉันพนันได้เลยว่ามันจะคุ้มค่ากับการล้างโค้ด

หากคุณไม่ต้องการจัดสรรแบบไดนามิกโดยใช้ new เพื่อเหตุผลด้านความปลอดภัยเกี่ยวกับความยุ่งเหยิง/ข้อยกเว้นของโค้ด คุณสามารถใช้ std::unique_ptr หรือ std::auto_ptr เพื่อแก้ไขปัญหานี้ได้

วิธีแก้ปัญหาที่หลีกเลี่ยง new คือการแก้ไข C เพื่อให้มีกระบวนการเริ่มต้นสองขั้นตอน ตัวสร้างจะสร้างวัตถุ "ซอมบี้" และคุณจะต้องเรียกใช้เมธอด Initialize บนอินสแตนซ์ m_C นั้นเพื่อเริ่มต้นให้เสร็จสิ้น สิ่งนี้คล้ายกับกรณีที่มีอยู่ที่คุณพบซึ่งคุณสามารถส่ง NULL ไปยังตัวสร้างได้ และย้อนกลับเพื่อเริ่มต้นวัตถุในภายหลัง

แก้ไข:

ฉันคิดถึงสิ่งนี้ก่อนหน้านี้ (แม้ว่าจะดูเหมือนวิธีแก้ปัญหาของคนอื่นมากก็ตาม) แต่ฉันต้องได้รับการยืนยันว่าสิ่งนี้จะไม่พังก่อนที่จะเพิ่มโซลูชันนี้ - C++ อาจค่อนข้างยุ่งยากและฉันไม่ได้ใช้มันบ่อยนัก :)

สิ่งนี้สะอาดกว่าคำแนะนำอื่นๆ ของฉัน และไม่ต้องการให้คุณยุ่งกับการใช้งานใดๆ ยกเว้นของ A

เพียงใช้วิธีคงที่เป็นคนกลางในการเริ่มต้นของคุณ:

class A
{
public:
    A();

private:
    static int InitFromB(B& b)
    {
        b.doSomething();
        b.doMore();
        return b.getSomeValue();
    }

    // m_B must be initialized before m_C
    B m_B;
    C m_C;
};

A::A()
    : m_B(1)
    , m_C(InitFromB(m_B))
{
}

โปรดทราบว่านี่หมายความว่าคุณไม่สามารถอนุญาตให้ m_B ขึ้นอยู่กับอินสแตนซ์ของ A หรือ C ได้เลย ในขณะที่วิธีแก้ปัญหาที่ด้านบนของคำตอบนี้อาจอนุญาตให้คุณส่ง A หรือ m_C ไปยังวิธีการของ m_B

เพียงใช้นิพจน์ลูกน้ำ:

A::A()
  : m_B(1)
  , m_c(m_B.doSomething(), m_B.doMore(), m_B.getSomeValue())
{
}

ตามที่คนอื่นอธิบายไว้อย่างชัดเจน m_B ควรประกาศก่อนที่ m_C else m_B.doSomething() จะเรียกใช้พฤติกรรมที่ไม่ได้กำหนดไว้

ที่นี่เรามีแบบเอกสารสำเร็จรูป:

#include <iostream>

class C
{
public:
  C(int i){std::cout << "C::C(" << i << ")" << std::endl;}
};

class B
{
public:
  B(int i){std::cout << "B::B(" << i << ")" << std::endl;}
  void doSomething(){std::cout << "B::doSomething()" << std::endl;}
  void doMore(){std::cout << "B::doMore()" << std::endl;}
  int getSomeValue(){return 42;}
};

หากคุณต้องการสร้างสิ่งก่อสร้างรูปแบบใหม่สำหรับ B ให้พิจารณาสร้างคลาสที่ได้รับ:

class B1 : public B
{
public:
  B1() : B(1)
  {
    doSomething();
    doMore();
  }
};

ตอนนี้ใช้คลาส B1 ที่ได้มาจาก B:

class A
{
private:
  B1 _b;
  C _c;
public:
  A() : _c(_b.getSomeValue()){std::cout << "A::A()" << std::endl;}
};

แล้ว:

int main()
{
  A a;
}

เอาท์พุท:

B::B(1)
B::doSomething()
B::doMore()
C::C(42)
A::A()