Gọi constructor trong c ++ mà không cần mới

Tôi thường thấy rằng mọi người tạo các đối tượng trong C ++ bằng cách sử dụng

Thing myThing("asdf");

Thay vì điều này:

Thing myThing = Thing("asdf");

Điều này dường như hoạt động (sử dụng gcc), ít nhất là miễn là không có mẫu liên quan. Câu hỏi của tôi bây giờ, dòng đầu tiên có đúng không và nếu có thì tôi có nên sử dụng nó không?

Cả hai dòng trên thực tế đều đúng nhưng làm những điều khác biệt tinh tế.

Dòng đầu tiên tạo một đối tượng mới trên ngăn xếp bằng cách gọi hàm tạo của định dạng Thing(const char*).

Cái thứ hai phức tạp hơn một chút. Nó cơ bản làm như sau

1. Tạo một đối tượng kiểu Thingbằng cách sử dụng hàm tạoThing(const char*)
2. Tạo một đối tượng kiểu Thingbằng cách sử dụng hàm tạoThing(const Thing&)
3. Gọi ~Thing()đối tượng được tạo ở bước # 1

Tôi giả sử với dòng thứ hai bạn thực sự có nghĩa là:

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

đó sẽ là cách tiêu chuẩn để tạo các đối tượng động mới (cần thiết cho liên kết động và đa hình) và lưu địa chỉ của chúng vào một con trỏ. Mã của bạn thực hiện những gì JaredPar đã mô tả, cụ thể là tạo hai đối tượng (một đối tượng đã vượt qua a const char*, đối tượng khác đã vượt qua a const Thing&) và sau đó gọi hàm hủy ( ~Thing()) trên đối tượng đầu tiên (đối tượng const char*).

Ngược lại, điều này:

Thing thing("uiae");

tạo một đối tượng tĩnh được hủy tự động khi thoát khỏi phạm vi hiện tại.

Trình biên dịch có thể tối ưu hóa hình thức thứ hai thành hình thức đầu tiên, nhưng nó không phải.

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

Đầu ra từ 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

Rất đơn giản, cả hai dòng đều tạo đối tượng trên ngăn xếp, thay vì trên heap như 'mới'. Dòng thứ hai thực sự liên quan đến một cuộc gọi thứ hai đến một nhà xây dựng sao chép, vì vậy nó nên được tránh (nó cũng cần được sửa chữa như được nêu trong các ý kiến). Bạn nên sử dụng ngăn xếp cho các đối tượng nhỏ càng nhiều càng tốt vì nó nhanh hơn, tuy nhiên nếu các đối tượng của bạn sẽ tồn tại lâu hơn khung ngăn xếp, thì rõ ràng đó là lựa chọn sai.

Lý tưởng nhất, một trình biên dịch sẽ tối ưu hóa thứ hai, nhưng nó không bắt buộc. Đầu tiên là cách tốt nhất. Tuy nhiên, điều khá quan trọng để hiểu sự khác biệt giữa stack và heap trong C ++, vì bạn phải quản lý bộ nhớ heap của riêng mình.

Tôi đã chơi một chút với nó và cú pháp có vẻ khá lạ khi một hàm tạo không có đối số. Để tôi lấy một ví dụ:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

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

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

}

Vì vậy, chỉ cần viết Thing myThing w / o ngoặc thực sự gọi hàm tạo, trong khi Thing myThing () làm cho trình biên dịch bạn muốn tạo một con trỏ hàm hoặc một cái gì đó ?? !!

Nối vào câu trả lời của JaredPar

1 ctor thông thường, 2-function-like-ctor với đối tượng tạm thời.

Biên dịch nguồn này ở đâu đó tại đây http://melpon.org/wandbox/ với các trình biên dịch khác nhau

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

Và bạn sẽ thấy kết quả.

Từ ISO / IEC 14882 2003-10-15

8,5, phần 12

Công trình thứ 1, 2 của bạn được gọi là khởi tạo trực tiếp

12.1, phần 13

Một chuyển đổi loại ký hiệu chức năng (5.2.3) có thể được sử dụng để tạo các đối tượng mới của loại. [Lưu ý: Cú pháp trông giống như một cuộc gọi rõ ràng của nhà xây dựng. ] ... Một đối tượng được tạo theo cách này không được đặt tên. [Lưu ý: 12.2 mô tả thời gian tồn tại của các đối tượng tạm thời. ] [Lưu ý: các lệnh gọi hàm tạo rõ ràng không mang lại giá trị, xem 3.10. ]

Nơi để đọc về RVO:

12 Hàm thành viên đặc biệt / 12.8 Sao chép các đối tượng lớp / Phần 15

Khi các tiêu chí nhất định được đáp ứng, việc triển khai được phép bỏ qua cấu trúc sao chép của một đối tượng lớp, ngay cả khi hàm tạo sao chép và / hoặc hàm hủy cho đối tượng có tác dụng phụ .

Tắt nó với cờ trình biên dịch từ bình luận để xem hành vi sao chép như vậy)