STL跨DLL使用

今天在写一个函数，需要将map作为一个引用参数传入函数体内部进行赋值，结果编译通过，执行时总是崩溃，在网上找到了一些作者写的blog，详细解释了这种情况发生的原因，特转载在这里，便于自己今后查询。

原文1：有一个功能模块, 本来是写在主程序当中. 现在觉得有必要将它写成一个 DLL. 于是开始代码的移植. 费了好大的劲. 终于移植完成, 通过编译了. 这时运行程序, CRASH!
调试之, 发现是在一个 map 的赋值出现了问题.
看 vc6 自带的 STL 的代码:

map 的赋值操作, 也就是其中的树赋值操作.
_Myt& operator=(const _Myt& _X)
{
    _Tr = _X._Tr;
    return (*this);
}

树的赋值操作:
_Myt& operator=(const _Myt& _X)
{
    if (this != &_X)
    {
        erase(begin(), end());
        key_compare = _X.key_compare;
        _Copy(_X);
    }
    return (*this);
}
先删除自己, 然后调用 _Copy(const _Myt&);

void _Copy(const _Myt& _X)
{
    _Root() = _Copy(_X._Root(), _Head);
    _Size = _X.size();
    if (_Root() != _Nil)
    {
        _Lmost() = _Min(_Root());
        _Rmost() = _Max(_Root());
    }
    else
        _Lmost() = _Head, _Rmost() = _Head;
}

其中又调用了 _Copy(_Nodeptr, _Nodeptr);

_Nodeptr _Copy(_Nodeptr _X, _Nodeptr _P)
{
    _Nodeptr _R = _X;
    for (; _X != _Nil; _X = _Left(_X))      // error here
    {
        _Nodeptr _Y = _Buynode(_P, _Color(_X));
        if (_R == _X)
            _R = _Y;
        _Right(_Y) = _Copy(_Right(_X), _Y);
        _Consval(&_Value(_Y), _Value(_X));
        _Left(_P) = _Y;
        _P = _Y;
    }
    _Left(_P) = _Nil;
    return (_R);
}

看标记的那一行. _X 与 _Nil 比较. 其中的 _Nil 如下:
static _Tree<_K, _Ty, _Kfn, _Pr, _A>::_Nodeptr _Tree<_K, _Ty, _Kfn, _Pr, _A>::_Nil = 0;

是一个静态变量. 初始值为 0. 在一个 module (注: 这里的 module 是指的一个exe, 或者 dll. 下同) 中构建第一个 map 实例时, 有这样的代码:
                if (_Nil == 0)
                        {_Nil = _Buynode(0, _Black);
                        _Left(_Nil) = 0, _Right(_Nil) = 0; }

如果 _Nil 未初始化则创建一个 node, 初始化 _Nil. 然后 map 将内部的 _Head._Parent 指向这个 _Nil.

设想这样一种情形. 一个 EXE, 一个 DLL. 
                        
EXE:
void main()
{
 map m;
 func(m);
}

DLL:
void func(map& m)
{
 map n = m;
}

在 EXE 中构建了一个 map 实例. 然后传到 DLL 中做赋值操作.
分析执行过程, 首先 EXE 中的 m 初始化, 完成之后 m._Head._Parent  指向了一个 _Nil 节点. 然后这个 m 传到 dll 中. 此时, n 进行初始化, 又执行这样的代码:
                if (_Nil == 0)
                        {_Nil = _Buynode(0, _Black);
                        _Left(_Nil) = 0, _Right(_Nil) = 0; }

注意, 在 DLL 中, 这里的 _Nil 为 0. 因为这个 _Nil 和 EXE 中的 _Nil 并不是同一份拷贝. 因此又会创建一个 node, 然后让 _Nil 指向它. 再让 n._Head._Parent 指向这个 _Nil.
问题在这里开始出现了. map 的代码认为其所有的实例的 _Head._Parent 都指向同一个 _Nil. 但这里已经违背了这个原则.
最终的结果就是 crash. 在这个例子中, crash 出现在 _Copy(_Nodeptr, _Nodeptr) 函数中.

注：原作中还有示例代码

转载自：http://blog.csdn.net/arcoolgg/article/details/1769612

评论：

Great article!分析得很准确！
话说回来，个人意见：避免类似的错，是应该养成良好的风格。
1）避免引用调用，而改用Const引用调用。没有任何理由使用非const的引用调用。
2）如果要取得某个值，使用值返回。
3）任何跨越Module边界的内存操作（分配/释放/copy),都应该避免。(MAP 的实现就是以这个假设，_buyNode已经分配内存，即使没有_Nil的错，在EXE里最后map释放的时候，也可能会Crash)

