Temporal std :: cadenas devolviendo basura

Question

Todavía estoy aprendiendo C++, así que por favor tengan paciencia conmigo. Estoy escribiendo un envoltorio simple para mejorar las rutas del sistema de archivos. Tengo problemas extraños con la devolución de cadenas temporales. Aquí está mi clase simple (esto no es exacta, pero bastante cerca):

typedef const char* CString; 
typedef std::string String; 
typedef boost::filesystem::path Path; 

class FileReference { 

    public: 

     FileReference(const char* path) : mPath(path) {}; 

     // returns a path 
     String path() const { 
      return mPath.string(); 
     }; 

     // returns a path a c string 
     CString c_str() const { 
      return mPath.string().c_str(); 
     }; 

    private: 

     Path mPath; 

} 

Con el pequeño código de prueba a continuación:

FileReference file("c:\\test.txt"); 

OutputDebugString(file.path().c_str()); // returns correctly c:\test.txt 
OutputDebugString(file.c_str());  // returns junk (ie îþîþîþîþîþîþîþîþîþîþî.....) 

Estoy bastante seguro de que esto tiene que hacer frente a los temporales, pero No puedo entender por qué sería eso: ¿no debería todo estar copiando correctamente?

Answer 1

Parece mPath.string() devuelve una cadena por valor. Ese objeto de cadena temporal se destruye tan pronto como FileReference :: c_str() retorna, por lo que c_str() deja de ser válido. Con un modelo de este tipo, no es posible crear una función c_str() sin introducir algún tipo de variable de nivel estático o de clase para la cadena.

considerar las siguientes alternativas:

//Returns a string by value (not a pointer!) 
//Don't call it c_str() - that'd be misleading 
String str() const 
{    
    return mPath.string(); 
} 

o

void str(String &s) const 
{    
    s = mPath.string(); 
} 

Answer 2

CString c_str() const { 
     return mPath.string().c_str(); 
    }; 

mPath.string() devuelve una copia de un std::string. Esa copia se almacena en un temporal que se destruirá al final de esta expresión.

.c_str() devuelve un puntero a la memoria que se destruirá cuando se destruya la cadena, es decir, al final de esta expresión.

Está devolviendo un puntero a la memoria que ya está destruida.

Answer 3

Expresiones

OutputDebugString(file.path().c_str()) 

y

OutputDebugString(file.c_str()) 

son similares en que ambos llaman efectivamente c_str() método en un objeto temporal y std::string intentan utilizar el resultado de esa llamada. El primero lo llama directamente como subexpresión file.path().c_str(). El segundo lo hace de manera más implícita: dentro del método FileReference::c_str().

En el primer caso, el objeto temporal std::string se crea explícitamente mediante la llamada file.path() como una parte inmediata de toda la expresión. De acuerdo con las reglas del lenguaje, la duración de ese objeto temporal se extiende hasta el final de toda la expresión, por lo que el temporal y el resultado de la llamada c_str() permanecen válidos en todo momento.

En el segundo caso, se crea el objeto temporal std::string dentro del método FileReference::c_str(). Ese objeto temporal se destruye cuando este método retorna, lo que significa que FileReference::c_str() devuelve un puntero a datos "muertos". Esta es la razón de la "basura" en cuestión.