C++ memcpy to char* from c_str

Question

I've done a bit of basic reading and from what I've gathered .c_str() always has a null terminator.

I have a fairly simple C++ program:

int main(int argc, char** argv)
{
  std::string from = "hello";
  char to[20];
  memcpy(to, from.c_str(), strlen(from.c_str())+1);
  std::cout<< to << std::endl;
  return 0;
}

Will that memcpy ensure that I copy over a null-terminated string to my variable to (provided that my string from is shorter in length)?

Yes, since `c_str()` is always null-terminated, but is there any particular reason for doing this? — chris, Jul 11 '13 at 06:45
Why are you doing this at all? One of the primary strengths of std::string is *not* using raw arrays of char like this. — Jerry Coffin, Jul 11 '13 at 06:45
By the way, `size()` or `length()` will get you a constant time size, whereas `strlen()` is linear. — chris, Jul 11 '13 at 06:47
My only constraint is that I have to copy into a fix sized char* — Max, Jul 12 '13 at 01:14

score 8 · Answer 1 · answered Jul 11 '13 at 07:39

8

You should use std::string to copy strings. However, if you want to do it like that you should use strcpy instead of memcpy

int main(int argc, char** argv)
{
  std::string from = "hello";
  char to[20];
  strcpy(to, from.c_str());
  std::cout<< to << std::endl;
  return 0;
}

answered Jul 11 '13 at 07:39

ronag

49,529
25
126
221

You will have to cast it to char * e.g strcpy(to,(char*)from.c_str()); – CM777 Feb 17 '22 at 15:51

score 5 · Accepted Answer · answered Jul 11 '13 at 06:55

5

memcpy doesn't know what is a string. you give it a range to copy. it depends on strlen here to provide the termination point of range

answered Jul 11 '13 at 06:55

Neel Basu

12,638
12
82
146

Chris · Answer 3 · 2013-07-11T08:32:17.453

Yes, this will work as long as your string in from is shorter than 20. Oh, no, wait, we are also copying the NULL terminator so it must be shorter than 19. I guess you see how that can lead to some confusion.

Which is by the way exactly the reason why this code is dangerous: I am assuming this is demo code and your actual code will get that string from some sort of input. At that moment you will not be able to control how long it is. You can truncate it but you might forget to do that which means that your program will be copying content to memory that possibly does not belong to it. This might lead to a crash but at least to undefined behaviour as you are overwriting memory that might contain other important data.

Using the string class actually helps to avoid such problems by not having to specify the string length. I would suggest using this class and only do operations involving c_str() when absolutely necessary.

Antonio · Answer 4 · 2021-02-03T14:46:12.017

0

The answer to your question is "yes" (as long as you char array is big enough, you should put a verification step).

If you really want to do this, you can do:

int main(int argc, char** argv)
{
  std::string from = "hello";
  char* to = new char[from.length() + 1];
  strcpy(to, from.c_str()); ///Or memcpy(to, from.c_str(), from.length() + 1 );
  std::cout<< to << std::endl;
  delete[] to;
  return 0;
}

Which is safer as long as you are not writing another, longer string into "to"

edited Feb 03 '21 at 14:46

answered Jul 11 '13 at 07:11

Antonio

19,451
13
99
197

Hello Does this solve the possible size limit problems which was 20 in previous example? why do you use delete? why do you use dynamic memory allocation? – Meric Ozcan Feb 03 '21 at 13:02
1

@MericOzcan 1) Yes 2) In order to free the memory after we have finished using it. We need `delete[]` because we used `new[]` 3) It is the only correct way to allocate a buffer whose size is not known at compile time – Antonio Feb 03 '21 at 14:42

C++ memcpy to char* from c_str

4 Answers4