Đảm bảo thời gian tồn tại tạm thời trong C ++?

C ++ có cung cấp sự đảm bảo cho thời gian tồn tại của một biến tạm thời được tạo trong một lệnh gọi hàm nhưng không được sử dụng làm tham số không? Đây là một lớp mẫu:

class StringBuffer
{
public:
    StringBuffer(std::string & str) : m_str(str)
    {
        m_buffer.push_back(0);
    }
    ~StringBuffer()
    {
        m_str = &m_buffer[0];
    }
    char * Size(int maxlength)
    {
        m_buffer.resize(maxlength + 1, 0);
        return &m_buffer[0];
    }
private:
    std::string & m_str;
    std::vector<char> m_buffer;
};

Và đây là cách bạn sẽ sử dụng nó:

// this is from a crusty old API that can't be changed
void GetString(char * str, int maxlength);

std::string mystring;
GetString(StringBuffer(mystring).Size(MAXLEN), MAXLEN);

Khi nào thì hàm hủy cho đối tượng StringBuffer tạm thời sẽ được gọi? Là nó:

• Trước cuộc gọi đến GetString?
• Sau khi GetString trả về?
• Trình biên dịch phụ thuộc?

Tôi biết rằng C ++ đảm bảo rằng một biến tạm thời cục bộ sẽ hợp lệ miễn là có một tham chiếu đến nó - điều này có áp dụng cho các đối tượng mẹ khi có một tham chiếu đến một biến thành viên không?

Cảm ơn.

Hàm hủy cho loại thời gian tạm thời đó được gọi ở cuối biểu thức đầy đủ. Đó là biểu hiện bên ngoài nhất mà không phải là một phần của bất kỳ biểu thức nào khác. Đó là trong trường hợp của bạn sau khi hàm trả về và giá trị được đánh giá. Vì vậy, nó sẽ hoạt động tốt.

Trên thực tế, đó là điều làm cho các mẫu biểu thức hoạt động: Chúng có thể giữ các tham chiếu đến loại thời gian tạm thời đó trong một biểu thức như

e = a + b * c / d

Bởi vì mọi tạm thời sẽ kéo dài cho đến khi biểu thức

x = y

Được đánh giá hoàn toàn. Nó được mô tả khá ngắn gọn 12.2 Temporary objectstrong Tiêu chuẩn.

câu trả lời của litb là chính xác. Thời gian tồn tại của đối tượng tạm thời (còn được gọi là rvalue) được gắn với biểu thức và trình hủy cho đối tượng tạm thời được gọi ở cuối biểu thức đầy đủ và khi trình hủy trên StringBuffer được gọi, trình hủy trên m_buffer cũng sẽ được được gọi, nhưng không phải hàm hủy trên m_str vì nó là một tham chiếu.

Lưu ý rằng C ++ 0x chỉ thay đổi mọi thứ một chút vì nó thêm các tham chiếu rvalue và di chuyển ngữ nghĩa. Về cơ bản bằng cách sử dụng một tham số tham chiếu rvalue (ký hiệu là &&), tôi có thể 'di chuyển' giá trị vào hàm (thay vì sao chép nó) và thời gian tồn tại của rvalue có thể bị ràng buộc với đối tượng mà nó di chuyển vào chứ không phải biểu thức. Có một bài đăng trên blog thực sự tốt từ nhóm MSVC trình bày rất chi tiết về vấn đề này và tôi khuyến khích mọi người đọc nó.

Ví dụ sư phạm cho việc di chuyển rvalue là các chuỗi tạm thời và tôi sẽ hiển thị phép gán trong một hàm tạo. Nếu tôi có một lớp MyType chứa một biến thành viên chuỗi, nó có thể được khởi tạo với một giá trị rvalue trong hàm tạo như sau:

class MyType{
   const std::string m_name;
public:
   MyType(const std::string&& name):m_name(name){};
}

Điều này rất hay vì khi tôi khai báo một thể hiện của lớp này với một đối tượng tạm thời:

void foo(){
    MyType instance("hello");
}

điều xảy ra là chúng ta tránh sao chép và phá hủy đối tượng tạm thời và "hello" được đặt trực tiếp bên trong biến thành viên của cá thể lớp sở hữu. Nếu đối tượng có trọng lượng nặng hơn một 'chuỗi' thì lệnh sao chép bổ sung và lệnh hủy có thể rất quan trọng.

Sau khi cuộc gọi đến GetString trở lại.

StringBuffer nằm trong phạm vi của GetString. Nó sẽ bị phá hủy ở cuối phạm vi của GetString (tức là khi nó quay trở lại). Ngoài ra, tôi không tin rằng C ++ sẽ đảm bảo rằng một biến sẽ tồn tại miễn là có tham chiếu.

Sau đây nên biên dịch:

Object* obj = new Object;
Object& ref = &(*obj);
delete obj;

Tôi đã viết gần như chính xác cùng một lớp:

template <class C>
class _StringBuffer
{
    typename std::basic_string<C> &m_str;
    typename std::vector<C> m_buffer;

public:
    _StringBuffer(std::basic_string<C> &str, size_t nSize)
        : m_str(str), m_buffer(nSize + 1) { get()[nSize] = (C)0; }

    ~_StringBuffer()
        { commit(); }

    C *get()
        { return &(m_buffer[0]); }

    operator C *()
        { return get(); }

    void commit()
    {
        if (m_buffer.size() != 0)
        {
            size_t l = std::char_traits<C>::length(get());
            m_str.assign(get(), l);    
            m_buffer.resize(0);
        }
    }

    void abort()
        { m_buffer.resize(0); }
};

template <class C>
inline _StringBuffer<C> StringBuffer(typename std::basic_string<C> &str, size_t nSize)
    { return _StringBuffer<C>(str, nSize); }

Trước khi có tiêu chuẩn, mỗi trình biên dịch đã làm theo cách khác nhau. Tôi tin rằng Sách hướng dẫn tham khảo có chú thích cũ cho C ++ đã chỉ định rằng các khoảng thời gian tạm thời sẽ được dọn dẹp ở cuối phạm vi, vì vậy một số trình biên dịch đã làm điều đó. Cuối năm 2003, tôi thấy rằng hành vi vẫn tồn tại theo mặc định trên trình biên dịch Forte C ++ của Sun, vì vậy StringBuffer không hoạt động. Nhưng tôi sẽ rất ngạc nhiên nếu bất kỳ trình biên dịch nào hiện tại vẫn bị hỏng.