Memanggil konstruktor dalam c ++ tanpa yang baru

Saya sering melihat bahwa orang membuat objek menggunakan C ++

Thing myThing("asdf");

Alih-alih ini:

Thing myThing = Thing("asdf");

Ini tampaknya berhasil (menggunakan gcc), setidaknya selama tidak ada template yang terlibat. Pertanyaan saya sekarang, apakah baris pertama benar dan jika demikian saya harus menggunakannya?

Kedua garis itu sebenarnya benar tetapi melakukan hal-hal yang agak berbeda.

Baris pertama membuat objek baru di stack dengan memanggil konstruktor format Thing(const char*).

Yang kedua sedikit lebih rumit. Ini pada dasarnya melakukan hal berikut

1. Buat objek bertipe Thingmenggunakan konstruktorThing(const char*)
2. Buat objek bertipe Thingmenggunakan konstruktorThing(const Thing&)
3. Panggil ~Thing()objek yang dibuat pada langkah # 1

Saya berasumsi dengan baris kedua yang Anda maksud:

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

yang akan menjadi cara standar untuk membuat objek dinamis baru (diperlukan untuk pengikatan dinamis dan polimorfisme) dan menyimpan alamatnya ke sebuah pointer. Kode Anda melakukan apa yang dijelaskan oleh JaredPar, yaitu membuat dua objek (satu melewati a const char*, yang lainnya melewati a const Thing&), dan kemudian memanggil destruktor ( ~Thing()) pada objek pertama ( const char*satu).

Sebaliknya, ini:

Thing thing("uiae");

membuat objek statis yang dihancurkan secara otomatis saat keluar dari cakupan saat ini.

Kompilator mungkin mengoptimalkan bentuk kedua ke dalam bentuk pertama, tetapi tidak harus.

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

Output dari 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

Sederhananya, kedua garis membuat objek pada stack, bukan pada heap seperti halnya 'baru'. Baris kedua sebenarnya melibatkan panggilan kedua ke copy constructor, jadi itu harus dihindari (juga perlu diperbaiki seperti yang ditunjukkan dalam komentar). Anda harus menggunakan tumpukan untuk objek kecil sebanyak mungkin karena lebih cepat, namun jika objek Anda akan bertahan lebih lama dari tumpukan bingkai, maka itu jelas pilihan yang salah.

Idealnya, kompiler akan mengoptimalkan yang kedua, tetapi itu tidak diperlukan. Yang pertama adalah cara terbaik. Namun, sangat penting untuk memahami perbedaan antara tumpukan dan tumpukan di C ++, karena Anda harus mengelola memori tumpukan Anda sendiri.

Saya bermain sedikit dengan itu dan sintaks tampaknya agak aneh ketika konstruktor tidak mengambil argumen. Izinkan saya memberi contoh:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

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

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

}

jadi hanya menulis Thing myThing tanpa tanda kurung sebenarnya memanggil konstruktor, sementara Thing myThing () membuat hal yang kompiler Anda ingin membuat pointer fungsi atau sesuatu ?? !!

Dalam menambahkan jawaban JaredPar

1-ctor biasa, 2nd-function-like-ctor dengan objek sementara.

Kompilasi sumber ini di suatu tempat di sini http://melpon.org/wandbox/ dengan kompiler yang berbeda

// 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");
}

Dan Anda akan melihat hasilnya.

Dari ISO / IEC 14882 2003-10-15

8.5, bagian 12

Konstruksi ke-1, ke-2 Anda disebut inisialisasi langsung

12.1, bagian 13

Konversi tipe notasi fungsional (5.2.3) dapat digunakan untuk membuat objek baru dari tipenya. [Catatan: Sintaksnya terlihat seperti panggilan eksplisit dari konstruktor. ] ... Objek yang dibuat dengan cara ini tidak disebutkan namanya. [Catatan: 12.2 menjelaskan umur benda sementara. ] [Catatan: panggilan konstruktor eksplisit tidak menghasilkan nilai, lihat 3.10. ]

Di mana membaca tentang RVO:

12 Fungsi anggota khusus / 12.8 Menyalin objek kelas / Bagian 15

Ketika kriteria tertentu terpenuhi, implementasi diperbolehkan untuk menghilangkan konstruksi salinan objek kelas, bahkan jika konstruktor dan / atau destruktor untuk objek memiliki efek samping .

Matikan itu dengan flag compiler dari komentar untuk melihat perilaku copy-seperti itu)