如何处理静态存储持续时间警告？

Question

I'm a total newbie trying to learn C++ from a book. The code below works and produces output as expected, but there are warnings on the two lines that define engine and randomInt : "Initialization of 'engine' with static storage duration may throw an exception that cannot be caught."

If I put lines 7 and 8 inside of main() , the warnings completely go away, but then engine and randomInt are not available to getNumber .

I don't know how to fix the warnings. Also, perhaps more importantly, what is the proper approach for using randomInt in various places besides main() ? Is it proper to declare it in main() then pass it to functions as needed? Somehow main() doesn't feel like the proper spot to be declaring these types of things.

I asked a question similar to this one earlier, but I'm still struggling to understand, and have provided an example that's hopefully useful.

// Loosely based on Fig. 6.12: fig06_12.cpp, C++ How To Program, Ninth Edition

#include <iostream>
#include <iomanip>
#include <random>

std::default_random_engine engine( static_cast<unsigned int>( time(nullptr) ) );
std::uniform_int_distribution<unsigned int> randomInt( 1, 6 );

int getNumber();

int main() {
    for ( unsigned int counter = 1; counter <= 10; ++counter ) {
        std::cout << std::setw( 10 ) << randomInt( engine );
        if ( counter % 5 == 0 )
            std::cout << std::endl;
    }
    std::cout << getNumber() << std::endl;
    return 0;
}

int getNumber () {
    return randomInt( engine );
}

Output:

/CLionProjects/Warning/cmake-build-debug/Warning
         3         5         6         3         3
         1         4         2         4         5
2

Process finished with exit code 0

Answer 1

One way to defer initialization of global variables such as the ones you are using is to wrap them in get -functions.

std::default_random_engine& getEngine()
{
   // Initialized upon first call to the function.
   static std::default_random_engine engine(static_cast<unsigned int>(time(nullptr)));
   return engine;
}

std::uniform_int_distribution<unsigned int>& getRandomInt()
{ 
   // Initialized upon first call to the function.
   static std::uniform_int_distribution<unsigned int> randomInt(1, 6);
   return randomInt;
}

and then use getEngine() and getRandomInt() instead of using the variables directly.

Answer 2

Using global variables is problematic, and it is common wisdom to avoid them unless they're absolutely necessary. For details, see:

Are global variables bad?

your question title also regards non-global-scope static storage duration variables (eg static locals of functions); these are less problematic but can also give you some headaches, especially in multi-threaded work.

Bottom line: It's best to make your functions depending only on their parameters and have as few side-effects as is necessary. Let's do this with your getNumber() function:

template <typename Distribution>
typename Distribution::result_type getNumber (
    std::default_random_engine&  random_engine,
    Distribution&                distribution) 
{
    return distribution( random_engine );
}

int main()
{
    std::default_random_engine engine( static_cast<unsigned int>( time(nullptr) ) );
    std::uniform_int_distribution<unsigned int> randomInt( 1, 6 );

    for ( unsigned int counter = 1; counter <= 10; ++counter ) {
        std::cout << std::setw( 10 ) << randomInt( engine );
        if ( counter % 5 == 0 )
            std::cout << std::endl;
    }
    std::cout << getNumber( engine, randomInt ) << std::endl;
    return 0;
}

Answer 3

I agree with the other answers that global objects are problematic.

However your question is specifically about initialization of global variables that can throw an exception and, in turn, that there is no C++ scope that can catch this exception (that I know of). (This warning is cert-err58-cpp in clang-tidy static analyzer.)

Another less know solution that worked in my experience is, if you can control the constructor of the class used as global, to make the constructor(s) invoked noexcept .

I think it has some advantages:

First, this forces you to think if you can avoid doing operations that can fail (eg allocation or open a file)

struct TypeUsedAsGlobal {
    explicit TypeUsedAsGlobal(int n) noexcept {
        ... // body of the constructor that cannot fail
    } catch(...) {}
...
};

and, second, if you cannot avoid them it will force you to handle the error in the constructor itself.

struct TypeUsedAsGlobal {
    explicit TypeUsedAsGlobal(int n) noexcept try : m_{n} {
        ... // body that can fail
    } catch(...) {
        ... // handle the error
        ... // cleanup as much as you can
        ... // print a message, and most likely std::terminate
    }
...
};

( try/catch can have smaller scope I think).

All things considered, this is not that bad, specially if the type is only used for global objects (not in scopes), because well, what can you do if a global object that is (hopefully) fundamental to the whole program cannot be constructed in the first place? (eg because a file doesn't exist or if the resource that the global object represent is not really there or sufficient to the logic of the program.)

The benefits of this approach relative to the function with static variable is that your program fails right away and not after the first use of the global object an hour later. Of course it is not clear in general that one approach is better than the other, it depends.

---

As a final note : it is a bad idea to have a global random number generator. Generators should be created when needed or passed down. It is not safe to call the random number generator/distribution from different threads, but more importantly (mathematically) the reason is that you have to control the lifetime and state of the generators very carefully.

There is no one other to blame here than the authors of the book you are using, notorious for their bad practices.

See here for good alternatives The Definitive C++ Book Guide and List