declaring a pointer or a stack variable - c++

Question

Assume we have the following case:
If it is morning mood is good otherwise mood is bad
Print the mood
it could be written as:
std::string mode; //this cost us calling the constructor of std::string
if(time==Morning){ // a real code should be here
mood="Good"//re assign the string
}
else{
mood="bad"//re assign the string
}
std::cout << mood;
assuming it is not std::string, it is a very big object. Isn't it too luxury to declare "mode" and call the constructor for no reason!
Is using the raw pointer a solution? what is the best practice here?
thanks

Answer 1

You could use the ternary operator to initialize the string.
std::string mode = (time == Morning ? "Good" : "Bad")
As MSalters pointed out in the comments this is actually still two constructions(constructor + copy) but it should get optimized by the compiler. You can directly initialize the string with
std::string mode { (time == Morning ? "Good" : "Bad") };

Answer 2

I would consider putting the logic into a separate function. This helps to keep functions small and simple.
std::string moodAtTime(Time time)
{
if(time==Morning)
{ // a real code should be here
return "Good";
}
else
{
return "bad";
}
}
std::string mood = moodAtTime(t);
This reduces function length and splits the code into small units performing simple questions.
If it is only for initialization, you can use a lambda to do it without the named function:
std::string mood = [](Time t)
{
if(t==Morning)
{
return "Good";
}
else
{
return "bad";
}
}(now);

Answer 3

The cost gets high if you enter that specific scope allot of times, and yes, it could get very expensive (depending on the what's happening inside the scope) .
The solution would be to keep either a global variable, or more widely used, a pool of such objects (object pools / memory are widely used for such purposes, especially in the case of small and very small objects).
So, to explain in code
// scope that is entered allot, like 100k times per second
{
std::string temp;
...
// magic happens
...
}
Quick solution
{
static std::string g_uniqueNamed_temp_string;
...
// magic happens
...
}
Elegant solution
EDIT : switched to raw pointers to avoid copying
{
std::string* tempString = StringPool::GetAPreallocatedString();
...
// magic happens
...
}

Answer 4

You can use alloca for that:
#include <iostream>
#include <sstream>
using namespace std::literals;
int main() {
void *mem = alloca(sizeof(std::string)); //Allocates memory on stack; no initialization
std::string *mood;
if(true){ // a real code should be here
mood = new (mem) std::string("Good");//re assign the string
}
else{
mood=new (mem) std::string("Bad");//re assign the string
}
std::cout << *mood;
return 0;
}