使用extern "C" __declspec(dllexport)导出C++函数时参数损坏问题

Alright, let's dig into this parameter corruption issue you're hitting—when you pass "None Stay" as cmdLine, the first four bytes get overwritten with random stuff like 'su\0...' after reinterpret_cast and calling an exported function in Release mode. This is a super common pitfall with Windows DLL exports, so I’ve got a few solid leads to fix this:

1. Fix Mismatched Calling Conventions #

This is the #1 cause of parameter corruption in exported functions, especially in Release mode where compiler optimizations amplify the issue.

• Windows compilers default to different calling conventions depending on project settings: __cdecl for most C/C++ code, __stdcall for Win32 APIs. If your exported function uses one convention and the caller expects another, the stack frame gets messed up, and parameters get overwritten.
• Fix it by explicitly declaring the same calling convention for both the export and the caller:

  // In your header (shared between export and caller files)
  extern "C" __declspec(dllexport) void __stdcall ProcessCommand(const char* cmdLine);
  
  // In the export .cpp file
  extern "C" __declspec(dllexport) void __stdcall ProcessCommand(const char* cmdLine) {
      // Your logic here
  }
  
  // In the caller .cpp file
  extern "C" __declspec(dllimport) void __stdcall ProcessCommand(const char* cmdLine);
  

2. Stop Misusing reinterpret_cast #

If you're casting a function pointer to an incompatible type (e.g., dropping the calling convention from the pointer type), you're triggering undefined behavior. Release mode optimizations will turn that undefined behavior into parameter corruption fast.

• Fix it by making sure your function pointer type matches exactly, including the calling convention:

  // Correct: Match the exact function signature and calling convention
  using CmdProcFunc = void(__stdcall*)(const char*);
  CmdProcFunc func = reinterpret_cast<CmdProcFunc>(GetProcAddress(hModule, "ProcessCommand"));
  

  Never skip the calling convention in the pointer type—this is a silent killer in Release builds.

3. Fix C++ Name Mangling #

C++ compilers mangle function names to support overloading, but this breaks DLL exports if the caller isn't expecting the mangled name. If you're not using extern "C", you might be linking to the wrong function entirely, leading to parameter misalignment.

• Fix it by wrapping your export and caller declarations in extern "C" to enforce C-style (unmangled) symbol names:

  // Export side
  extern "C" __declspec(dllexport) void ProcessCommand(const char* cmdLine);
  
  // Caller side
  extern "C" __declspec(dllimport) void ProcessCommand(const char* cmdLine);
  

  This ensures both sides are referencing the exact same symbol name, no surprises.

4. Check for Release Mode Optimization Side Effects #

Release mode's aggressive optimizations (like O2, stack alignment, or register reuse) can expose hidden bugs in your code that Debug mode ignores. For example, if your cmdLine is stored in a stack buffer that gets reused before the function call completes, it'll get overwritten.

• Test temporarily by disabling optimizations for the problematic function to see if the issue goes away:

  #pragma optimize("", off)
  extern "C" __declspec(dllexport) void ProcessCommand(const char* cmdLine) {
      // Your logic here
  }
  #pragma optimize("", on)
  

  If this fixes it, you've got a hidden bug in your code—look for things like out-of-bounds array access, dangling pointers, or stack variables being reused too early.

5. Ensure Stable Memory for cmdLine #

If you're passing a stack-allocated string as cmdLine, Release mode might optimize the stack space and overwrite the string before the exported function uses it.

• Fix it by using stable memory for the command line:

  // Bad: Stack buffer might get overwritten in Release mode
  void Caller() {
      char cmdBuf[] = "None Stay";
      ProcessCommand(cmdBuf);
  }
  
  // Good: Use a std::string (heap-backed, stays alive during the call)
  void Caller() {
      std::string cmdStr = "None Stay";
      ProcessCommand(cmdStr.c_str());
  }
  

  Just make sure the string object doesn't go out of scope before the function call finishes.

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