Làm thế nào để có thể trả lại một đối tượng, trong C ++?

Tôi biết tiêu đề nghe có vẻ quen thuộc vì có nhiều câu hỏi tương tự, nhưng tôi đang hỏi về một khía cạnh khác của vấn đề (tôi biết sự khác biệt giữa việc có mọi thứ trên chồng và đặt chúng vào đống).

Trong Java tôi luôn có thể trả về các tham chiếu đến các đối tượng "cục bộ"

public Thing calculateThing() {
    Thing thing = new Thing();
    // do calculations and modify thing
    return thing;
}

Trong C ++, để làm một cái gì đó tương tự tôi có 2 tùy chọn

(1) Tôi có thể sử dụng tài liệu tham khảo bất cứ khi nào tôi cần "trả lại" một đối tượng

void calculateThing(Thing& thing) {
    // do calculations and modify thing
}

Sau đó sử dụng nó như thế này

Thing thing;
calculateThing(thing);

(2) Hoặc tôi có thể trả về một con trỏ tới một đối tượng được phân bổ động

Thing* calculateThing() {
    Thing* thing(new Thing());
    // do calculations and modify thing
    return thing;
}

Sau đó sử dụng nó như thế này

Thing* thing = calculateThing();
delete thing;

Sử dụng cách tiếp cận đầu tiên tôi sẽ không phải giải phóng bộ nhớ theo cách thủ công, nhưng với tôi nó làm cho mã khó đọc. Vấn đề với cách tiếp cận thứ hai là, tôi sẽ phải nhớ delete thing;, trông không đẹp lắm. Tôi không muốn trả về một giá trị được sao chép vì nó không hiệu quả (tôi nghĩ vậy), vì vậy đây là câu hỏi

• Có giải pháp thứ ba (không yêu cầu sao chép giá trị) không?
• Có bất kỳ vấn đề nếu tôi dính vào giải pháp đầu tiên?
• Khi nào và tại sao tôi nên sử dụng giải pháp thứ hai?

Tôi không muốn trả về giá trị sao chép vì nó không hiệu quả

Chứng minh điều đó.

Tra cứu RVO và NRVO, và trong ngữ nghĩa di chuyển C ++ 0x. Trong hầu hết các trường hợp trong C ++ 03, tham số out chỉ là một cách tốt để làm cho mã của bạn trở nên xấu xí, và trong C ++ 0x, bạn thực sự đang tự làm tổn thương mình bằng cách sử dụng tham số out.

Chỉ cần viết mã sạch, trả về theo giá trị. Nếu hiệu suất là một vấn đề, hãy lập hồ sơ (ngừng đoán) và tìm những gì bạn có thể làm để khắc phục nó. Nó có khả năng sẽ không trả lại mọi thứ từ các chức năng.

Điều đó nói rằng, nếu bạn đã chết khi viết như vậy, có lẽ bạn muốn thực hiện tham số out. Nó tránh phân bổ bộ nhớ động, an toàn hơn và thường nhanh hơn. Nó đòi hỏi bạn phải có một số cách để xây dựng đối tượng trước khi gọi hàm, điều này không phải lúc nào cũng có ý nghĩa đối với tất cả các đối tượng.

Nếu bạn muốn sử dụng phân bổ động, ít nhất có thể được thực hiện là đặt nó trong một con trỏ thông minh. (Dù sao thì việc này cũng nên được thực hiện mọi lúc)

Chỉ cần tạo đối tượng và trả lại nó

Thing calculateThing() {
    Thing thing;
    // do calculations and modify thing
     return thing;
}

Tôi nghĩ bạn sẽ tự giúp mình nếu bạn quên tối ưu hóa và chỉ viết mã có thể đọc được (bạn sẽ cần chạy trình hồ sơ sau - nhưng không tối ưu hóa trước).

Chỉ cần trả về một đối tượng như thế này:

Thing calculateThing() 
{
   Thing thing();
   // do calculations and modify thing
   return thing;
}

Điều này sẽ gọi hàm tạo sao chép trên Things, vì vậy bạn có thể muốn thực hiện việc đó. Như thế này:

Thing(const Thing& aThing) {}

Điều này có thể thực hiện chậm hơn một chút, nhưng nó có thể không phải là một vấn đề.

Cập nhật

Trình biên dịch có thể sẽ tối ưu hóa cuộc gọi đến hàm tạo sao chép, do đó sẽ không có thêm chi phí. (Giống như dreamlax đã chỉ ra trong bình luận).

Bạn đã thử sử dụng con trỏ thông minh (nếu Thing thực sự là đối tượng lớn và nặng), như auto_ptr:

std::auto_ptr<Thing> calculateThing()
{
  std::auto_ptr<Thing> thing(new Thing);
  // .. some calculations
  return thing;
}


// ...
{
  std::auto_ptr<Thing> thing = calculateThing();
  // working with thing

  // auto_ptr frees thing 
}

Một cách nhanh chóng để xác định xem hàm tạo sao chép có được gọi hay không là thêm ghi nhật ký vào hàm tạo sao chép của lớp bạn:

MyClass::MyClass(const MyClass &other)
{
    std::cout << "Copy constructor was called" << std::endl;
}

MyClass someFunction()
{
    MyClass dummy;
    return dummy;
}

Gọi someFunction; số lượng dòng "Copy constructor được gọi là" mà bạn sẽ nhận được sẽ khác nhau giữa 0, 1 và 2. Nếu bạn không nhận được, thì trình biên dịch của bạn đã tối ưu hóa giá trị trả về (điều này được phép làm). Nếu bạn không nhận được 0 và trình xây dựng sao chép của bạn rất tốn kém, thì hãy tìm kiếm các cách khác để trả về các thể hiện từ các hàm của bạn.

Đầu tiên bạn có một lỗi trong mã, bạn có nghĩa là có Thing *thing(new Thing());và chỉ return thing;.

• Sử dụng shared_ptr<Thing>. Deref nó như tho nó là một con trỏ. Nó sẽ bị xóa cho bạn khi tham chiếu cuối cùng đến Thingtrong phạm vi.
• Giải pháp đầu tiên rất phổ biến trong các thư viện ngây thơ. Nó có một số hiệu suất và chi phí cú pháp, tránh nó nếu có thể
• Chỉ sử dụng giải pháp thứ hai nếu bạn có thể đảm bảo sẽ không có ngoại lệ nào bị ném hoặc khi hiệu suất hoàn toàn quan trọng (bạn sẽ can thiệp vào C hoặc lắp ráp trước khi điều này thậm chí có liên quan).

Tôi chắc rằng một chuyên gia về C ++ sẽ đi kèm với một câu trả lời tốt hơn, nhưng cá nhân tôi thích cách tiếp cận thứ hai. Sử dụng con trỏ thông minh giúp giải quyết vấn đề quêndelete và như bạn nói, có vẻ sạch sẽ hơn là phải tạo một đối tượng trước khi sử dụng (và vẫn phải xóa nó nếu bạn muốn phân bổ nó trên heap).