Assigning const char* to char*

Question

#include <cstring>

char* str0;
const char* str1 = "abc";


// assign str1 to str0
strcpy(str0, str1);    // syntax correct, but run time error
str0 = str1;           // syntax error, cannot convert const char* to char*
string n_str = str1;
str0 = n_str;          // syntax error, cannot convert ...


cout << str0 << endl;  // expected output: abc

I'd like to make str0 same as str1 while runtime(after compilation), I don't know how to do it. And for the case str0 = str1; I don't understand why it won't work, because str0 points to nothing, while str1 points to a const string literal, so if I now make str0 point to what str1 is pointing to, it should be fine, but it is not. So it there any way to solve it?

Answer 1

std::string str0;
const std::string str1 = "abc";

// assign str1 to str0
str0 = str1;

cout << str0 << endl;  // output: abc

If you insist on using C:

char* str0;
const char* str1 = "abc";

str0 = malloc(strlen(str1) + 1);
// if you use a c++ compiler you need instead:
// str0 = (char*) malloc(strlen(str1) + 1);

strcpy(str0, str1);

// and free after use
// if you use C++ this will not help much
// as pretty much any exception above will cause your code to get out of `free`,
// causing a memory leak
free(str0);

If you insist on using bad C++:

char* str0;
const char* str1 = "abc";

str0 = new char[strlen(str1) + 1];

strcpy(str0, str1);

// and delete after use
// this will not help much
// as pretty much any exception above will cause your code to get out of `delete`,
// causing a memory leak
delete(str0);

Please read about RAII to understand why all of the solutions with manual memory management are bad: cppreference , wiki

Answer 2

Let's look one issue at a time

strcpy(str0, str1);

strcpy copies the characters pointed by str1 into the memory pointed by str0. str1 points to "abc", but str0 doesn't point to anything, hence the runtime error. I would recommend using std::string everywhere so you don't have to manage the memory yourself.

str0 = str1;  

str0 is of type char*, str1 is of type const char*. The const qualifier instructs the compiler to not allow data modification on that particular variable (way over simplified role of const, for more in-depth explanation use your favorite search engine and you should be able to find a bunch of articles explaining const). If you'd be able to assign the same pointer to str0 you'd break the const contract; str0 can be modifiable.

string n_str = str1;

This is valid because std::string overloads the assignment operator and accepts a const char pointer as the right hand value.

str0 = n_str;

n_str is of type std::string and str0 is char*, there's no overloaded operator that allows this. If you really want the raw point out of an std::string you can use the c_str() method and it will return you a const char* - I strongly advise against it, unless you have to pass it to a function that only accepts const char*.

Answer 3

Copying strings is an expensive operation. But moving strings from one place to another is efficient.

casts away the const

str0 = (char*) str1;

or use std::string class template library for managing strings. std::string owns the character buffer that stores the string value. characters are part of the string object. cont char* stores the address of such a character buffer but does not own it.

c_str returns a const char* that points to a null-terminated string. It is useful when you want to pass the contents.

std::string str1 = "abc";
char* str0;

strcpy(str0, str1.c_str());
printf(str0);

Answer 4

const is part of the type, and as such, you can cast it "away". This is considered bad practice, but you should think of const as a strong suggestion of the original programmer, not to modify it.

const char * str1 = "abc";
char * str2 = (char*) str1;