The value of c-strings change when I call an unrelated method - c++

Question

I am working on a header file that defines a namespace in which some c-strings are defined.
namespace env {
const char* C_NAME;
const char* SYS_DRIVE;
const char* PROCESSOR;
const char* PROCESSOR_ARCHITECTURE;
const char* OSNAME;
}
My main function looks like this:
int main(int argc, char* argv[], char* env[]) {
initialize_environment_vars(env);
cout << "C_NAME\t\t\t" << env::C_NAME << endl;
/*...*/
return 0;
}
My problem is that the strings I initialize in initialize_environment_vars() do not have the values I want them to have.
void initialize_environment_vars(char* env[]) {
int id = PRIVATE::findEntry(env, "COMPUTERNAME");
env::C_NAME = (str::getAfter(env[id], "=")).c_str(); // getAfter() returns a string
//std::cout << env::C_NAME << std::endl; //Right value!!!
id = PRIVATE::findEntry(env, "SystemDrive");
std::cout << env::C_NAME; //Value at env[id]
/*Here the other constants are initialized in the same way.*/
}
I have found out that in the function initialize_environment_vars() the variables have the right value until I call the function findEntry() to look for another entry.
int PRIVATE::findEntry(const char* const arr[], std::string toFind) {
bool found = false;
int i = 0;
std::string actual;
while(arr[i] && !found) {
actual = arr[i];
if(str::contains(actual, toFind)) {
found = true;
break;
}
i++;
}
if(found)
return i;
else { /*Error message and exit program*/ }
}
After reading this post, string::c_str query, I also thought that my use of .c_str() in initialize_environment_vars() is wrong, because the string that is returned would be destroyed after calling the .c_str(), but this does not seem to be the case, since the env::C_NAME is valid in main().
Thus I have two questions:
Why does my PRIVATE::findEntry(const char* const [], std::string) function change the value of env::C_NAME the way I use it above, even though it only returns an int and does not modify the array nor the entries?
Why is env::C_NAME still valid in 'main()'? Should it not become invalid after the destructor of the string that str::getAfter(const std::string&, std::string) returns is called? (ANSWERED)

Answer 1

Why does my PRIVATE::findEntry(const char* const [], std::string) function change the value of env::C_NAME the way I use it above, even though it only returns an int and does not modify the array nor the entries?
The return value of c_str() is no longer guaranteed to be valid if the string is destroyed or modified.
Why is env::C_NAME still valid in 'main()'? Should it not become invalid after the destructor of the string that str::getAfter(const std::string&, std::string) returns is called?
It's not. It just happens to contain what you want it to contain rather than happening to contain something other than what you want it to contain. If you flip a coin in a circumstance in which it might come up heads, you are doing something broken, but it might happen to work. If you do it again, it might happen not to work. That's why we don't do stuff like this.
Do not confuse how code happens to behave without how you should expect code to behave. In situations where we expect things to be invalid, we have no idea how the code will actually behave. It might happen to do something good, it might happen to do something disastrous. It might change with the compiler options, compiler version, platform, or other parameters.
You have two obvious options. You can change the type of these variables from const char * to std::string or you can use malloc or strdup to allocate memory that will remain valid.

Answer 2

Your "c-strings" in your env environment are just pointers... nothing more. For example, env::C_NAME points to the address that once held the string you got with (str::getAfter(env[id], "=")). Who knows what's there now? You could change your "c-strings" in env to be char buffers of fixed size and use strcpy() to copy the content into them (beware of overrunning the end of the buffers though), or you could leave them as pointers and malloc() space for your copies of the strings, then strcpy() the original strings into your malloc()ed buffers, or best option, use std::string and don't worry about the nitty gritty.