The following statment doesn't create a value on the Heap, nor the stack. Where does it exist in memory until then?

Question

This is from my Computer Science Class

"This is dangerous (and officially deprecated in the C++ standard) because you haven't allocated memory for str1 to point at."

            — jD3V's Computer Science Professor

The Quote Above is Referring to this Line of Code

    char* str1 = "Hello world";

To be clear:

I Get that using a pointer, as shown in the Line of Code above, is deprecated. I also know that it shouldn't appear in my code.

The Part I Don't Get:

The example line of code — char* str1 = "Hello world"; — works, and that surprises me.

It says that no memory has been allocated for the pointer to point at, though the pointer could still be accessed to obtain the C-String "Hello World". I am unaware of another place in memory, though my guess is that there has to be one, because if the following statement doesn't exist on the heap — "and its not placed in the stack according to my debugger" — then it must live in another memory location.

I am trying to be able to understand, and locate where the variables I declare are at in memory, and I am unable to do that here.

I would like to know...

In the example I showed above, where is the string "Hello World", and the str1 pointer that points at it, located in memory, if not in the Heap, or on the Stack?

Answer 1

[Disclaimer: I wrote this answer when the question was tagged both [c] and [c++]. The answer is definitely different for C versus C++. I am leaning somewhat towards C in this answer.]

char* str = "Hello world";

This is perfectly fine in C.

According to my CS Professor, in reference to the statement above, he says...

"This is dangerous (and officially deprecated in the C++ standard) because you haven't allocated memory for str to point at."

Either you misunderstood, or your professor is very badly confused.

The code is deprecated in C++ because you neglected to declare str as being a pointer to unmodifiable (i.e. const) characters. But there is nothing, absolutely nothing, wrong with the allocation of the pointed-to string.

When you write

char *str = "Hello world";

the compiler takes care of allocating memory for str to point to. The compiler behaves more or less exactly as if you had written

static char __hidden_string[] = "Hello world";
char *str = __hidden_string;

or maybe

static const char __hidden_string[] = "Hello world";
char *str = (char *)__hidden_string;

Now, where is that __hidden_string array allocated? Certainly not on the stack (you'll notice it's declared static), and certainly not on the heap, either.

Once upon a time, the __hidden_string array was typically allocated in the "initialized data" segment, along with (most of) the rest of your global variables. That meant you could get away with modifying it, if you wanted to.

These days, some/many/most compilers allocate __hidden_string in a nonwritable segment, perhaps even the code segment. In that case, if you try to modify the string, you'll get a bus error or the equivalent.

For backwards compatibility reasons, C compilers cannot treat a string constant as if it were of type const char []. If they did, you'd get a warning whenever you wrote something like

char *str = "Hello world";

and to some extent that warning would be a good thing, because it would force you to write

const char *str = "Hello world";

making it explicit that str points to a string that you're not allowed to modify.

But C did not adopt this rule, because there's too much old code it would have broken.

C++, on the other hand, very definitely has adopted this rule. When I try char *str = "Hello world"; under two different C++ compilers, I get warning: conversion from string literal to 'char *' is deprecated. It's likely this is what your professor was trying to get at.

Answer 2

Summary:

• "any strings in double quotes" are const lvalue string literals, stored somewhere in compiled program.

• You can't modify such string, but you can store pointer to this string (of course const) and use it without modifying:

  const char *str = "some string"

  For example:

  int my_strcmp(const char *str1, const char *str2) { ... }
  
  int main() 
  {
      ...
  
      const char *rule2_str= "rule2";
  
      // compare some strings
      if (my_strcmp(my_string, "rule1") == 0)
          std::cout << "Execute rule1" << std::endl;
      else if (my_strcmp(my_string, rule2_str) == 0)
          std::cout << "Execute rule2" << std::endl;
  
      ...
  }
  

• If you want to modify string, you can copy string literal to your own array: char array[] = "12323", then your array will ititialize as string with terminate zero at the end:

  Actually char array[] = "123" is same as char array[] = {'1', '2', '3', '\0'}.

  For example:

  int main()
  {
      char my_string[] = "12345";
      my_string[0] = 5; // correct!
  
      std::cout << my_string << std::endl; // 52345
  }
  

  Remember that then your array will be static, so you can't change it's size, for "dynamic sized" strings use std::string.

Answer 3

The problem is in lvalue and rvalue. lvalue defines locator value and it means that it has a specified place in memory and you can easily take it. rvalue has undefined place in memory. For example, any int a = 5 has 5 as rvalue. So you cannot take the address of an rvalue. When you try to access the memory for char* str = "Hello World" with something like str[0] = 'x' you will get an error Segmentation fault which means you tried to get unaviable memory. Btw operators * and & are forbidden for rvalues, it throws compile time error, if you try to use them.
The lvalue of "Hello World" is stored at the programms segment of memory. But it is specified so, as the programm can't modify it directly.