การเรียก constructors ใน c ++ โดยไม่มีสิ่งใหม่

ฉันมักจะเห็นว่าผู้คนสร้างวัตถุใน C ++ โดยใช้

Thing myThing("asdf");

แทนสิ่งนี้:

Thing myThing = Thing("asdf");

ดูเหมือนว่าจะใช้งานได้ (โดยใช้ gcc) อย่างน้อยตราบใดที่ไม่มีเทมเพลตที่เกี่ยวข้อง คำถามของฉันตอนนี้บรรทัดแรกนั้นถูกต้องหรือไม่และถ้าเป็นเช่นนั้นฉันควรใช้หรือไม่

ความจริงแล้วทั้งสองบรรทัดนั้นถูกต้อง แต่ทำสิ่งต่าง ๆ อย่างละเอียด

บรรทัดแรกสร้างวัตถุใหม่ใน stack Thing(const char*)โดยการเรียกตัวสร้างรูปแบบที่

อันที่สองค่อนข้างซับซ้อนกว่าเล็กน้อย มันทำสิ่งต่อไปนี้เป็นหลัก

1. สร้างวัตถุประเภทThingโดยใช้ตัวสร้างThing(const char*)
2. สร้างวัตถุประเภทThingโดยใช้ตัวสร้างThing(const Thing&)
3. โทรหา~Thing()วัตถุที่สร้างขึ้นในขั้นตอนที่ # 1

ฉันสมมติกับบรรทัดที่สองที่คุณหมายถึงจริง:

Thing *thing = new Thing("uiae");

ซึ่งจะเป็นวิธีมาตรฐานในการสร้างวัตถุแบบไดนามิกใหม่(จำเป็นสำหรับการเชื่อมโยงแบบไดนามิกและความหลากหลาย) และการจัดเก็บที่อยู่ของพวกเขาไปยังตัวชี้ รหัสของคุณทำในสิ่งที่ JaredPar อธิบายไว้นั่นคือการสร้างวัตถุสองรายการ (อันหนึ่งผ่านไปconst char*อีกอันผ่านไปอีกหนึ่งรายการconst Thing&) จากนั้นเรียก destructor ( ~Thing()) บนวัตถุแรก ( const char*หนึ่งรายการ)

ในทางตรงกันข้ามสิ่งนี้:

Thing thing("uiae");

สร้างวัตถุคงที่ซึ่งถูกทำลายโดยอัตโนมัติเมื่อออกจากขอบเขตปัจจุบัน

คอมไพเลอร์อาจปรับรูปแบบที่สองให้เหมาะสมในรูปแบบแรก แต่ไม่จำเป็นต้องทำ

#include <iostream>

class A
{
    public:
        A() { std::cerr << "Empty constructor" << std::endl; }
        A(const A&) { std::cerr << "Copy constructor" << std::endl; }
        A(const char* str) { std::cerr << "char constructor: " << str << std::endl; }
        ~A() { std::cerr << "destructor" << std::endl; }
};

void direct()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a(__FUNCTION__);
    static_cast<void>(a); // avoid warnings about unused variables
}

void assignment()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a = A(__FUNCTION__);
    static_cast<void>(a); // avoid warnings about unused variables
}

void prove_copy_constructor_is_called()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a(__FUNCTION__);
    A b = a;
    static_cast<void>(b); // avoid warnings about unused variables
}

int main()
{
    direct();
    assignment();
    prove_copy_constructor_is_called();
    return 0;
}

เอาต์พุตจาก gcc 4.4:

TEST: direct
char constructor: direct
destructor

TEST: assignment
char constructor: assignment
destructor

TEST: prove_copy_constructor_is_called
char constructor: prove_copy_constructor_is_called
Copy constructor
destructor
destructor