回到示例，似乎改为这样，就应该毫无问题：
MapDLL.cpp:

intmap MAPAPI func()
{
intmap n ;
n.insert(pair&lt;int,int&gt;(1,2));
return n;
}

MapEXE:

void main()
{
intmap&amp; m = func();
}

原文2：STL跨平台调用会出现很多异常，你可以试试.

STL使用模板生成，当我们使用模板的时候，每一个EXE，和DLL都在编译器产生了自己的代码，导致模板所使用的静态成员不同步，所以出现数据传递的各种问题，下面是详细解释。

原因分析：
一句话-----如果任何STL类使用了静态变量（无论是直接还是间接使用），那么就不要再写出跨执行单元访问它的代码。 除非你能够确定两个动态库使用的都是同样的STL实现，比如都使用VC同一版本的STL，编译选项也一样。强烈建议，不要在动态库接口中传递STL容器！！

STL不一定不能在DLL间传递，但你必须彻底搞懂它的内部实现，并懂得为何会出问题。
微软的解释：
http://support.microsoft.com/default.aspx?scid=kb%3ben-us%3b172396
微软给的解决办法：
http://support.microsoft.com/default.aspx?scid=kb%3ben-us%3b168958

1、微软的解释：
大部分C++标准库里提供的类直接或间接地使用了静态变量。由于这些类是通过模板扩展而来的，因此每个可执行映像（通常是.dll或.exe文件）就会存在一份只属于自己的、给定类的静态数据成员。当一个需要访问这些静态成员的类方法执行时，它使用的是“这个方法的代码当前所在的那份可执行映像”里的静态成员变量。由于两份可执行映像各自的静态数据成员并未同步，这个行为就可能导致访问违例，或者数据看起来似乎丢失或被破坏了。

可能不太好懂，我举个例子：假如类A<T>有个静态变量m_s，那么当1.exe使用了2.dll中提供的某个A<int>对象时，由于模板扩展机制，1.exe和2.dll中会分别存在自己的一份类静态变量A<int>.m_s。
这样，假如1.exe中从2.dll中取得了一个的类A<int>的实例对象a，那么当在1.exe中直接访问a.m_s时，其实访问的是 1.exe中的对应拷贝（正确情况应该是访问了2.dll中的a.m_s）。这样就可能导致非法访问、应当改变的数据没有改变、不应改变的数据被错误地更改等异常情形。

原文：
Most classes in the Standard C++ Libraries use static data members directly or indirectly. Since these classes are generated through template instantiation, each executable image (usually with DLL or EXE file name extensions) will contain its own copy of the static data member for a given class. When a method of the class that requires the static data member is executed, it uses the static data member in the executable image in which the method code resides. Since the static data members in the executable images are not in sync, this action could result in an access violation or data may appear to be lost or corrupted.

1、保证资源的分配/删除操作对等并处于同一个执行单元；
   比如，可以把这些操作（包括构造/析构函数、某些容器自动扩容{这个需要特别注意}时的内存再分配等）隐藏到接口函数里面。换句话说：尽量不要直接从dll中输出stl对象；如果一定要输出，给它加上一层包装，然后输出这个包装接口而不是原始接口。

2、保证所有的执行单元使用同样版本的STL运行库。
   比如，全部使用release库或debug库，否则两个执行单元扩展出来的STL类的内存布局就可能会不一样。

只要记住关键就是：如果任何STL类使用了静态变量（无论是直接还是间接使用），那么就不要再写出跨执行单元访问它的代码。

解决方法：
1. 一个可以考虑的方案
比如有两个动态库L1和L2，L2需要修改L1中的一个map，那么我在L1中设置如下接口
int modify_map(int key, int new_value);
如果需要指定“某一个map”，则可以考虑实现一种类似于句柄的方式，比如可以传递一个DWORD
不过这个DWORD放的是一个地址

那么modify_map就可以这样实现：
int modify_map(DWORD map_handle, int key, int new_value)
{
    std::map<int, int>& themap = *(std::map<int, int>*)map_handle;
    themap[key] = new_value;
}

map_handle的值也首先由L1“告诉”L2:
DWORD get_map_handle();

L2可以这样调用:
DWORD h = get_map_handle();
modify_map(h, 1, 2);

2. 加入一个额外的层，就可以解决问题。所以，你需要将你的Map包装在dll内部，而不是让它出现在接口当中。动态库的接口越简单越好，不好去传太过复杂的东东是至理名言：）