CERT C++: ERR58-CPP

This issue occurs when an exception might arise during the construction of global and static variables before main() begins executing. If an exception is raised during the startup phase, you cannot write an exception handler that the compiler can execute to handle the raised exception. This exception becomes an unhandled exception. For instance, you might implement main() as a function-try-catch block to handle exceptions. None of the catch blocks can handle exceptions raised during the startup phase and these raised exceptions become unhandled exceptions.

When you invoke callable entities to initialize or declare global or static variables, these entities are executed during program startup. Polyspace^® checks whether these entities might raise exceptions during program startup by making certain assumptions.

Polyspace ignores:

Polyspace also ignores the dynamic context when checking for exceptions. For instance, you might initialize a global or static variable by using a function that raises exceptions only in a certain dynamic context. Polyspace flags such a declaration even if the exception might never be raised. You can justify such a violation by using comments in Polyspace.

When exceptions are not handled, the compiler might abnormally terminate the code execution without unwinding the stack depending on the set of hardware and software that you use. Consider this code where the construction of the static object obj might cause an exception.

class A{
	A(){throw(0);}	
};

static A obj;

main(){
	//...
}

Avoid operations that might raise an exception in the parts of your code that might be executed before startup or after termination of the program. For instance, avoid operations that might raise exceptions in the constructor and destructor of static or global objects.

Consider this code where the construction of the global pointer arr requires dynamic memory allocation.

#include <stdexcept>
void* alloc(size_t s) noexcept {          
	return new int[s];
}
int* arr = (int*)alloc(5);//Noncompliant
int main(){
	//..
	return 0;
}

Dynamic memory allocation by using the new operator can raise an exception. Because constructing arr can raise an exception before main() begins execution, Polyspace flags the declaration.

Avoid operations that might raise exception when constructing global objects. For instance, you can initialize the global pointer arr by using a nullptr. Then allocate memory for arr in main() in a try-catch code block.

#include <stdexcept>
#include<vector>
void* alloc(size_t s) noexcept {          
	return new int[s];
}
int* arr =nullptr;
int main(){
	try{
		arr =  (int*)alloc(5);	
	}
	catch(std::bad_alloc e){
		//..
	}
	//..
	return 0;
}

In this case, the dynamic memory allocation operation raises the std::bad_alloc exception in main() where it can be handled by the catch blocks of code.