是否使用strcpy

Question

If I have an array of strings

char* q[2];
q[0] = "Hello";
q[1] = "World";

and I want to put q[0] in a new array of strings

char* x[2];

called x in x[0], should I use strcpy or just this?

x[0] = q[0];

This seems to work, but no using strcpy has caused some problems in the past.

Should I do this just in case? What is the difference?

char* a = malloc(strlen(q[0]) + 1);
strcpy(a, q[0]);
x[0] = a;

Answer 1

The assignment works without allocating any extra memory.

If you use strcpy() , you have to assign enough memory to x[0] before you do the copy ( strlen(q[0]) + 1 bytes minimum), and you have to ensure it is released at the appropriate time.

Answer 2

To be clear, there is nothing "broken" about strcpy() ; if it has "has caused some problems in the past" for you, that that is because of errors in your usage, not any intrinsic issue with strcpy() , and you should perhaps post a question about that so your misconceptions can be corrected.

The semantics between string pointer assignment and string copy differ, so it depends what you are trying to do.

x is an array of pointers. The assignment:

x[0] = q[0];

Does not copy the string pointed to by q[0] to the memory pointed to by x[0] . rather it changes the value of x[0] to the address of the string referred to by q[0] . So they both refer to the same string in memory. No string data is moved or copied , only the reference to the string literals in this case:

q[0] --> "Hello"
          ^
          |
x[0] -----

In this sense x is not "a new array of strings" as you describe, but an array of pointers to the same strings . So is perhaps not the semantic behaviour you intended.

If you were to attempt:

strcpy( x[0], q[0] ) ;

That would be a semantic error since in your fragments x[0] does not point to any defined memory, so the string data referred to by q[0] will be copied to some undefined location with undefined results - none good, even if it superficially appears to work.

If x[0] referred to some validly allocated space by for example either being declared as an array thus:

char x[2][128] ;

or being dynamically allocated:

x[0] = malloc( 128 ) ;

or by first being assigned to some other valid space:

char a[120]
x[0] = a ;

Or by dynamically allocating a as in the example in your question.

Then strcpy( x[0], q[0] ) is a valid operation and would copy the string referred to by q[0] to the space referred to by x[0] :

q[0] --> "Hello"

x[0] --> "Hello"

Critically in this case the strings do not refer to the same space in memory.

Note that if you actually wanted string pointer assignment semantics (which is probably less likely), and q refers to literal string constants , then for safer code it is important that you declare the arrays as pointers to const data:

const char* q[2] ;
const char* x[2] ;

The q array should be declared const in this case in any event, but clearly x should not be const if you want string-copy semantics.

Helpfully by declaring it const , any attempt to strcpy() to it will fail deterministicly at compilation rather than having some undefined and erroneous and possibly latent run-time behaviour. So it enforces the intended semantics if that is indeed what you intended. Equally it stops you from attempting to modify the data referred to by q[n] which would also be undefined behaviour (but will generally cause a runtime error on a modern desktop OS).

Answer 3

There is no general rule, which one is better. This solely depends on your intented usage of the strings.

Simply assigning the pointer will work if you do not plan to modify the memory independently.

If you free the first pointer, you will still have a copy in the second pointer. But now it is invalid. Also if you add or change content via one pointer, this change will be visible via second pointer as well. This happens because you are using same memory.

If you copy the string, you have independend content. You can free or modify via the first pointer and still use it via second pointer. Of course you also have to free the memory separately if you have copied to another location.

The simple assignment is faster, of course. Which one is better depends on your needs.

Answer 4

I have an array of strings

Well, not quite. q is declared as

char* q[2];

Which makes it an array of two pointers to char . What is commonly referred to as a string , in C, is a NULL-terminated array of char .

Then, two values are assigned to each element of the array:

q[0] = "Hello";
q[1] = "World";

Where both "Hello" and "World" are string literals . No string is copied here, only the pointers.

Later in the code you could reassign each pointer, like in

q[0] = "Bye";

But any attempt to modify the characters or free the pointers would lead to hard to detect bugs.

It would be safer to declare it as an array to pointer to const char , if they are meant to be untouched, so that, in case of mistakes, at least the error messages would be more informative. Eg 1 or 2 .

If you need modifiable strings and the control of those objects lifetime, your only option is to allocate enough memory and copy the strings.