c++ pass by value segmentation fault

Question

I have a function f() which receives a char* p and gives a const char* to it.

void f(char *p) {
  string s = "def";
  strcpy(p, s.c_str());
}

In the main() below I expect to get q = "def".

int main(){
  char *q = "abc";
  f(q);
  cout << q << endl;
}

By running this I get segmentation fault and as I am new in C++ I don't understand why.

I also get a segmentation fault when I do not initialize q thus:

int main(){
  char *q;
  f(q);
  cout << q << endl;
}

Knowing that the function's parameter and the way it's called must not change. Is there any work around that I can do inside the function? Any suggestions? Thanks for your help.

Answer 1

You are trying to change a string literal. Any attemp to change a string literal results in undefined behaviour of the program.

Take into account that string literals have types of constant character arrays. So it would be more correct to write

  const char *q = "abc";

From the C++ Standard (2.14.5 String literals)

8 Ordinary string literals and UTF-8 string literals are also referred to as narrow string literals. A narrow string literal has type “array of n const char”, where n is the size of the string as defined below, and has static storage duration

You could write your program the following way

//...
void f(char *p) {
  string s = "def";
  strcpy(p, s.c_str());
}
//..
main(){
  char q[] = "abc";
  f(q);
  cout << q << endl;
}

If you need to use a pointer then you could write

//...
void f(char *p) {
  string s = "def";
  strcpy(p, s.c_str());
}
//..
main(){
  char *q = new char[4] { 'a', 'b', 'c', '\0' };
  f(q);
  cout << q << endl;
  delete []q;  
}

Answer 2

This is an issue that, in reality, should fail at compilation time but for really old legacy reasons they allow it.

"abc" is not not a mutable string and therefore it should be illegal to point a mutable pointer to it.

Really any legacy code that does this should be forced to be fixed, or have some pragma around it that lets it compile or some permissive flag set in the build.

But a long time ago in the old days of C there was no such thing as a const modifier, and literals were stored in char * parameters and programmers had to be careful what they did with them.

The latter construct, where q is not initialised at all is an error because now q could be pointing anywhere, and is unlikely to be pointing to a valid memory place to write the string. It is actually undefined behaviour, for obvious reason - who knows where q is pointing?

The normal construct for such a function like f is to request not only a pointer to a writable buffer but also a maximum available size (capacity). Usually this size includes the null-terminator, sometimes it might not, but either way the function f can then write into it without an issue. It will also often return a status, possibly the number of bytes it wanted to write. This is very common for a "C" interface. (And C interfaces are often used even in C++ for better portability / compatibility with other languages).

To make it work in this instance, you need at least 4 bytes in your buffer.

int main()
{
    char q[4];
    f(q);
    std::cout << q << std::endl;
}

would work.

Inside the function f you can use std::string::copy to copy into the buffer. Let's modify f. (We assume this is a prototype and in reality you have a meaningful name and it returns something more meaningful that you retrieve off somewhere).

size_t f( char * buf, size_t capacity )
{
    std::string s = "def";
    size_t copied = s.copy( buf, capacity-1 ); // leave a space for the null
    buf[copied] = '\0'; // std::string::copy doesn't write this
    return s.size() + 1; // the number of bytes you need
}

int main()
{
     char q[3];
     size_t needed = f( q, 3 );
     std::cout << q << " - needed " << needed << " bytes " << std::endl;
}

Output should be:

de needed 4 bytes

In your question you suggested you can change your function but not the way it is called. Well in that case, you actually have only one real solution:

void f( const char * & p )
{
   p = "def";
}

Now you can happily do

int main()
{
   const char * q;
   f( q );
   std::cout << q << std::endl;
}

Note that in this solution I am actually moving your pointer to point to something else. This works because it is a static string. You cannot have a local std::string then point it to its c_str(). You can have a std::string whose lifetime remains beyond the scope of your q pointer e.g. stored in a collection somewhere.

Answer 3

Look at the warnings you get while compiling your code (and if you don’t get any, turn up the warning levels or get a better compiler).

You will notice that despite the type declaration, the value of q is not really mutable. The compiler was humoring you because not doing so would break a lot of legacy code.

Answer 4

You can't do that because you assigned a string literal to your char*. And this is memory you can't modify.

Answer 5

With your f, You should do

int main(){
  char q[4 /*or more*/];
  f(q);
  std::cout << q << std::endl;
}

Answer 6

The problem is that you are trying to write on a read-only place in the process address space. As all the string literals are placed in read-only-data. char *q = "abc"; creates a pointer and points towards the read-only section where the string literal is placed. and when you copy using strcpy or memcpy or even try q[1] = 'x' it attempts to write on a space which is write protected.

This was the problem among many other solutions one can be

main(){
  char *q = "abc";    \\ the strings are placed at a read-only portion 
                      \\ in the process address space so you can not write that
  q = new char[4];    \\ will make q point at space at heap which is writable
  f(q);
  cout << q << endl;

  delete[] q;
}

the initialization of q is unnecessary here. after the second line q gets a space of 4 characters on the heap (3 for chars and one for null char). This would work but there are many other and better solutions to this problem which varies from situation to situation.