If I use
const char * str = "Hello";
there is no memory allocation/deallocaton needed in runtime
If I use
const std::string str = "Hello";
will be there an allocation via new/malloc inside string class or not? I could find it in assembly, but I am not good at reading it.
If answer is "yes, there will be malloc/new", why? Why can there be only pass through to inner const char pointer inside std::string and do actual memory allocation if I need to edit edit string?
will be there an allocation via new/malloc inside string class or not?
It depends. The string object will have to provide some memory to store the data, since that's its job. Some implementations use a "small string optimisation", where the object contains a small buffer, and only allocates from the heap if the string is too large for that.
Why can there be only pass through to inner const char pointer inside
std::stringand do actual memory allocation if I need to edit edit string?
What you describe isn't necessarily an optimisation (since it needs an extra runtime check whenever you modify the string), and in any case isn't allowed by the iterator invalidation rules.
There is a proposal for a string_view, allowing you to access an existing character sequence with an interface like const string, without any memory management. It's not yet standard, and doesn't allow you to modify the string.
Naive implementation of std::string will require a heap allocation however compilers are allowed to optimize statically initialized std::string objects by replacing them with objects of alternative implementations if the initialized strings are not modified during runtime.
You may use const std::string when you instantiate immutable strings to ensure better optimization.
static cosnt std::string would be even more "optimized", in terms of potentially less dynamic allocations per call of function.
The C++ standard doesn't actually say you can't just store a pointer to an external string (and a length). However, that means EVERY time you may modify the string (e.g. char& std::string::operator[](size_t index)) would have to ensure that the string is actually writeable. Since a large number of string usage does NOT use a constant string only to store the string, but does indeed modify the string [or use a string that isn't a constant input anyway].
So, some problems are;
std::string s = "Hello";
char &c = s[1];
c = 'a'; // Should make string to "Hallo".
what if:
char buffer[1000];
cin.getline(buffer); // Reads "Hello"
std::string s = buffer;
cin.getline(buffer); // Reads "World"
What is the value in s now?
There are so many such cases where if you were to just copy the original string, it would cause more problems, and little or no benefit.
char str[] = "Hello";orconst std::string str = "Hello";or evenstatic const std::string str = "Hello".