È necessario distruggere char * = “string” o char * = new char[6]?

Question

presumo che char* = "string" è lo stesso per char* = new char[6].Credo che queste stringhe vengano create sull'heap anziché sullo stack.Quindi devo distruggerli o liberare la loro memoria quando ho finito di usarli o si distruggono da soli?

Answer 1

NO.È necessario liberare manualmente le stringhe solo quando si alloca manualmente la memoria utilizzando il file malloc funzione (in C) o il new operatore (in C++).Se non usi malloc O new, poi il char* o la stringa verrà creata nello stack o come costante in fase di compilazione.

Answer 2

NO.Quando dici:

const char* c = "Hello World!";

Stai assegnando c a una costante stringa "preesistente" che NON è la stessa di:

char* c = new char[6];

Solo in quest'ultimo caso stai allocando memoria sull'heap.Quindi chiameresti Elimina quando hai finito.

Answer 3

Presumo quando lo farò char* = "string" è la stessa cosa di char* = new char[6].

NO.Ciò che fa il primo è creare una costante.Modificarlo è un comportamento indefinito.Ma per rispondere alla tua domanda;no, non devi distruggerli.E solo una nota, usalo sempre std::string quando possibile.

Answer 4

Il nome del gioco è "distruggi solo ciò che hai creato".Ecco le coppie:

1. malloc/free
2. calloc/free
3. new/delete
4. new []/delete []

Dato che hai creato la seconda stringa utilizzando new [], spetta a te distruggerlo delete [].Chiamata delete [] string2 quando hai finito.

Ora, se il codice è sufficientemente contorto e rende difficile tenere traccia delle eliminazioni, prendere in considerazione l'utilizzo di puntatori con ambito o puntatori automatici.IL boost::scoped_ptr class dalla libreria boost è un buon punto di partenza.Guarda anche il RAII idioma, roba piuttosto pratica e utile.

Answer 5

Non sono la stessa cosa.Il tuo primo esempio è una stringa costante, quindi sicuramente non è allocata dall'heap.Il tuo secondo esempio è un'allocazione di memoria di runtime di 6 caratteri e proviene dall'heap.Non vuoi eliminare il tuo primo esempio, ma devi farlo delete [] il tuo secondo esempio.

Answer 6

Non sai dove sono archiviati i valori letterali delle stringhe.Potrebbe anche essere memoria di sola lettura, quindi il tuo codice dovrebbe leggere:

const char* c = "string";

E un nuovo dovrebbe essere l'array di caratteri eliminared proprio come qualsiasi altra area di memoria allocata dinamicamente.

Answer 7

new è sempre un'allocazione mentre la definizione di una stringa in linea incorpora effettivamente i dati nel programma stesso e non può essere modificata (alcuni compilatori lo consentono con un trucco intelligente, non preoccuparti).

Alcuni compilatori digitano stringhe inline in modo che non sia possibile modificare il buffer.

char* const sz1 = "string"; // embedded string, immutable buffer
char* sz2 = new char[10]; // allocated string, should be deleted

Answer 8

Vediamo cosa fa GCC 4.8 x86-64 Linux

Programma:

#include <cstdio>
int main() {
    const char *s = "abc";
    char *sn = new char[4];
    sn[3] = '\0';
    std::printf("%s\n", s);
    std::printf("%s\n", sn);
}

Compilare e decompilare:

g++ -ggdb -std=c++98 a.cpp
objdump -CSr a.o

L'output contiene:

  const char *s = "abc";
 8:   48 c7 45 f0 00 00 00    movq   $0x0,-0x10(%rbp)
 f:   00 
                     c: R_X86_64_32S .rodata
  char *sn = new char[4];
10:   bf 04 00 00 00          mov    $0x4,%edi
15:   e8 00 00 00 00          callq  1a <main+0x1a>
                        16: R_X86_64_PC32       operator new[](unsigned long)-0x4
1a:   48 89 45 f8             mov    %rax,-0x8(%rbp)

Interpretazione:

• char *s = "abc" entra .rodata.Quindi non puoi free in alcun modo.
• char *sn = new char[4]; proviene dall'output di operator new[].Quindi dovresti liberarlo quando puoi.