Quanto sono sicuri e affidabili sono C ++ stringa letterali?

Question

Quindi, sto vogliono ottenere una migliore comprensione su come stringhe letterali nel lavoro C ++. Sono per lo più interessato a situazioni in cui si sta assegnando l'indirizzo di una letterale di stringa a un puntatore, e passando in giro. Ad esempio:

char* advice = "Don't stick your hands in the toaster.";

Ora lascia dire che solo passare questa stringa intorno copiando puntatori per tutta la durata del programma. Certo, non è probabilmente una buona idea, ma sono curioso di quello che sarebbe effettivamente succedendo dietro le quinte.

Per un altro esempio, diciamo che facciamo una funzione che restituisce un letterale stringa:

char* foo()
{
    // function does does stuff
    return "Yikes!"; // somebody's feeble attempt at an error message
}

Ora diciamo questa funzione viene chiamata molto spesso, e il valore letterale stringa viene utilizzato solo circa la metà del tempo si chiama:

// situation #1: it's just randomly called without heed to the return value
foo(); 

// situation #2: the returned string is kept and used for who knows how long
char* retVal = foo();

Nel primo caso, quello che succede? È la stringa appena creato ma non utilizzati, e mai deallocata?

Nel secondo caso, è la stringa sta per essere mantenuta fino a quando i reperti degli utenti hanno bisogno per questo? Che cosa succede quando non è più necessaria ... sarà che la memoria sia liberato allora (assumendo punti niente a che lo spazio più)?

Do non fraintendetemi, non sto pensando di usare le stringhe letterali come questo. Sto pensando di usare un contenitore per mantenere le mie corde sotto controllo (probabilmente std :: string). Sono per lo più semplicemente desideroso di sapere se queste situazioni potrebbero causare problemi sia per la gestione della memoria o di dati danneggiati.

Answer 1

String-letterali hanno il tipo const char[N] (dove N è la lunghezza + 1) e sono allocati staticamente. Non c'è bisogno di preoccuparsi di problemi di memoria; se una stringa viene utilizzato nel programma è tutto gestito per voi, e risiede da qualche parte nella memoria di programma (di solito di sola lettura).

Cioè, questi sono "lo stesso":

static const char str[] = "a string";
"a string"

Quando si punta ad un letterale stringa, si punta al primo carattere a matrice. In realtà, perché il tipo è const char[], è sicuro solo per puntare a via const char*. La conversione da stringa letterale a char* è obsoleto e non sicuri.

// the "same"
static const char str[] = "a string";
const char* strPtr = str; // decays

const char* s1 = "a string";
char* s2 = "a string"; // allowed, implicit const_cast

*s1 = 'A'; // not allowed, it's const
*s2 = 'B'; // allowed, it's not const (but leads to undefined behavior)

Answer 2

In primo luogo, dichiarare il valore restituito foo come const, perché stringhe sono costanti che non possono essere modificati senza provocare il "comportamento indefinito" temuto. Questo sarà quindi forzare tutti i puntatori che utilizzano il valore restituito di foo anche essere dichiarata come const, e potenzialmente limitare il danno che può essere (solitamente involontariamente) svolto. Le stringhe costanti vengono memorizzate nel 'testo' area di un binario eseguibile -. non sono creati in quanto tale, in fase di esecuzione