What is the standard approach for implementing a one-time Boolean switch?

Question

Let's say I have some code like the following, and that processData gets executed hundreds or even thousands of times per minute:

class DataProcessor {
private:
    DataValidator* validator;
    bool atLeastOneDataPoint;
    bool dataIsValid(Data* dataToValidate) {
        return validator->validate(dataToValidate);
    }

public:
    // ...

    void processData(Data* dataToProcess) {
        if (dataIsValid(dataToProcess) || !atLeastOneDataPoint) {
            // process data
            // ...
            atLeastOneDataPoint = true;
        }
    }

    // ...
}

As can be inferred from its name, atLeastOneDataPoint is a variable that really only needs to get set once, yet in the code above it is set every single time processData is called after the first data point. Naturally, I could change the assignment line to this:

if (!atLeastOneDataPoint) atLeastOneDataPoint = true;

But that would simply replace a bunch of unnecessary assignments with a bunch of unnecessary Boolean checks.

I'm not concerned about the performance of this code; really I'm just bothered by the idea of doing something so totally unnecessary. Is there a standard way of setting one-time switches such as this, that is more intuitively "proper" in design?

As for whether or not even caring about this makes me a bad programmer: let's leave that discussion for another day, please.

Answer 1

Callbacks

first register a function called "call_once_at_init()", and this function will register "call_always_after_init()" for use afterwards.

Answer 2

I'd say what you've already got is the best way: just set the boolean flag on every iteration.

If you're not concerned about performance, I think this is the most readable solution: it's nice and obvious what's going on - I've processed a valid data point, so I set the flag to true.

Even if performance is a concern, I think you'd struggle to find any operation that's more efficient than setting a single boolean to true.

Answer 3

provide you dont use atLeastOneDataPoint as a first flag in process data

void processData(Data* dataToProcess) {
   if ( (atLeastOneDataPoint = (dataIsValid(dataToProcess) || !atLeastOneDataPoint) ) ) {
      // process data
      //...
   }
}

but 10000 per minute is nothing - worry when its 1.5 million per second

Answer 4

Isn't this what you want?

void processData(Data* dataToProcess) {
    if (!atLeastOneDataPoint) atLeastOnedataPoint = true;
    if (dataIsValid(dataToProcess)) {
        // process data
        // ...
    }
}

This is only actually doing atLeastOnedataPoint = true once.

Even if it were doing it every time, doing if (!atLeastOneDataPoint) atLeastOnedataPoint = true; should take less than 100 ns (probably a lot less). Even at 100 ns, if you do it 1000 times in one minute, it is consuming 100us = 0.1ms out of that minute.

I bet you have "bigger fish to fry".