Память в DLL и вне ее

dll = LoadLibrary("Dll.dll");
memfunc m = (memfunc)GetProcAddress(dll,"make_array");
int * a = m(5);
for(int i = 0; i < 5; ++i) cout << a[i] << " "; cout << endl;
FreeLibrary(dll);
for(int i = 0; i < 5; ++i) cout << (a[i] *= a[i]) << " "; cout << endl;
dll = LoadLibrary("Dll.dll");
m = (memfunc)GetProcAddress(dll,"make_array");
for(int i = 0; i < 5; ++i) cout << (a[i] *= a[i]) << " "; cout << endl;
delete[] a;
a = m(6);
for(int i = 0; i < 5; ++i) cout << a[i] << " "; cout << endl;

Первое, что нужно знать - это рантайм. В случае с студией, есть MD и MT. В первом случае используется общий рантайм. И если в одной длл создать класс, а в другой удалить - все будет работать как ожидается. Если же рантайм у каждого свой - тут сложнее. Если создать в одном месте, а удалить в другом, то может отработать (если менеджер память достаточно умный), может отработать, но упадет потом (если длл и программа используют одинаковый рантайм), а может и сразу упасть (если рантаймы различны).

Как приложение работает с памятью? Обычно диспетчер памяти (который является частью рантайма), запрашивает о операционной системы большой кусок памяти (4Мб или даже 64Мб) и внутри него уже "нарезает" под мелкие объекты, которые создаются с помощью new/malloc. Когда приложение выгружается, эта память отдается назад операционной системе.

но при выгрузке DLL, как я понимаю, эта область остается не освобожденной?

если рантайм динамический, то менеждер памяти общий. И этой памятью заведует само приложение.

Если же используется статический рантайм, то тут все за программистом и рантаймом. Длл знает о том, что её выгружают и "должна" освободить память.

Как реально работать с такими вещами, как интеллектуальные указатели?

умные указатели в этом случае хорошие помощники. Нужно только убедиться, что у них правильно прописан "custom deleter" (даже не знаю, как это на русском - пользовательский удалятор? или пользовательская функция удаления?). В этом случае будет вызвана правильная функция в правильном менеждере памяти (в любом случае, у программиста есть возможность все сломать).

Но если DLL от OW, а программа от VC++ - то работает все, кроме delete[]. Как, само собой, и следовало ожидать - из-за разных диспетчеров памяти.

тут ситуация хитрая. когда вызывается delete[], то менеджер памяти должен знать, сколько удалять памяти. И где то это количество нужно сохранить. И я точно знаю, что студия и gcc используют различные, несовместимые модели. Поэтому, если такой указатель передать между длл с различными менджерами, может быть абсолютно все, что угодно.

Смотрите.

Проблема в том, что у C++ нету бинарного стандарта. Это значит, что один и тот же класс при компиляции разными компиляторами (да что там, даже при компиляции одним и тем же компилятором с разными флагами) может иметь разный бинарный layout. Может быть разное представление таблицы виртуальных методов, разная декорация имён методов, да просто разный физический размер. Поэтому передача между компонентами, скомпилированными разными компиляторами или разными версиями одного и того же компилятора, чего-то сложнее, чем простые структуры, закономерно может привести к проблемам и топтанию по чужой памяти. И в сложных случаях имеет смысл указывать #pragma pack.

Это объясняет, почему в экспортируемых из DLL заголовочных файлах часто встречается extern "C".

Если DLL гарантированно скомпилирована той же версией компилятора с теми же ключами, в этом случае передавать объекты можно. Но это сразу же вносит проблемы с версионированием: обновление компонент возвращает проблему.

Это объясняет, почему не получится передавать объекты по смарт-указателю, если в проекте не все DLL скомпилированы той же версией компилятора. (А также почему системные DLL не используют смарт-указатели, исключения и другие фичи C++.)

Далее, о проблеме принадлежности памяти. Эта часть Microsoft-специфическая. Компиляция DLL имеет режимы со статической и динамической компоновкой рантайм-библиотеки.

В случае статической компоновки рантайма у вас есть своя реализация new и delete в каждой DLL, они друг о друге не знают ничего, и обладают непересекающимися heap'ами. Это значит, что вы должны обеспечить, чтобы объект деаллоцировался тем же рантаймом, который его аллоцировал.

В случае динамической компоновки рантайма, у вас есть один рантайм на приложение — но только в случае, когда ваше приложение скомпилировано одной и той же версией студии! В этом хорошем случае вы можете аллоцировать объект в одной DLL, и деаллоцировать в другой. В плохом случае, когда у вас разные DLL скомпилированы разными версиями студии, они ссылаются на разные версии рантайм-библиотеки, и в этом случае у вас в бегущей программе будет по одному рантайму на каждую версию студии, с которой компилировались её DLL. С очевидными последствиями.

Вот тут это, по моему, хорошо освещается:

1. Семантика симметрического владения. Если DLL возвращает указатель на динамически выделенный участок памяти, то пользователь должен вызвать соответствующий деаллокатор для этого.

Само собой, если они не будут совпадать то будет проблема - для этого случая рекомендуется использовать функции для аллокации и деаллокации выделенных участков памяти в загружаемой библиотеке (dll->free() или dll->freeArray())

2. Гибкость. Если пользователь захочет выделять память в другом месте - не обязательно в heap а где-то еще.

То есть, в итоге передавая указатель НА ПАМЯТЬ в функцию DLL с уже выделенной памятью будет лучше чем выделять память в самой DLL.