ค่อนข้างง่ายทั้งสองบรรทัดสร้างวัตถุบนสแต็กแทนที่จะเป็นฮีปเหมือนกับ 'ใหม่' บรรทัดที่สองเกี่ยวข้องกับการเรียกตัวสร้างสำเนาที่สองดังนั้นจึงควรหลีกเลี่ยง (มันต้องได้รับการแก้ไขตามที่ระบุในความคิดเห็น) คุณควรใช้สแต็กสำหรับวัตถุขนาดเล็กให้มากที่สุดเท่าที่จะทำได้เนื่องจากมันจะเร็วกว่า แต่ถ้าวัตถุของคุณจะอยู่รอดได้นานกว่าสแต็กเฟรมก็เป็นทางเลือกที่ผิดอย่างชัดเจน

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

ฉันเล่นกับมันเล็กน้อยและไวยากรณ์ดูเหมือนจะค่อนข้างแปลกเมื่อตัวสร้างไม่มีอาร์กิวเมนต์ ขอยกตัวอย่าง:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

Thing::Thing()
{
    cout << "Hi" << endl;
}

int main()
{
    //Thing myThing(); // Does not work
    Thing myThing; // Works

}

ดังนั้นเพียงแค่เขียน Thing myThing โดยไม่มีเครื่องหมายวงเล็บเรียกจริงนวกรรมิกขณะที่ Thing myThing () ทำให้คอมไพเลอร์สิ่งที่คุณต้องการสร้างตัวชี้ฟังก์ชั่นหรือบางสิ่งบางอย่าง ?? !!

ต่อท้ายคำตอบJaredPar

ctor 1 ปกติ, 2- ฟังก์ชั่นเหมือน ctor กับวัตถุชั่วคราว

รวบรวมแหล่งนี้ที่ใดที่หนึ่งที่นี่http://melpon.org/wandbox/ด้วยคอมไพเลอร์ที่แตกต่างกัน

// turn off rvo for clang, gcc with '-fno-elide-constructors'

#include <stdio.h>
class Thing {
public:
    Thing(const char*){puts(__FUNCTION__ );}
    Thing(const Thing&){puts(__FUNCTION__ );}   
    ~Thing(){puts(__FUNCTION__);}
};
int main(int /*argc*/, const char** /*argv*/) {
    Thing myThing = Thing("asdf");
}

และคุณจะเห็นผล

จาก ISO / IEC 14882 2003-10-15

8.5 ตอนที่ 12

การก่อสร้างที่ 1 และ 2 ของคุณเรียกว่าการเริ่มต้นโดยตรง

12.1 ตอนที่ 13

การแปลงประเภทสัญกรณ์ทำงาน (5.2.3) สามารถใช้เพื่อสร้างออบเจ็กต์ใหม่ของประเภทนั้น [หมายเหตุ: ไวยากรณ์ดูเหมือนว่าจะมีการเรียกตัวสร้างอย่างชัดเจน ] ... วัตถุที่สร้างในลักษณะนี้ไม่มีชื่อ [หมายเหตุ: 12.2 อธิบายอายุการใช้งานของวัตถุชั่วคราว ] [หมายเหตุ: การเรียกตัวสร้างอย่างชัดเจนไม่ได้ให้ค่า lvalues ​​ดู 3.10 ]

จะอ่านเกี่ยวกับ RVO ได้ที่ไหน:

12 ฟังก์ชั่นสมาชิกพิเศษ / 12.8 การคัดลอกคลาสอ็อบเจ็กต์ / ส่วนที่ 15

เมื่อเกณฑ์ที่แน่นอนจะได้พบกับการดำเนินการที่ได้รับอนุญาตที่จะละเว้นการก่อสร้างสำเนาของวัตถุชั้นแม้กระทั่งถ้านวกรรมิกสำเนาและ / หรือ destructor สำหรับวัตถุมีผลข้างเคียง

ปิดโดยใช้ธงคอมไพเลอร์จากความคิดเห็นเพื่อดูพฤติกรรมการทำสำเนา)