我刚刚发现 basic_string<char> 的默认分配器GCC 4.9(使用 MinGW-w64)实现中的 STL 不使用全局 operator new()但也许直接malloc ，但 MSVC 11 (VS 2012) 中的实现使用它。

还在 CentOS 下尝试了 gcc 4.4.6，并按预期调用了运算符。

为什么会有这样的差异，MSVC 方法不是正确的方法吗？我希望能够通过提供我自己的 operator new() 来跟踪 STL 完成的每个分配。 .

这是我的测试代码:

#include <limits>
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <memory>
#include <map>
using namespace std;

template<typename T>
struct MallocAllocator
{
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef T value_type;

    pointer allocate(size_type n, const void* = 0) {
        cout << "Custom: " << sizeof(value_type) * n << endl;
        return static_cast<pointer>(malloc(sizeof(value_type) * n));
    }

    void deallocate(pointer ptr, size_type) {
        free(ptr);
    }

    // boilerplate follows
    MallocAllocator() {}

    MallocAllocator(const MallocAllocator&) {}

    size_type max_size () const throw() { return std::numeric_limits<std::size_t>::max() / sizeof(T); }

    template <typename Other>
    MallocAllocator(const MallocAllocator<Other>&) {}

    MallocAllocator& operator=(const MallocAllocator&) { return *this; }

    template <class Other>
    MallocAllocator& operator=(const MallocAllocator<Other>&) { return *this; }

    template <typename Other>
    struct rebind { typedef MallocAllocator<Other> other; };

    pointer address(reference ref) const {
        return &ref;
    }

    const_pointer address(const_reference ref) const {
        return &ref;
    }

    void construct(pointer ptr, const value_type& val) {
        ::new(ptr) value_type(val);
    }

    void destroy(pointer ptr) {
        ptr->~value_type();
    }
};

template <typename T, typename U>
inline bool operator==(const MallocAllocator<T>&, const MallocAllocator<U>&) {
    return true;
}

template <typename T, typename U>
inline bool operator!=(const MallocAllocator<T>& a, const MallocAllocator<U>& b) {
    return !(a == b);
}

void *operator new(size_t s) {
    cout << "Global: " << s << endl;
    return (void*)malloc(s);
}

void *operator new[](size_t s) {
    cout << "Global: " << s << endl;
    return (void*)malloc(s);
}

int main(int argc, char** argv) {
    //basic_string<char, char_traits<char>, MallocAllocator<char> > s;
    basic_string<char> s;
    s = "dfasdf";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += ".";
    s += "dfasdfsdfasfsdfasdfsdfasfsdfasdfsdfasfsdfasdfsdfasfsdfasdfsdfasfsdfasdfsdfasfsdfasdfsdfasfsdfasdfsdfasfsdfasdfsdfasfs";

    cout << s << endl;

#ifdef _MSC_VER
    system("pause");
#endif

    return 0;
}

使用 MinGW-w64 的 GCC:当我使用自定义分配器时，我看到了分配。当我不使用它时，我什么也看不到。

最佳答案

我认为这可能只是 mingw-w64 运行时或“mingw-builds”中的错误...

“mingw-builds”构建中使用的运行时可能已经从预构建的 dll 中导出了使用 std::string 和默认分配器(我没有能够确认这一点，它可能是 mingw-w64 运行时本身)，MSVC 过去做了类似的事情(虽然我不知道这是否导致了类似的错误)。

我尝试过的一些组合:

• 使用 vector 和覆盖的 operator new 构建的“mingw-builds”按预期使用。
• 使用到运行时的静态绑定(bind) (--static) 构建可执行文件 (mingw-builds) 按预期工作(对于 string 和 vector).
• “nuwen”的构建和对 string 和 vector 的预期工作。
• VS2013 还调用覆盖的 operator new 与 std::allocator 一起使用(有和没有 /MD 选项)。
• VS2008(使用 /MD)产生了意外的输出(std::string 是从运行时 dll、IIRC 导出的)。

据我所知，std::string 是从“libstdc++-6.dll”导出的，因此与 ::operator new 等的绑定(bind)是可能已经在二进制文件中为 string 分配修复了(如您所知)。

对分配器的简单更改；

template <class C>
struct myallocator : std::allocator<C> {
};

允许重写的全局 operator new 按预期与“mingw-builds”一起工作。您已经通过完整的自定义分配器注意到这一点，但此处的简单推导支持“默认”字符串类可能源自 dll 的概念。

#include <cstdio>
#include <cstdlib>
#include <string>
#include <iostream>
#include <vector>
// replacement of a minimal set of functions:
void* operator new(std::size_t sz) {
    std::printf("global op new called, size = %d\n",sz);
    return std::malloc(sz);
}
void operator delete(void* ptr) noexcept
{
    std::puts("global op delete called");
    std::free(ptr);
}
template <class C>
struct myallocator : std::allocator<C> {
};
int main() {
     using namespace std;

     vector<int> def;
     def.resize(100000);

     basic_string<char, char_traits<char>, myallocator<char>> abc;
     abc.resize(100000);
}

命令行

cl /EHsc file.cpp
cl /EHsc /MD file.cpp
g++ --std=c++11 file.cpp
g++ --static --std=c++11 file.cpp

关于c++ - STL 实现之间分配策略的差异？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25680528/