Question

what does something like this do?

static int i;

// wrapped in a big loop
void update_text()
{
    std::stringstream ss; // this gets called again and again
    ++i;
    ss << i;
    text = new_text(ss.str()); // text and new_text are defined elsewhere
    show_text(text); // so is this
}

does is create a new instance of ss in the stack with a new address and everything? would it be smarter to use sprintf with a char array?

Answer 1

Each time the function is called, a new, local, instance of std::stringstream ss is pushed upon on the stack. At the end of the function, this instance is destroyed and popped off the stack.

At no point in time does the scope of function update_text have multiple variables in its scope with the identifier ss. So, within the scope of update_text, there is only one ss identifier.

A character array would make no difference. Each time the function is called, the char array, if statically allocated, will be pushed onto the stack and popped off at the end. If you use dynamic memory and dynamically allocate the character array, the new and delete statements would still be executed each time the function was called, and the pointer to this character array would still be pushed and popped off the stack. The std::stringstream is already handling the new and delete for you internally.

Declaring an object multiple times would look like this:

void Function()
{
    int x;
    int x;
}

This would cause compiler errors.

Be warned, this however, is valid:

void Function()
{
    int x;
    if(true)
    {
        int x;
    }
}

Because the two variables are of different scopes. The second x exists only within that if statement. As such, the compiler can infer that any reference to x after that declaration and within that scope refers to the second x. Note that the type doesn’t matter, it’s the identifier or “name” that matters.