没错，新的.hpp又来了……

（不是哥们，又干啥了？）

点我看Tree~~.hpp: 关于我自己写的Tree.hpp

String_number.hpp

顾名思义，把number(就是int, long long一类的)用string保存。

那why要写这个看起来就很（没）难（啥）用（用）的.hpp呢？

什么？？？你还不知道？？？

高精度啊！！bro！！~

You:那高精度又有……

拱出去，谢谢awa~

下面是代码时间~:

#include <string>
#include <unordered_map>
#include <bits/c++config.h>
#include <ostream>
#include <istream>
#include <algorithm>
namespace std
{
    class string_number
    {
    private:
        string num;
        unordered_map<char, int> digit_map;

    public:

#define digit_map_init {{'0', 0}, {'1', 1}, {'2', 2}, {'3', 3}, {'4', 4}, {'5', 5}, {'6', 6}, {'7', 7}, {'8', 8}, {'9', 9}}

        string_number(int num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(unsigned num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(long num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(unsigned long num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(long long num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(unsigned long long num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(float num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(double num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(long double num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(to_string(num)), digit_map(digit_map) {}
        string_number(char num,
                      unordered_map<char, int> digit_map = digit_map_init) : num(string(1, num)), digit_map(digit_map) {}
        string_number(string num = "",
                      unordered_map<char, int> digit_map = digit_map_init) : num(num), digit_map(digit_map) {}
        string_number(size_t n, char c,
                      unordered_map<char, int> digit_map = digit_map_init) : num(string(n, c)), digit_map(digit_map) {}

#undef digit_map_init

        string_number operator=(string_number str_n)
        {
            this->num = str_n.num;
            return *this;
        }
        friend string_number operator+(string_number str_n1, string_number str_n2);
        string_number operator+=(string_number str_n)
        {
            *this = *this + str_n;
            return *this;
        }

        friend ostream &operator<<(ostream &output, string_number str_n);
        friend istream &operator>>(istream &input, string_number &str_n);
    };

    string_number operator+(string_number str_n1, string_number str_n2)
    {
        size_t len1 = str_n1.num.size(), len2 = str_n2.num.size();
        if (len1 > len2)
        {
            swap(str_n1, str_n2);
            swap(len1, len2);
        }
        bool carry = false;
        size_t i = len2 - 1;
        for (; i >= len2 - len1; i--)
        {
            str_n2.num.at(i) += str_n1.num.at(i - len2 + len1) - '0' + carry;
            carry = str_n2.num.at(i) - '0' > 9;
            str_n2.num.at(i) -= carry * 10;
            if (i == 0)
                break;
        }
        while (carry && !(len2 - len1 == 0))
        {
            str_n2.num.at(i)++;
            carry = str_n2.num.at(i) - '0' > 9;
            str_n2.num.at(i) -= carry * 10;
            if (i-- == 0)
                break;
        }
        if (carry)
            str_n2.num = '1' + str_n2.num;
        return str_n2;
    }

    ostream &operator<<(ostream &output, string_number str_n)
    {
        output << str_n.num;
        return output;
    }
    istream &operator>>(istream &input, string_number &str_n)
    {
        input >> str_n.num;
        return input;
    }
}

（悄悄地告诉你：这个加法好出生啊QWQ，写了我半个小时awa~~）

如你所见，只有加法。剩下的还要等等。（毕竟还在写Tree.hpp）

其实是不想写……

新版

上课写的，不说太多。

#include <string>
#include <unordered_map>
#include <bits/c++config.h>
#include <ostream>
#include <istream>
#include <algorithm>

namespace std
{

    class string_number
    {
    public:
        typedef size_t size_type;
        typedef unordered_map<size_type, char> dig_map_type;
        typedef unordered_map<string, char> sym_map_type;

    protected:
        typedef unordered_map<char, size_type> chr_map_type;

    private:
        static const dig_map_type digit_map_init;
        static const sym_map_type symbol_map_init;
        size_t sys;
        string num;
        dig_map_type digit_map;
        sym_map_type symbol_map;

    protected:
        chr_map_type character_map;

    public:
        string_number(string num = "", dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(num), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(int num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(unsigned num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(long num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(unsigned long num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(long long num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(unsigned long long num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(float num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(double num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(long double num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(to_string(num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(char num, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(string(1, num)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }
        string_number(size_t n, char c, dig_map_type digit_map = digit_map_init, sym_map_type symbol_map = symbol_map_init)
            : num(string(n, c)), digit_map(digit_map), symbol_map(symbol_map)
        {
            oper_sys();
        }

        size_type oper_sys()
        {
            character_map.clear();
            for (size_type digit = 0;; digit++)
            {
                dig_map_type::iterator iter = digit_map.find(digit);
                if (iter != digit_map.end())
                    character_map.insert({iter->second, iter->first});
                else
                {
                    sys = digit;
                    break;
                }
            }
            return sys;
        }

        size_type length()
        {
            return num.size();
        }

        friend string_number operator+(string_number str_n1, string_number str_n2);

        string_number operator=(string_number str_n)
        {
            this->num = str_n.num;
            return *this;
        }
        string_number operator+=(string_number str_n)
        {
            *this = *this + str_n;
            return *this;
        }

        friend ostream &operator<<(ostream &output, string_number str_n);
        friend istream &operator>>(istream &input, string_number &str_n);
    };
    const string_number::dig_map_type string_number::digit_map_init =
        {{0, '0'}, {1, '1'}, {2, '2'}, {3, '3'}, {4, '4'}, {5, '5'}, {6, '6'}, {7, '7'}, {8, '8'}, {9, '9'}};
    const string_number::sym_map_type string_number::symbol_map_init =
        {{"point", '.'}, {"negative", '-'}, {"positive", '+'}};

    string_number operator+(string_number str_n1, string_number str_n2)
    {
        size_t len1 = str_n1.num.size(), len2 = str_n2.num.size();
        if (len1 > len2)
        {
            swap(str_n1, str_n2);
            swap(len1, len2);
        }
        bool carry = false;
        size_t i = len2 - 1;
        for (; i >= len2 - len1; i--)
        {
            str_n2.num.at(i) += str_n1.num.at(i - len2 + len1) - '0' + carry;
            carry = str_n2.num.at(i) - '0' > 9;
            str_n2.num.at(i) -= carry * 10;
            if (i == 0)
                break;
        }
        while (carry && !(len2 - len1 == 0))
        {
            str_n2.num.at(i)++;
            carry = str_n2.num.at(i) - '0' > 9;
            str_n2.num.at(i) -= carry * 10;
            if (i-- == 0)
                break;
        }
        if (carry)
            str_n2.num = '1' + str_n2.num;
        return str_n2;
    }

    ostream &operator<<(ostream &output, string_number str_n)
    {
        output << str_n.num;
        return output;
    }
    istream &operator>>(istream &input, string_number &str_n)
    {
        input >> str_n.num;
        return input;
    }

}