Question

I’m aware that undefined behavior can potentially cause anything, which makes any program containing UB potentially meaningless. I was wondering if there is any way to identify the earliest point in a program that undefined behavior could cause problems.
Here is an example to illustrate my question.

void causeUndefinedBehavior()
{
   //any code that causes undefined behavior
   //every time it is run
   char* a = nullptr;
   *a;
}


int main()
{
 //code before call
 //...
 causeUndefinedBehavior();
 //code after call
 //...
}

From my understanding, the possible times undefined behavior could be evoked (not necessarily manifested) are:

1. When causeUndefinedBehavior() is compiled.
2. When main() is compiled.
3. At the time the program is run.
4. At the time causeUndefinedBehavior() is executed.

Or is the point where undefined behavior is evoked completely different for every case and every implementation?

In addition, if I commented out the line where causeUndefinedBehavior() is called, would that eliminate the UB, or would it still be in the program since code containing UB was compiled?

Answer 1

As your code somewhat demonstrates, undefined behavior is almost always a condition of runtime state at the time the behavior is attempted. A slight modification of your code can make this painfully obvious:

void causeUndefinedBehavior()
{
   //any code that causes undefined behavior
   //every time it is run
   char* a = nullptr;
   *a;
}


int main()
{
 srand(time(NULL));
 //code before call
 //...
 if (rand() % 973 == 0)
    causeUndefinedBehavior();
 //code after call
 //...
}

You could execute this a thousand times or more and never trip the UB execute-condition. that doesn’t change the fact the function itself is clearly UB, but detecting it at compile time in context of the invoker is not trivial.