C++ 为什么这个列表实现比stl列表占用更多的空间？

我正在使用IAR作为嵌入式项目的编译器。我试图为基本类型（如list）引入一些模板，但创建的每个STL list对象都会将代码大小增加约200字节，这与当前的C风格实现相比。 我试图自己实现STL列表的一小部分，希望得到更小的代码占用空间，但最终比完整的STL列表更重。 我在使用模板时是否犯了严重错误

谢谢

请注意，代码未经测试，因此可能包含龙

#ifndef __LINK_LIST_HPP__
#define __LINK_LIST_HPP__

#include <stdint.h>
#include <stdlib.h>

template <typename T> class list
{
private:
    struct LinkListElement
    {
        T payload;
        LinkListElement* next;
        LinkListElement* prev;
    };
public:

    class iterator
    {
        // Need access to LinkListElement struct
        friend class list;
    public:
        iterator() : m_cur_item(NULL){}

        iterator(LinkListElement* elem) : m_cur_item(elem){}

        iterator(const iterator& other) : m_cur_item(other.m_cur_item){}

        ~iterator(){}

        iterator& operator=(const iterator& other)
        {
            m_cur_item = other.m_cur_item;
            return *this;
        }

        bool operator==(const iterator& other) const
        {
            // Compare by position, ignoring the payload contents when comparing iterators.
            return  (m_cur_item->next == other.m_cur_item->next) &&
                    (m_cur_item->prev == other.m_cur_item->prev);
        }

        bool operator!=(const iterator& other) const
        {
            return !(*this == other);
        }

        // Prefix increment operator.
        iterator& operator++()
        {
            increment();
            return *this;
        }

        // Postfix increment operator.
        iterator operator++(int)
        {
            iterator copy(*this);
            increment();
            return copy;
        }

        // Prefix decrement operator.
        iterator& operator--()
        {
            decrement();
            return *this;
        }

        // Postfix decrement operator.
        iterator operator--(int)
        {
            iterator copy(*this);
            decrement();
            return copy;
        }

        T& operator*()
        {
            // Just so we won't crash, but behavior is undefined.
            if (m_cur_item == NULL)
            {
                return dummy;
            }

            return m_cur_item->payload;
        }

        T* operator->()
        {
            if (m_cur_item == NULL)
            {
                return NULL;
            }

            return &(m_cur_item->payload);
        }

    private:

        void increment()
        {
            if (m_cur_item == NULL || m_cur_item->next == NULL)
            {
                return;
            }

            m_cur_item = m_cur_item->next;
        }

        void decrement()
        {
            if (m_cur_item == NULL || m_cur_item->prev == NULL)
            {
                return;
            }

            m_cur_item = m_cur_item->prev;
        }

        LinkListElement* m_cur_item;
        static T dummy;

    };

    // Need access to internal LinkListElement pointer
    friend class iterator;

    list()
    {
        // Add sentinel to mark end of list.
        m_tail = new LinkListElement;
        m_tail->next = m_tail;
        m_tail->prev = m_tail;
        m_head = m_tail;
    }

    ~list()
    {
        // Clear entire list except for sentinel
        clear();

        // Destroy sentinel
        delete m_tail;
        m_head = NULL;
        m_tail = NULL;
    }

    T& back()
    {
        // empty list with only sentinel. Result of back() is undefined
        if (empty())
        {
            // TODO: Show some debug error
        }

        return m_tail->prev->payload;
    }

    T& front()
    {
        if (empty())
        {
            // TODO: Show some debug error
        }

        // m_head is always defined even if list is empty
        return m_head->payload;
    }

    size_t size()
    {
        return m_count;
    }

    bool empty()
    {
        // head == tail means the list is empty
        return m_head == m_tail;
    }

    iterator begin()
    {
        return iterator(m_head);
    }

    iterator end()
    {
        return iterator(m_tail);
    }

    iterator insert(iterator position, const T& payload)
    {
        // Validate position by finding it in our list
        iterator find = begin();
        while (find != end() && find != position)
        {
            ++find;
        }

        if (find == end())
        {
            // TODO: Show some debug error
            return position;
        }

        return insert_before(find.m_cur_item, payload);
    }

    void push_back(const T& payload)
    {
        insert_before(m_tail, payload);
    }

    void push_front(const T& payload)
    {
        insert_before(m_head, payload);
    }

    iterator erase(iterator position)
    {
        // Validate position by finding it in our list
        iterator find = begin();
        while (find != end() && find != position)
        {
            ++find;
        }

        if (find == end())
        {
            // TODO: Show some debug error
            return position;
        }

        return remove_at(find.m_cur_item);

    }

    //iterator erase(iterator first, iterator last);    // Implement only if needed
    void pop_back()
    {
        if (!empty())
        {
            // Don't remove the sentinel
            remove_at(m_tail->prev);
        }
    }

    void pop_front()
    {
        if (!empty())
        {
            remove_at(m_head);
        }
    }

    void remove(const T& value)
    {
        iterator iter = begin();

        while (iter != end())
        {
            iterator remove = iter++;
            if (*remove == value)
            {
                remove_at(remove.m_cur_item);
            }
        }
    }

    void clear()
    {
        while (!empty())
        {
            pop_back();
        }
    }

private:

    iterator insert_before(LinkListElement* existing, const T& payload)
    {
        // Allocate memory and save the element
        LinkListElement* new_elem = new LinkListElement;

        // For classes types (not pointer to object) this should invoke copy constructor
        new_elem->payload = payload;
        new_elem->prev = existing->prev;
        new_elem->next = existing;
        existing->prev = new_elem;
        ++m_count;

        if (existing == m_head)
        {
            m_head = new_elem;
        }

        return iterator(new_elem);
    }

    iterator remove_at(LinkListElement* to_remove)
    {
        // Allocate memory and save the element
        LinkListElement* prev = to_remove->prev;
        LinkListElement* next = to_remove->next;
        prev->next = next;
        next->prev = prev;
        --m_count;

        if (to_remove == m_head)
        {
            m_head = next;
        }

        delete to_remove;

        return iterator(prev);
    }

    LinkListElement* m_head;
    LinkListElement* m_tail;
    uint32_t         m_count;
};

