我正在使用google benchmark运行boost/singleton_pool的基准测试。我碰巧做了一个模板类，用std::malloc和std::free重载了new和delete：

template <typename Derived>
    class Standard
    {
      public:
        static void* operator new(std::size_t size) {
            return std::malloc(size);
        }

        static void operator delete(void *ptr, std::size_t) {
            std::free(ptr);
        }
    };

我用gooogle基准测试框架测试了一些类，比如int和Standard<int>，我发现这个模板 Package 器会对性能产生影响。对于T类，Standard<T>似乎比T本身快一点。
我对此很困惑。我认为默认的new和delete也使用std::malloc和std::free。为什么他们是不同的？？
一个最小的可复制的二进制文件：（需要google benchmark framework来编译）

#include "evelyn/PoolPolicy.h"
#include <cstdint>
#include <benchmark/benchmark.h>

template <size_t N>
struct Block
{
    int8_t data[N];
};

template <typename T>
class Standard
{
public:
    static void *operator new(std::size_t size)
    {
        return std::malloc(size);
    }

    static void operator delete(void *ptr, std::size_t)
    {
        std::free(ptr);
    }
};

using A = Standard<int>;
using B = int;

class PoolFixture : public benchmark::Fixture
{
public:
    void SetUp(const ::benchmark::State &state)
    {
    }

    void TearDown(const ::benchmark::State &state)
    {
    }
};

auto constexpr ITERATE_TIME = 1000;

BENCHMARK_F(PoolFixture, without_pool_only_allocate)
(benchmark::State &state)
{
    using Block = Block<10>;
    for (auto _ : state)
    {
        for (auto i = 0; i < ITERATE_TIME; ++i)
        {
            auto ptr = new Block;
        }
    }
}

BENCHMARK_F(PoolFixture, with_pool_only_allocate)
(benchmark::State &state)
{
    using Block = Standard<Block<10>>;
    for (auto _ : state)
    {
        for (auto i = 0; i < ITERATE_TIME; ++i)
        {
            auto ptr = new Block;
        }
    }
}

BENCHMARK_F(PoolFixture, without_pool_allocate_and_delete_1)
(benchmark::State &state)
{
    using Block = Block<10>;
    for (auto _ : state)
    {
        for (auto i = 0; i < ITERATE_TIME; ++i)
        {
            auto ptr = new Block;
            delete ptr;
        }
    }
}

BENCHMARK_F(PoolFixture, with_pool_allocate_and_delete_1)
(benchmark::State &state)
{
    using Block = Standard<Block<10>>;
    for (auto _ : state)
    {
        for (auto i = 0; i < ITERATE_TIME; ++i)
        {
            auto ptr = new Block;
            delete ptr;
        }
    }
}