C Runtime Library issue MD/MDd

We have a C library that we want to distribute, alongside C example code.

The library is of course built in release mode. The example code project is in cmake so that it can be easily run on both Linux and Windows. On Linux (debug and release) as well as on Windows (release), we have no issue. However, on Windows (debug), we have an issue when leaving the main : the program triggers an assertion:

Invalid address specified to RtlValidateHeap
Expression: _CrtIsValidHeapPointer(block)

Then when continuing the process, it raises the following exception:

Unhandled exception at [...] (ntdll.dll)
0xC000000D STATUS_INVALID_PARAMETER

As this seemed related to runtime library, we tryed changing it from MDd (multithreaded dll debug) to MD (multithreaded dll) [ more on these here ] and it solved the issue. However, this seems like a work around rather than a fix: the release library (built with MD) should be usable in a debug program using MDd, right?

As we understand it, conflicts in runtime library only appears when allocation is made in the caller and deallocation is made in the callee or vice-versa. So we tracked all allocations to check them and everything seems ok. We ran leak detections on the example code in both Linux (Valgrind) and Windows (CrtDbg) but they didn't find any leak, everything seems fine.

Is it right to expect a release library built with MD to run in an MDd program? If not, it seems strange: libraries are always distributed in release, yet used in debug solutions while developing... If yes, what can cause the issue?

It sounds more like a heap corruption than a leak. It implies someone is overwriting the heap (passed its allocated memory). Finding it can be pain in the but.

First, check your example code. Strip it down to the bare minimum "hello world" and then build it up until it happens again. Then check the example code. If it is not the example code, check which library functions were called and code-review those.

As an aid, you can use the MS heap check functions. place them at function entry and function exit, or maintain global versions that you regularly check. The following is an example:

#include <crtdbg.h>

void example(void)
{
    _CrtMemState memStateStart, memStateEnd, memStateDelta;

    // Make a checkpoint of the heap's state so we can later check the heap is still OK
    _CrtMemCheckpoint( &memStateStart );
    //
    // do your things
    //
    // Check the heap
    _CrtMemCheckpoint( &memStateEnd );
    _CrtSetReportMode( _CRT_WARN,   _CRTDBG_MODE_WNDW );
    _CrtSetReportMode( _CRT_ERROR,  _CRTDBG_MODE_WNDW );
    _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_WNDW );
    if (_CrtMemDifference( &memStateDelta, &memStateStart, &memStateEnd ))
        _CrtMemDumpStatistics( &memStateDelta );
    _CrtDumpMemoryLeaks();
}