Make a copy of a char*

Question

I have a function that accepts a char* as one of its parameters. I need to manipulate it, but leave the original char* intact. Essentially, I want to create a working copy of this char*. It seems like this should be easy, but I am really struggling.

My first (naive) attempt was to create another char* and set it equal to the original:

char* linkCopy = link;

This doesn't work, of course, because all I did was cause them to point to the same place.

Should I use strncpy to accomplish this?

I have tried the following, but it causes a crash:

char linkCopy[sizeof(link)] = strncpy(linkCopy, link, sizeof(link));

Am I missing something obvious...?

EDIT: My apologies, I was trying to simplify the examples, but I left some of the longer variable names in the second example. Fixed.

Answer 1

You might want to take a look at the strdup (man strdup) function:

char *linkCopy = strdup(link);

/* Do some work here */

free(linkCopy);

Edit: And since you need it to be standard C, do as others have pointed out:

char *linkCopy = malloc(strlen(link) + 1);
/* Note that strncpy is unnecessary here since you know both the size
 * of the source and destination buffers
 */
strcpy(linkCopy, link);

/* Do some work */

free(linkCopy);

---

Since strdup() is not in ANSI/ISO standard C, if it's not available in your compiler's runtime, go ahead and use this:

/*
**  Portable, public domain strdup() originally by Bob Stout
*/

#include <stdlib.h>
#include <string.h>

char* strdup(const char* str)
{
      char* newstr = (char*) malloc( strlen( str) + 1);

      if (newstr) {
          strcpy( newstr, str);
      }

      return newstr;
}

Answer 2

Use strdup, or strndup if you know the size (more secure).

Like:

char* new_char = strdup(original);
... manipulate it ...
free(new_char)

ps.: Not a C standard

Answer 3

The sizeof will give you the size of the pointer. Which is often 4 or 8 depending on your processor/compiler, but not the size of the string pointed to. You can use strlen and strcpy:

// +1 because of '\0' at the end
char * copy = malloc(strlen(original) + 1); 
strcpy(copy, original);
...
free(copy); // at the end, free it again.

I've seen some answers propose use of strdup, but that's a posix function, and not part of C.

Answer 4

You are on the right track, you need to use strcpy/strncpy to make copies of strings. Simply assigning them just makes an "alias" of it, a different name that points to the same thing.

Your main problem in your second attempt is that you can't assign to an array that way. The second problem is you seem to have come up with some new names in the function call that I can't tell where they came from.

What you want is:

char linkCopy[sizeof(link)];
strncpy(linkCopy, chLastLink, sizeof(link));

but be careful, sizeof does not always work the way you want it to on strings. Use strlen, or use strdup.

Answer 5

Like sean.bright said strdup() is the easiest way to deal with the copy. But strdup() while widely available is not std C. This method also keeps the copied string in the heap.

char *linkCopy = strdup(link);

/* Do some work here */

free(linkCopy);

If you are committed to using a stack allocated string and strncpy() you need some changes. You wrote:

char linkCopy[sizeof(link)]

That creates a char array (aka string) on the stack that is the size of a pointer (probably 4 bytes). Your third parameter to strncpy() has the same problem. You probably want to write:

char linkCopy[strlen(link)+1];
strncpy(linkCopy,link,strlen(link)+1);

Answer 6

You don't say whether you can use C++ instead of C, but if you can use C++ and the STL it's even easier:

std::string newString( original );

Use newString as you would have used the C-style copy above, its semantics are identical. You don't need to free() it, it is a stack object and will be disposed of automatically.

Answer 7

Some answers, including the accepted one are a bit off. You do not strcpy a string you have just strlen'd. strcpy should not be used at all in modern programs.

The correct thing to do is a memcpy.

EDIT: memcpy is very likely to be faster in any architecture, strcpy can only possibly perform better for very short strings and should be avoided for security reasons even if they are not relevant in this case.