Durata garantita temporanea in C ++?

Il C ++ fornisce una garanzia per la durata di una variabile temporanea creata all'interno di una chiamata di funzione ma non utilizzata come parametro? Ecco un esempio di classe:

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

Ed ecco come lo useresti:

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

Quando verrà chiamato il distruttore per l'oggetto StringBuffer temporaneo? È:

• Prima della chiamata a GetString?
• Dopo che GetString è tornato?
• Dipendente dal compilatore?

So che il C ++ garantisce che una variabile temporanea locale sarà valida fintanto che c'è un riferimento ad essa: questo si applica agli oggetti padre quando c'è un riferimento a una variabile membro?

Grazie.

Il distruttore per quel tipo di provvisori viene chiamato alla fine dell'espressione completa. Questa è l'espressione più esterna che non fa parte di nessun'altra espressione. Questo è nel tuo caso dopo che la funzione ritorna e il valore viene valutato. Quindi, funzionerà tutto bene.

È infatti ciò che fa funzionare i modelli di espressione: possono mantenere i riferimenti a quel tipo di temporanei in un'espressione come

e = a + b * c / d

Perché ogni temporaneo durerà fino all'espressione

x = y

Viene valutato completamente. È descritto in modo abbastanza conciso 12.2 Temporary objectsnello Standard.

la risposta di litb è accurata. La durata dell'oggetto temporaneo (noto anche come valore r) è legata all'espressione e il distruttore per l'oggetto temporaneo viene chiamato alla fine dell'espressione completa e quando viene chiamato il distruttore su StringBuffer, sarà anche il distruttore su m_buffer chiamato, ma non il distruttore su m_str poiché è un riferimento.

Nota che C ++ 0x cambia le cose solo un po 'perché aggiunge riferimenti rvalue e sposta la semantica. Essenzialmente utilizzando un parametro di riferimento rvalue (annotato con &&) posso "spostare" il valore rvalue nella funzione (invece di copiarlo) e la durata di rvalue può essere vincolata all'oggetto in cui si muove, non all'espressione. C'è un ottimo post del blog del team di MSVC su questo argomento in grande dettaglio e incoraggio le persone a leggerlo.

L'esempio pedagogico per spostare i rvalue sono le stringhe temporanee e mostrerò l'assegnazione in un costruttore. Se ho una classe MyType che contiene una variabile membro di stringa, può essere inizializzata con un rvalue nel costruttore in questo modo:

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

Questo è bello perché quando dichiaro un'istanza di questa classe con un oggetto temporaneo:

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

quello che succede è che evitiamo di copiare e distruggere l'oggetto temporaneo e "hello" viene posizionato direttamente all'interno della variabile membro dell'istanza della classe proprietaria. Se l'oggetto ha un peso maggiore di una "stringa", la chiamata aggiuntiva alla copia e al distruttore può essere significativa.

Dopo la chiamata a GetString ritorna.

StringBuffer rientra nell'ambito di GetString. Dovrebbe essere distrutto alla fine dell'ambito di GetString (cioè quando ritorna). Inoltre, non credo che C ++ garantirà che una variabile esisterà finché c'è un riferimento.

Il seguente dovrebbe essere compilato:

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

Ho scritto quasi esattamente la stessa classe:

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

Prima dello standard, ogni compilatore lo faceva in modo diverso. Credo che il vecchio Annotated Reference Manual per C ++ specificasse che i provvisori dovevano essere ripuliti alla fine dell'ambito, quindi alcuni compilatori lo hanno fatto. Fino al 2003, ho scoperto che il comportamento esisteva ancora per impostazione predefinita sul compilatore Forte C ++ di Sun, quindi StringBuffer non funzionava. Ma sarei stupito se qualche compilatore attuale fosse ancora così rotto.