Thread: running code EXACTLY once

How can I guarantee it runs code only once?

using static and an if statement doesn't count.

one line...

such as this:

Code:

void func1()
{
         //code
        FlushConsoleInputBuffer(
		hStdin   // handle to console input buffer
	); // ONLY RUN THIS ONE TIME, even if called multiple times
         // more code
}

Originally posted by Trauts
using static and an if statement doesn't count.

Ignoring that...

What is the difference between a static function and a non static?

I know what a static variable does... but not what the function would do.

Originally posted by Prelude
It's a trick that saves you from using more awkward methods.

i.e. global variables

Sorry if I'm bumping an age-old thread, I actually meant to reply to this a while ago, but wasn't at my computer when I thought of this solution, and I forgot until now. Using an "if" is NOT required in this method; using a static variable is. As you said you can't use the static AND an if, this follows the letter of the law.

The secret is to do your code WITHIN the initialization of a static variable within a function, because that is guaranteed to happen exactly once, the first time the function happens.

Code:

void function(){
    static int i = (
        std::cout << "This is really long" <<std::endl,
        std::cout << "Note it uses commas" <<std::endl,
        std::cout << "And not semicolons!" <<std::endl,
        std::cout << "It's only done once" <<std::endl,
        0); // we end with something we can instantiate i with
    std::cout << "We always do this!" << std::endl;
}

Here, we use the parentheses to force an order of operations (otherwise, it would try to initialize i with an &ostream, which won't work.) We want to do all the comma operations first, then the initialization.

You notice there are no semicolons; this is ONE expression. It uses the comma operator four times.

So long as the very last thing in our chain of comma operators is something that can legally instantiate an integer, it's OK. You could put as many lines as you like in there, and there is no limit on what can go in the middle of the chain, just make sure the very last thing is an integer.

The nice thing about this is that it happens in the scope of the function, so you can use all the variables of the function. You could also do:

static int i = function2(/*parameters*/);

where function 2 accepts/modifies the necessary variables via parameter list, and returns an int.

Output of calling the above code five times would be:

This is really long
Note it uses commas
And not semicolons!
It's only done once
We always do this!
We always do this!
We always do this!
We always do this!
We always do this!

originally posted by Cat

Code:

void function(){
    static int i = (
        std::cout << "This is really long" <<std::endl,
        std::cout << "Note it uses commas" <<std::endl,
        std::cout << "And not semicolons!" <<std::endl,
        std::cout << "It's only done once" <<std::endl,
        0); // we end with something we can instantiate i with
    std::cout << "We always do this!" << std::endl;
}

This is probably beside the point, but why do you need the
std:: in front of cout here. It appears to me that this is not always needed.