树状数组动态扩容

#include <vector>
#include <iostream>
template <class data = int>
class Binary_Index_Tree
{
private:
    std::vector<data> BIT;

public:
    void reset()
    {
        BIT.clear();
    }
    unsigned lowbit(const unsigned x) const
    {
        return x & (-x);
    }
    Binary_Index_Tree(int x = 0, data y = data())
    {
        BIT = std::vector<data>(x, y);
    }
    void kuorong(unsigned x)
    {
        if (x <= BIT.size())
            return;
        const auto old_size = BIT.size();
        BIT.resize(x);
        const auto new_size = BIT.size();
        for (unsigned i = old_size; i < new_size; i++)
        {
            if (i < 1)
                continue;
            for (unsigned zzz_1 = i - 1, zzz_2 = i - lowbit(i); zzz_1 > zzz_2; zzz_1 -= lowbit(zzz_1))
                BIT[i] += BIT[zzz_1];
        }
        return;
    }
    data query(int x)
    {
        kuorong(x + 1);
        data wer(0);
        for (; x > 0; x -= lowbit(x))
        {
            wer += BIT[x];
        }
        return wer;
    }
    void change(unsigned x, const data d)
    {
        kuorong(x + 1);
        for (; x != 0 && x < BIT.size(); x += lowbit(x))
        {
            BIT[x] += d;
        }
    }
};
Binary_Index_Tree<> e;
using namespace std;
signed main()
{
    int n, m;
    cin >> n >> m;
    e = Binary_Index_Tree(0);
    for (int i = 1, zzz; i <= n; i++)
    {
        cin >> zzz;
        e.change(i, zzz);
    }
    for (int opt, zzz1, zzz2, j = 1; j <= m; j++)
    {
        cin >> opt;
        switch (opt)
        {
        case 1:
            cin >> zzz1 >> zzz2;
            e.change(zzz1, zzz2);
            break;
        case 2:
            cin >> zzz1 >> zzz2;
            cout << e.query(zzz2) - e.query(zzz1 - 1) << endl;
            break;
        }
    }
    return 0;
}