[阶段练习] String类型实现

（本文已于2018-1-1更新）
使用时#include包含以下代码的头文件即可：

// File: pstring.hpp
#ifndef __HEADER__PSTRING_
#define __HEADER__PSTRING_
#include<stdexcept>
#include<iostream>
class pstring {
private:
    // 任意迭代器类型
    template<typename FN>
    struct any_iterator {
    private:
        char *p;
    public:
        any_iterator(): p(nullptr) {}
        any_iterator(char *p): p(p) {}

        char &operator*()
        {
            return *p;
        }

        char *operator->()
        {
            return p;
        }

        bool operator!=(const any_iterator& rhs) const
        {
            return p != rhs.p;
        }

        any_iterator &operator++()
        {
            FN f;
            p = f(p);
            return *this;
        }
    };

    // 任意常量迭代器类型
    template<typename FN>
    struct any_const_iterator {
    private:
        char *p;
    public:
        any_const_iterator(): p(nullptr) {}
        any_const_iterator(char *p): p(p) {}

        const char &operator*()
        {
            return *p;
        }

        const char *operator->()
        {
            return p;
        }

        bool operator!=(const any_const_iterator& rhs) const
        {
            return p != rhs.p;
        }

        any_const_iterator &operator++()
        {
            FN f;
            p = f(p);
            return *this;
        }
    };

    // 正向迭代器函数
    struct FNIterator {
        char *operator()(char *p)
        {
            return ++p;
        }
    };

    // 逆向迭代器函数
    struct FNReverseIterator {
        char *operator()(char *p)
        {
            return --p;
        }
    };

public:
    /** @type size_type 字符串中的所有长度、大小类型 */
    typedef unsigned int size_type;
    /** @type iterator 字符串内容迭代器 */
    typedef any_iterator<FNIterator> iterator;
    typedef any_const_iterator<FNIterator> const_iterator;
    /** @type reverse_iterator 字符串内容逆向迭代器 */
    typedef any_iterator<FNReverseIterator> reverse_iterator;
    typedef any_const_iterator<FNReverseIterator> const_reverse_iterator;
private:    
    // 存储默认长度
    static const size_type DEFAULT_CAPACITY = 10;
    // 常数，表示最长支持的字符串长度（此处用到隐式转换）
    static const size_type npos = -1;
    // 存储区域的指针
    char *_data = nullptr;
    // 目前字符的长度
    size_type _length;
    // 目前存储区域的大小（容量）
    size_type _capacity = DEFAULT_CAPACITY;
    /** 求C风格字符串长度
     *  @param st {const char *} 要求长的C风格字符串
     *  @return {size_type} 字符串长度
     */
    size_type count_cstring(const char *st) const;
public:
    /** @constructor 构建一个空字符串 */
    pstring();

    /** @destructor 回收字符串资源 */
    ~pstring();

    /** @constructor 构造由指定C风格字符串构成的字符串
     *  @param st {const char *} 指定C风格字符串
     */
    pstring(const char *s);

    /** @constructor 构造由指定字符串构成的字符串
     *  @param str {const pstring &} 指定字符串
     */
    pstring(const pstring &st);

    /** @constructor 构造由count个指定字符构成的字符串
     *  @param ch {const char} 指定字符
     *  @param count {int} 个数
     */
    pstring(const char ch, int count = 1);

    /** 用另一个字符串赋值
     *  @param st {const pstring} 另一个字符串
     *  @return {pstring &} *this
     */
    pstring &assign(const pstring &st);

    /** 用一个C风格字符串赋值
     *  @param s {const char *} C风格字符串
     *  @return {pstring &} *this
     */
    pstring &assign(const char *s);

    /** 用一个字符赋值
     *  @param ch {const char} 指定字符
     *  @param count {int} 字符出现的次数
     *  @return {pstring &} *this
     */
    pstring &assign(const char ch, int count = 1);

    /** 用另一个字符串赋值，等同于assign(const pstring &)
     *  @see assign(const pstring &st)
     */
    pstring &operator=(const pstring &st);

    /** 用一个C风格字符串赋值，等同于assign(const char *)
     *  @see assign(const char *s)
     */
    pstring &operator=(const char *s);

    /** 用一个字符赋值，等同于assign(const char ch)
     *  @see assign(const char ch)
     */
    pstring &operator=(const char ch);

