Crash happens when Multi-threaded Debug (/MTd) is set (C++) - c++

Question

When building a dynamic library (in C++), we can select Multi-threaded Debug (/MTd) or Multi-threaded Debug DLL (/MDd) run time library for Windows. If we select Multi-threaded Debug, then the created dynamic library will be in charge of memory allocation for all the variables that are used in the library. Therefore, the following example will show a case where /MDd setting will work while /MTd setting will fail:
my_dll.h
class MY_EXPORT DllClass
{
public:
std::vector<int> abcWorkable;
void create_new_input_workable();
};
my_dll.cpp
void DllClass::create_new_input_workable()
{
abcWorkable.push_back(3);
abcWorkable.push_back(4);
}
main.cpp
int main(void)
{
DllClass mine;
//mine.abcWorkable.reserve(20);
mine.create_new_input_workable();
return 0;
}
There are two work-around solutions to this problem: one is using static library rather than the dynamic one and the other is to allocate memory only in the dynamic library or the executable, for example if we change main.cpp:
int main(void)
{
DllClass mine;
mine.abcWorkable.reserve(20);
mine.create_new_input_workable();
return 0;
}
It will work as this time the variable std::vector<int> abcWorkable is allocated memory in the executable program. However, if the variable insider the class (in the dll) is difficult to allocate memory in the executable, then this solution may fail. I also take another example:
my_dll.h
class MY_EXPORT DllClass
{
public:
std::list<std::vector<int> > myContainer;
void create_new_input();
}
my_dll.cpp
void DllClass::create_new_input()
{
std::vector<int> abc;
abc.push_back(2);
abc.push_back(3);
myContainer.push_back(abc);
}
main.cpp
int main()
{
DllClass mine;
mine.create_new_input();
std::list<std::vector<int> >::iterator it = mine.myContainer.begin();
std::list<std::vector<int> >::iterator itEnd = mine.myContainer.end();
while(it != itEnd)
{
for(int i=0; i<(*it).size(); i++)
std::cout<<(*it)[i]<<std::endl;
it++;
}
return 0;
}
It is impossible to allocate memory before hand for the variable std::list<std::vector<int> > myContainer, then my question is how I can deal with this situation? (Except using static library) Thanks.

Answer 1

When you build with /MT then every module will have its own copy of the CRT. With its own global variables like errno and its own memory allocator that uses its own heap. The final program will run with multiple CRT copies.
This is very troublesome, particularly with your code. Because you return an std::string by value from the DLL. Which was allocated on the heap that the CRT copy that the DLL uses. This object needs to be released again by the caller. But it uses a different heap and cannot possibly release the object. Kaboom.
Using /MD is a hard requirement here. Which ensures that every module uses the same CRT copy and only a single implementation is present in the final program. As long as they were built with the same CRT version anyway.