Question

Does there exist any implementation of C++ (and/or C) that guarantees that anytime undefined behavior is invoked, it will signal an error? Obviously, such an implementation could not be as efficient as a standard C++ implementation, but it could be a useful debugging/testing tool.

If such an implementation does not exist, then are there any practical reasons that would make it impossible to implement? Or is it just that no one has done the work to implement it yet?

Edit: To make this a little more precise: I would like to have a compiler that allows me to make the assertion, for a given run of a C++ program that ran to completion, that no part of that run involved undefined behavior.

Answer 1

Yes, and no.

I am fairly certain that for practical purposes, an implementation could make C++ a safe language, meaning every operation has well-defined behavior. Of course, this comes at a huge overhead and there is probably some cases where it’s simply unfeasible, such as race conditions in multithreaded code.

Now, the problem is that this can’t guarantee your code is defined in other implementations! That is, it could still invoke UB. For instance, observe the following code:

int a;
int* b;

int foo() {
  a = 5;
  b = &a;
  return 0;
}

int bar() {
  *b = a;
  return 0;
}

int main() {
  std::cout << foo() << bar() << std::endl;
}

According to the standard, the order that foo and bar are called is up to the implementation to decide. Now, in a safe implementation this order would have to be defined, likely being left-to-right evaluation. The problem is that evaluating right-to-left invokes UB, which wouldn’t be caught until you ran it on an unsafe implementation. The safe implementation could simply compile each permutation of evaluation order or do some static analysis, but this quickly becomes unfeasible and possibly undecidable.

So in conclusion, if such an implementation existed it would give you a false sense of security.