C/C++ Char Pointer Crash

Question

Let\'s say that a function which returns a fixed ‘random text’ string is written like

char *Function1()
{ 
return “Some text”;
}

then the p

Answer 1

The signature of that function should really be constchar* Function();.

Answer 2

It's not the brackets, but the assignement. Your function returns not a simple char *, but const char *( i can be wrong here, but the memory is read-only here), so you try to change the unchangeable memory. And the brackets - they just give you access to the element of the array.

Answer 3

Note also that you can avoid the crash by placing the text in a regular array:

char Function1Str[] = "Some text";

char *Function1()
{
    return Function1Str;
}

Answer 4

The question shows that you do not understand the string literals.

image this code

char* pch = "Here is some text";
char* pch2 = "some text";
char* pch3 = "Here is";

Now, how the compiler allocates memory to the strings is entirely a matter for the compiler. the memory might organised like this:

Here is<NULL>Here is some text<NULL>

with pch2 pointing to memory location inside the pch string.

The key here is understanding the memory. Using the Standard Template Library (stl) would be a good practice, but you may be quite a steep learning curve for you.

Answer 5

The string you're returning in the function is usually stored in a read-only part of your process. Attempting to modify it will cause an access violation. (EDIT: Strictly speaking, it is undefined behavior, and in some systems it will cause an access violation. Thanks, John).

This is the case usually because the string itself is hardcoded along with the code of your application. When loading, pointers are stablished to point to those read-only sections of your process that hold literal strings. In fact, whenever you write some string in C, it is treated as a const char* (a pointer to const memory).

Answer 6

You are trying to modify a string literal. According to the Standard, this evokes undefined behavior. Another thing to keep in mind (related) is that string literals are always of type const char*. There is a special dispensation to convert a pointer to a string literal to char*, taking away the const qualifier, but the underlying string is still const. So by doing what you are doing, you are trying to modify a const. This also evokes undefined behavior, and is akin to trying to do this:

const char* val = "hello";
char* modifyable_val = const_cast<char*>(val);
modifyable_val[1] = 'n';  // this evokes UB

Instead of returning a const char* from your function, return a string by value. This will construct a new string based on the string literal, and the calling code can do whatever it wants:

#include <string>

std::string Function1()
{ 
return “Some text”;
}

...later:

std::string s = Function1();
s[1] = 'a';

Now, if you are trying to change the value that Function() reuturns, then you'll have to do something else. I'd use a class:

#include <string>
class MyGizmo
{
public: 
  std::string str_;
  MyGizmo() : str_("Some text") {};
};

int main()
{
  MyGizmo gizmo;
  gizmo.str_[1] = 'n';
}