C++ StringBuilder类

#ifndef __GTL_STRING_BUILDER_H_
#define __GTL_STRING_BUILDER_H_

/* 字符串生成模板 */

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <list>
#include <string>

/*
设计方案:
    一、这里的TLStringBuilder::_container用std::list而不是std::vector？
    官方文档上注明除非你有一个用其他容器的好理由，通常都是使用std::vector。
    优势
        1. 字符串总是会附加到一个容器的末尾。std::list允许在不需要内存再分配的情况下这样做；
      因为vector是使用一个连续的内存块实现的，每用一个就可能导致内存再分配。
        2. std::list对顺序存取相当有利，而且在m_Data上所做的唯一存取操作也是顺序的。
    劣势
        1. 模板类中提供了 Revoke() 方法，该方法在 std::list 和 std::vector性能上会产生差异，
        std::vector性能上会更高效(因为 vector 遍历最后一个元素肯定比 list要快)
    总结：之所以选用 std::list 是因为大多数场景下用户都不会使用 Revoke() 方法，因此选用 std::list
    二、TLStringBuilder到底比string优化在什么地方呢?
        std::string对象执行+操作时，会创建一个新对象，而TLStringBuilder不会创建新对象，TLStringBuilder减少了创建多个临时对象的消耗
        经过测试，c++中的string是在堆上创建字符串的，并非静态区中创建对象，所以并不会占用很多的内存，因为每个变量用完之后会释放的。
    三、注意点
        a. TLStringBuilder在多线程场景下需要加锁保护
        b. 模板类型有要求(并非任意类型，这是由std::basic_string类模板决定的),与类型定义的专用化字符串类型元素的char，
       wstring，为wchar_t， u16string为char16_t，和u32string为char32_t。
*/

namespace gtl
{
    template <typename T>
    class TLStringBuilder
    {
        typedef std::basic_string<T> StringType;    //字符串类型
        typedef std::list<StringType> ContainerType;    //字符串容器类型
        typedef typename StringType::size_type SizeType;    //字符串长度类型
    public:
        //构造函数
        TLStringBuilder() :_container(), _length()
        {
        }

        //构造函数
        explicit TLStringBuilder(const StringType &str) :_container(), _length()
        {
            if (str.empty())
            {
                return;
            }

            this->_container.emplace_back(str);
            this->_length += str.length();
        }

        //析构函数
        ~TLStringBuilder()
        {
            this->_container.clear();
            this->_length = ;
        }

    public:
        //追加字符串
        TLStringBuilder & Append(const StringType &str)
        {
            if (!str.empty())
            {
                this->_container.emplace_back(str);
                this->_length += str.length();
            }
            return *this;
        }

        //撤销最后的字符串
        TLStringBuilder & Revoke(void)
        {
            if (!this->_container.empty())
            {
                StringType tmpStr = this->_container.back();
                this->_container.pop_back();
                this->_length -= tmpStr.length();
            }

            return *this;
        }

        //获取字符串长度
        SizeType Length(void)
        {
            return this->_length;
        }

        //追加字符串 换行
        TLStringBuilder & AppendLine(const StringType &str)
        {
            static T CRLF[]{ ,  }; // C++ 11
            StringType tmpStr;

            if (!str.empty())
            {
                tmpStr = str + CRLF;
            }
            else
            {
                tmpStr = CRLF;
            }

            this->_container.push_back(tmpStr);
            this->_length += tmpStr.length();

            return *this;
        }

        //追加换行
        TLStringBuilder & AppendLine(void)
        {
            static T CRLF[]{ ,  }; // C++ 11
            StringType tmpStr = CRLF;

            this->_container.push_back(tmpStr);
            this->_length += tmpStr.length();

            return *this;
        }

        //拼接字符串(IT的类型需要是迭代器类型 inputIterator )
        template<class IT>
        TLStringBuilder & Add(const IT &first, const IT &last)
        {
            for (IT item = first; item != last; ++item)
            {
                this->Append(*item);
            }

            return *this;
        }

        //转字符串
        StringType ToString(void)
        {
            StringType tmpStr;
            unsigned char *pTmp = NULL;
            unsigned int offset = ;

            pTmp = (unsigned char *)calloc(this->_length + , sizeof(T));
            assert(pTmp);

            for (auto item = this->_container.begin(); item != this->_container.end(); ++item)
            {
                memcpy(pTmp + offset, item->c_str(), item->length());
                offset += item->length();
            }

            tmpStr = (T *)pTmp;

            free(pTmp);
            pTmp = NULL;

            return tmpStr;
        }

    private:
        //禁止拷贝构造 与 赋值操作
        TLStringBuilder(const TLStringBuilder &r) {};
        TLStringBuilder & operator= (const TLStringBuilder &) {}

    private:
        ContainerType _container;
        SizeType _length;
    };
}