如何复制 const char* 类型变量的内容？

Question

I know the difference between:

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

from *a , it acts as the following...

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

If I want to create another variable say

char *b;

and I hope it copies all contents in pointer a points to instead of pointing to the a's content.

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

How to do this ?

Answer 1

In C, you can allocate a new buffer b, and then copy your string there with standard library functions like this:

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

Note the +1 in the malloc to make room for the terminating '\\0' . The sizeof(char) is redundant, but I use it for consistency.

In C++, you should use the safer and more elegant std::string :

std::string b {a};

Answer 2

In C++, you can do

const size_t n = strlen(a);   // excludes null terminator
char *b = new char[n + 1]{};  // {} zero initializes array
std::copy_n(a, n, b);

Live Example

However I recommend using std::string over C-style string since it is

• deals with \\0 -embedded strings correctly
• safe
• easy to use

Answer 3

a 's content, as you posted, points to a read-only memory location set up by the compiler. If you want to have another one at compile-time with distinct values you'll have to define one yourself:

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

Notice that according to §2.14.5, whether these two pointers will point or not to the same memory location is implementation defined

Whether all string literals are distinct (that is, are stored in nonoverlapping objects) is implementation defined.

Otherwise go for a heap-stored location like:

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

I would go for std::string s anyway.

Answer 4

You can use the non-standard (but available on many implementations) strdup function from <string.h> :

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

or you can reserve space with malloc and then strcpy :

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

Answer 5

The contents of a is what you have labelled as * in your diagram. a is your little box, and the contents of a are what is in the box!

The "string" is NOT the contents of a . It's somewhere else in memory, and a contains the address of that string.

Copying the contents of a to b would end up doing this:

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

To achieve what you have drawn in your second diagram, you need to take a copy of all the data which a is pointing to. This is not straightforward because how do you decide when to stop copying? There's no general way, but if you have predetermined that you just want to copy a string, then you can use a function which copies a string.

The common but non-standard strdup function will allocate new space and copy a string. Otherwise, you can allocate space (in any of the usual ways of allocating space in C) and then copy the string over to the allocated space.