    /** 返回位于idx的字符的引用。并进行边界检查，非法访问时抛出 std::out_of_range 类型的异常。
     *  @param idx 指定的位置
     *  @throws std::out_of_range
     *  @return {char &} 指定位置字符的引用
     */
    char &at(int idx);

    /** 返回位于idx的字符的引用。但不进行边界检查。
     *  @param idx 指定的位置
     *  @return {char &} 指定位置字符的引用
     */
    char &operator[](int idx) noexcept;

    /** 返回位于idx的字符的引用。但不进行边界检查。
     *  @param idx 指定的位置
     *  @return {char &} 指定位置字符的引用
     */
    const char &operator[](int idx) const;

    /** 返回string首字符的引用。当字符串为空时将出现随机字符。
     *  @return {char &} 首字符的引用
     */
    char &front();

    /** 返回string首字符的引用。当字符串为空时将出现随机字符。
     *  @return {const char &} 首字符的引用
     */
    const char &front() const;

    /** 返回string尾字符的引用。当字符串为空时将出现随机字符。
     *  @return {char &} 尾字符的引用
     */
    char &back();

    /** 返回string尾字符的引用。当字符串为空时将出现随机字符。
     *  @return {const char &} 尾字符的引用
     */
    const char& back() const;

    /** 获得字符串存储位置的指针。
     *  @return {char *} 数据指针
     */
    char *data();

    /** 获得字符串存储位置的指针 
     *  @return {const char *} 数据指针
     */
    const char *data() const;

    /** 获得string对应的C风格字符串 
     *  @return {const char *} 对应的C风格的字符串
     */
    const char *c_str() const;

    /** 返回从首字符开始的正向迭代器
     *  @return {iterator} 从首字符开始的正向迭代器
     */
    iterator begin() const;

    /** 返回从首字符开始的常量正向迭代器
     *  @return {iterator} 从首字符开始的常量正向迭代器
     */
    const_iterator cbegin() const;

    /** 返回从首字符开始的逆向迭代器
     *  @return {iterator} 从首字符开始的逆向迭代器
     */
    reverse_iterator rbegin() const;

    /** 返回从首字符开始的常量逆向迭代器
     *  @return {iterator} 从首字符开始的常量逆向迭代器
     */
    const_reverse_iterator crbegin() const;


    /** 返回从尾字符开始的正向迭代器
     *  @return {iterator} 从尾字符开始的正向迭代器
     */
    iterator end() const;

    /** 返回从尾字符开始的常量正向迭代器
     *  @return {iterator} 从尾字符开始的常量正向迭代器
     */
    const_iterator cend() const;

    /** 返回从尾字符开始的逆向迭代器
     *  @return {iterator} 从尾字符开始的逆向迭代器
     */
    reverse_iterator rend() const;

    /** 返回从尾字符开始的常量逆向迭代器
     * @return {iterator} 从尾字符开始的常量逆向迭代器
     */
    const_reverse_iterator crend() const;

    /** 获得字符串是否为空字符串 
     *  @return {bool} 字符串是否为空
     */
    bool empty() const;

    /** 获得字符串的长度，等价于length()
     *  @return {size_type} 字符串的长度
     */
    size_type size() const;

    /** 获得字符串的长度，等价于size()
     *  @return {size_type} 字符串的长度
     */
    size_type length() const;

    /** 获得字符串库允许的最大长度
     *  @return {size_type} 库允许的最大字符串的长度
     */
    size_type max_size() const;

    /** 指定string预留一定的空间，具体行为以参数的不同而不同。
     *  若new_cap大于当前的capacity(), 则分配新存储，并使capacity()大于或等于new_cap；
     *  若new_cap小于当前的capacity()，则不会发生任何事；
     *  若new_cap小于当前的size()，则等同于执行了shrink_to_fit()。
     *  @param new_cap 新的空间的参考值
     *  @return {void}
     */
    void reserve(size_type new_cap = 0);

    /** 返回已经为string分配空间的字符数。
     *  @return {size_type} 表示已分配的字符数
     */
    size_type capacity() const;

    /** 请求移除未使用的容量，减少capacity()到size()的请求。
     *  一旦执行，将非法化所有指针、引用和迭代器。
     *  @return {void}
     */
    void shrink_to_fit();

    /** 擦除string中的所有字符，同时所有指针、引用、迭代器均非法化。
     *  @return {void}
     */
    void clear();

    /** 在index处插入count个ch字符。
     *