template <typename T> T list<T>::iterator::dummy;

#endif

\ifndef\uu链接列表\uu水电站__
#定义链接列表水电站__
#包括
#包括
模板类列表
{
私人：
结构链接列表元素
{
T有效载荷；
LinkListElement*下一步；
LinkListElement*prev；
};
公众：
类迭代器
{
//需要访问LinkListElement结构
好友类列表；
公众：
迭代器（）：m_cur_item（NULL）{}
迭代器（LinkListElement*elem）：m_cur_项（elem）{}
迭代器（const iterator&other）：m_cur_项（other.m_cur_项）{}
~iterator（）{}
迭代器和运算符=（常量迭代器和其他）
{
m_cur_item=其他m_cur_item；
归还*这个；
}
布尔运算符==（常量迭代器和其他）常量
{
//按位置比较，在比较迭代器时忽略有效负载内容。
返回（当前项目->下一步==其他.当前项目->下一步）&&
（m\u cur\u item->prev==其他.m\u cur\u item->prev）；
}
布尔运算符！=（常量迭代器和其他）常量
{
返回！（*此==其他）；
}
//前缀增量运算符。
迭代器和运算符++（）
{
增量（）；
归还*这个；
}
//后缀增量运算符。
迭代器运算符++（int）
{
迭代器副本（*this）；
增量（）；
返回副本；
}
//前缀减量运算符。
迭代器和运算符--（）
{
减量（）；
归还*这个；
}
//后缀减量运算符。
迭代器运算符--（int）
{
迭代器副本（*this）；
减量（）；
返回副本；
}
T&运算符*（）
{
//这样我们就不会崩溃，但行为是未定义的。
if（m_cur_item==NULL）
{
返回假人；
}
返回当前项目->有效载荷；
}
T*运算符->（）
{
if（m_cur_item==NULL）
{
返回NULL；
}
返回和（当前项目->有效载荷）；
}
私人：
无效增量（）
{
如果（当前项目==NULL |当前项目->下一步==NULL）
{
返回；
}
当前项目=当前项目->下一步；
}
无效减量
{
如果（m|u cur_item==NULL | m|u cur_item->prev==NULL）
{
返回；
}
当前项目=当前项目->上一个；
}
LinkListElement*m_cur_项目；
静态T型假人；
};
//需要访问内部LinkListElement指针
友元类迭代器；
列表（）
{
//添加哨兵以标记列表的末尾。
m_tail=新链接列表元素；
m_tail->next=m_tail；
m_tail->prev=m_tail；
m_头=m_尾；
}
~list（）
{
//清除除sentinel之外的整个列表
清除（）；
//消灭哨兵
删除m_tail；
m_头=空；
m_tail=NULL；
}
T&back（）
{
//只有sentinel的空列表。back（）的结果未定义
if（空（））
{
//TODO:显示一些调试错误
}
返回m_tail->prev->payload；
}
T&front（）
{
if（空（））
{
//TODO:显示一些调试错误
}
//即使列表为空，也始终定义m_头
返回m_头->有效载荷；
}
大小
{
返回m_计数；
}
bool empty（）
{
//head==tail表示列表为空
返回m_head==m_tail；
}
迭代器begin（）
{
返回迭代器（m_头）；
}
迭代器结束（）
{
返回迭代器（m_tail）；
}
迭代器插入（迭代器位置、常量T和有效负载）
{
//通过在我们的列表中查找来验证位置
迭代器find=begin（）；
while（find！=end（）&&find！=position）
{
++发现；
}
if（find==end（））
{
//TODO:显示一些调试错误
返回位置；
}
返回之前的插入内容（查找当前项目，有效负载）；
}
无效推回（常数T和有效载荷）
{
在（m_尾，有效载荷）之前插入_；
}
无效前推（常数T和有效载荷）
{
在（m_头，有效载荷）之前插入_；
}
迭代器擦除（迭代器位置）
{
//通过在我们的列表中查找来验证位置
迭代器find=begin（）；
while（find！=end（）&&find！=position）
{
++发现；
}
if（find==end（））
{
//TODO:显示一些调试错误
返回位置；
}
返回删除位置（查找当前项目）；
}
//迭代器擦除（迭代器优先，迭代器最后）；//仅在需要时实现
void pop_back（）
{
如果（！empty（））
{
//不要移除哨兵
在（m_tail->prev）处移除_；
}
}
void pop_front（）
{
如果（！empty（））
{
移除（m_头）处的_；
}
}
无效删除（常量T和值）
{
迭代器iter=begin（）；
while（iter！=end（））
{
迭代器删除=iter++；
如果（*删除==值）
{
在（移除m）处移除