C ++ 'da garantili geçici ömür?

C ++, bir işlev çağrısı içinde oluşturulan ancak bir parametre olarak kullanılmayan geçici bir değişkenin yaşam süresi için bir garanti sağlıyor mu? İşte örnek bir sınıf:

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

Ve işte bunu nasıl kullanacağınız:

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

Geçici StringBuffer nesnesinin yıkıcısı ne zaman çağrılacak? Bu mu:

• GetString'i aramadan önce?
• GetString döndükten sonra?
• Derleyiciye bağlı mı?

C ++ 'nın, yerel bir geçici değişkenin kendisine bir başvuru olduğu sürece geçerli olacağını garanti ettiğini biliyorum - bu, bir üye değişkene başvuru olduğunda ana nesneler için geçerli midir?

Teşekkürler.

Bu tür geçiciler için yıkıcı, tam ifadenin sonunda çağrılır. Bu, başka bir ifadenin parçası olmayan en dış ifade. Bu, fonksiyon döndükten ve değer değerlendirildikten sonra sizin durumunuzdur. Yani, her şey yolunda gidecek.

Aslında ifade şablonlarının çalışmasını sağlayan şey budur: Bu tür geçicilere referansları bir ifadede tutabilirler.

e = a + b * c / d

Çünkü her geçici, ifadeye kadar sürer

x = y

Tamamen değerlendirilir. 12.2 Temporary objectsStandart'ta oldukça kısaca açıklanmıştır .

litb'nin cevabı doğrudur. Geçici nesnenin ömrü (rvalue olarak da bilinir) ifadeye bağlıdır ve geçici nesnenin yıkıcısı tam ifadenin sonunda çağrılır ve StringBuffer'daki yıkıcı çağrıldığında m_buffer'daki yıkıcı da çağrıldı, ancak m_str üzerindeki yıkıcı bir başvuru olduğu için değil.

C ++ 0x'in her şeyi biraz değiştirdiğine dikkat edin çünkü rvalue referansları ekler ve semantiği taşır. Esasen bir rvalue referans parametresi kullanarak (&& ile işaretlenmiştir) rvalue'yu işleve 'taşıyabilirim' (kopyalamak yerine) ve rvalue'nun ömrü ifadeye değil, içine geçtiği nesneye bağlanabilir. MSVC ekibinden bu konuyu detaylı bir şekilde anlatan gerçekten iyi bir blog yazısı var ve insanları okumaya teşvik ediyorum.

Rvalue'ları taşımak için pedagojik örnek geçici dizelerdir ve bir yapıcıda atama göstereceğim. Bir dize üye değişkeni içeren bir sınıf MyType'a sahipsem, yapıcıda şu şekilde bir rvalue ile başlatılabilir:

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

Bu güzel çünkü bu sınıfın bir örneğini geçici bir nesneyle bildirdiğimde:

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

geçici nesneyi kopyalamaktan ve yok etmekten kaçınmamız ve "merhaba" doğrudan sahip olan sınıfın üye değişkeninin içine yerleştirilmesidir. Nesne bir 'dizgiden' daha ağırsa, fazladan kopya ve yıkıcı çağrısı önemli olabilir.

GetString'e yapılan çağrı geri döner.

StringBuffer, GetString kapsamındadır. GetString'in kapsamının sonunda (yani geri döndüğünde) yok edilmelidir. Ayrıca, C ++ 'nın, referans olduğu sürece bir değişkenin var olacağını garanti edeceğine inanmıyorum.

Aşağıdakiler derlenmelidir:

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

Neredeyse tamamen aynı sınıfta yazdım:

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

Standarttan önce her derleyici bunu farklı şekilde yapıyordu. C ++ için eski Açıklamalı Referans Kılavuzunun kapsamın sonunda geçici dosyaların temizlenmesi gerektiğini belirttiğine inanıyorum, bu nedenle bazı derleyiciler bunu yaptı. 2003 gibi geç bir tarihte, bu davranışın Sun'ın Forte C ++ derleyicisinde hala varsayılan olarak var olduğunu buldum, bu yüzden StringBuffer çalışmadı. Ancak mevcut herhangi bir derleyici hala o kadar bozuksa şaşırırdım.