调用全局引用的函数时触发Access violation异常，求排查解决

Hey there, let’s break down what’s likely causing that access violation when using your global reference to call foo(), and walk through fixes while comparing against your other working scenarios.

Common Causes & Corresponding Fixes #

1. Undefined Global Initialization Order #

This is the most frequent culprit here. In C++, the initialization order of global variables across different translation units (.cpp files) is not guaranteed.

For example:

• If your global reference void (*global_foo)() = foo; lives in main.cpp, but foo() is defined in foo.cpp, the compiler might initialize the global reference before foo’s address is properly resolved. This leaves global_foo pointing to invalid memory, triggering an access violation when you try to call it.

Compare this to your working scenarios:

• Holder类静态成员存储直接引用: Class static members either initialize at program startup (if constexpr/inline) or on first class access (lazy initialization, depending on compiler settings). This usually avoids cross-translation-unit initialization order chaos.
• Holder类存储静态引用的引用/副本: These rely on Holder’s already-initialized static member, which has far more predictable timing.

Fix:

• Wrap the global reference in a function to enforce lazy initialization:

  void (*get_global_foo())() {
      static void (*global_foo)() = foo;
      return global_foo;
  }
  

  Now global_foo initializes the first time you call get_global_foo(), ensuring foo’s address is valid.
• Alternatively, mark foo as inline (if it’s a global function) to let the compiler resolve its address earlier.

2. Accidental Corruption of the Global Reference #

Access violations can also pop up if the memory holding your global reference gets overwritten by an out-of-bounds write elsewhere in code. For example, a buffer overflow in an unrelated function could clobber global_foo’s value, making it point to an invalid memory region.

Fix:

• Use your debugger to set a watchpoint on the global reference variable. This will pause execution whenever the variable’s value changes, letting you track down the source of corruption.
• Make the global reference const if you don’t need to modify it later:

  void (*const global_foo)() = foo;
  

  This turns accidental writes into compile-time errors instead of runtime crashes.

3. foo Lives in a Dynamic Link Library (DLL) #

If foo() is in a DLL loaded dynamically (not statically linked), your global reference might initialize before the DLL maps into the process’s address space. The stored function address will be invalid until the DLL finishes loading.

Fix:

• Initialize the global reference after the DLL loads. For example, if using LoadLibrary, set global_foo with GetProcAddress right after loading the library.
• Avoid storing DLL function addresses in global variables; retrieve them dynamically when needed instead.

Quick Recap of Your Working Scenarios #

To clarify why the other methods work smoothly:

• Holder静态成员直接引用: Predictable initialization timing avoids cross-unit order issues.
• Holder存储静态引用的引用: Points to a valid, already-initialized static member of Holder.
• Holder存储静态引用的副本: Copies a valid address from Holder’s safely initialized static member.

内容的提问来源于stack exchange，提问作者Nighteen