Come copiare il contenuto della variabile di tipo const char *?

Question

so la differenza tra:

char *a = "string"; 
char p[] = "string"; 

da *a, agisce come la seguente ...

 +-----+  +---+---+---+---+---+---+---+ 
    a: | *======> | s | t | r | i | n | g |\0 |  
    +-----+  +---+---+---+---+---+---+---+ 

Se voglio creare un'altra variabile dicono

char *b; 

ed io spero che copi tutto il contenuto nel puntatore a punta anziché puntare al contenuto della a.

 +-----+  +---+---+---+---+---+---+---+  
    a: | *======> | s | t | r | i | n | g |\0 |  
    +-----+  +---+---+---+---+---+---+---+ 
    b: | *======> | s | t | r | i | n | g |\0 |  
    +-----+  +---+---+---+---+---+---+---+ 

Come fare?

Answer 1

In C++, si può fare

char *b = new char[strlen(a) + 1]{}; 
std::copy(a, a + strlen(a), b); 

Ecco a live example. Anche se, mi consiglia di utilizzare std::string per la sua sicurezza e facilità d'uso.

Answer 2

È possibile utilizzare il non-standard (ma disponibile su molte implementazioni) strdup funzione dal <string.h>:

char *b; 
strdup(b, a); 
... 
free(b); 

o è possibile prenotare lo spazio con malloc e poi strcpy:

char *b; 
b = malloc(strlen(a) + 1); 
strcpy(b, a); 
... 
free(b); 

Answer 3

a ' Il contenuto di s, come hai postato, punta a una posizione di memoria di sola lettura impostata dal compilatore. Se si desidera avere un altro al momento della compilazione con valori distinti si dovrà definire uno voi stessi:

char *a = "string"; 
char *b = "string"; // Nb. This might point to the same location as a 

Si noti che in base alla §2.14.5, se questi due puntatori punterà o meno allo stesso locazione di memoria è attuazione definita

Se tutte le stringhe letterali sono distinte (cioè, sono memorizzati negli oggetti sovrapposti) è implementazione definita.

altrimenti passare per una posizione heap-memorizzati come:

size_t len = strlen(a); // Doesn't include null-terminator character 
char *b = new char[len+1]; 
memcpy(b, a, len); // Assumes plain ASCII string 
b[len] = '\0'; 

vorrei andare per std::string s comunque.

Answer 4

In C, è possibile allocare un nuovo buffer b, e quindi copiare la stringa lì con funzioni della libreria standard del genere:

b = malloc((strlen(a) + 1) * sizeof(char)); 
strcpy(b,a); 

Nota la +1 nella malloc per fare spazio per la terminazione '\0'. Il sizeof(char) è ridondante, ma lo uso per coerenza.

In C++, è necessario utilizzare il più sicuro e più elegante std::string:

std::string b {a}; 

Answer 5

Il contenuto di a è quello che è stato etichettato come * nel diagramma. a è la tua piccola scatola, e il contenuto di a è quello che è nella scatola!

La "stringa" NON è il contenuto di a. È altrove nella memoria e a contiene l'indirizzo di quella stringa.

Copiare il contenuto del a-b finirebbe per fare questo:

+-----+  +---+---+---+---+---+---+---+  
a: | *======> | s | t | r | i | n | g |\0 |  
    +-----+/+---+---+---+---+---+---+---+ 
b: | *====/ 
    +-----+  

per ottenere quello che avete disegnato nel secondo schema, è necessario prendere una copia di tutti i dati che a sta indicando . Questo non è semplice perché come decidi quando smettere di copiare? Non c'è un modo generale, ma se hai predeterminato che vuoi solo copiare una stringa, allora puoi usare una funzione che copia una stringa.

La funzione comune ma non standard strdup allocherà nuovo spazio e copierà una stringa. Altrimenti, è possibile allocare spazio (in uno dei modi usuali di allocazione dello spazio in C) e quindi copiare la stringa nello spazio allocato.