24#endif
25
26// Create a boolean used to handle a SIGINT and exit gracefully.
27volatile sig_atomic_t bMainStop = false; 28
29/******************************************************************************
30 * @brief Help function given to the C++ csignal standard library to run when 16// If not included, define empty run example function and set bRunExampleFlag
17// to false. If included, then define bRunExampleFlag as true.
18#ifndef CHECK_IF_EXAMPLE_INCLUDED
19static bool bRunExampleFlag = false; 20
21void RunExample() {}
22#else34
35 // RoveComm Status:
36 extern bool g_bRoveCommUDPStatus;
37 extern bool g_bRoveCommTCPStatus;38} // namespace network
39
40#endif // AUTONOMY_NETWORKING_H33 extern rovecomm::RoveCommTCP* g_pRoveCommTCPNode; // Global RoveComm TCP Instance.
34
35 // RoveComm Status:
36 extern bool g_bRoveCommUDPStatus;37 extern bool g_bRoveCommTCPStatus;
38} // namespace network
3930{
31 // RoveComm Instances:
32 extern rovecomm::RoveCommUDP* g_pRoveCommUDPNode; // Global RoveComm UDP Instance.
33 extern rovecomm::RoveCommTCP* g_pRoveCommTCPNode; // Global RoveComm TCP Instance.34
35 // RoveComm Status:
36 extern bool g_bRoveCommUDPStatus;Global variables are accessible anywhere in the scope of the program even in the threads outside of the main thread, as long as it shares the main process stack.
A mutable global variable have high dependency and the dependent code on such variables have no way to learn about the changes to the variable. Hence using a non-const global variables is considered quite risky, as they can lead to data races or contention issues.
Consider avoiding the use of global variable by adding a qualifier const. If
the variable must be mutable then consider passing the variable as argument to
the functions which are designed to mutate the variable.
In the case of atomic or synchronization primitives being used to handle data races, there is still concern about misuse, which can be reduced by making it non-global. That is a private class member that can only be used by its function.
Consider passing references to unique values and then merging them as if you need mutable stack of program memory.
Note that const pointers and pointer to const are not the same. You need a global pointer to be entirely const for this lint to be satisfied.
That is, if you are passing a pointer, then you need to make sure that the pointer is a const pointer to a const. (See here for more information.)
const int *p = &x;
// should instead be
const int *const p = &x;
Bad practice
std::atomic<bool> flag(false);
int global_counter = 0;
void foo() {
global_counter += 1;
flag.store(true);
}
int main() {
global_counter += 1;
std::thread t(foo);
flag.store(false); // there won't be a data race,
// but the output can still be unexpected as we
// don't know which mutation will occur last
t.join();
}
Recommended
#include <thread>
int main() {
int global_counter = 1;
int global_counter1 = 0;
std::atomic<bool> flag(false);
std::thread t1([&](){
for (int i = 0; i < 10; i++) {
global_counter1 += 1;
flag.store(true);
}
});
int global_counter2 = 0;
std::thread t2([&](){
for (int i = 0; i < 10; i++) {
global_counter2 += 1;
flag.store(false);
}
});
t1.join();
t2.join();
// we again don't know which one executed
// last but we know nothing else but things
// from this scope can use it making
// debugging easier
global_counter += global_counter1 + global_counter2;
}