Language: C++

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <utility>
#include <algorithm>
#include <numeric>
#include <functional>
#include <queue>
#include <stack>
#include <deque>
#include <cmath>
using namespace std;
#define int long long
using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define ITR(i,b,e) for(auto i=(b);i!=(e);++i)
#define FORE(x,c) for(auto &x:c)
#define REPF(i,a,n) for(int i=a,i##len=(int)(n);i<i##len;++i)
#define REP(i,n) REPF(i,0,n)
#define REPR(i,n) for(int i=(int)(n);i>=0;--i)
#define SZ(c) ((int)c.size())
#define CONTAIN(c,x) (c.find(x)!=end(c))
#define OUTOFRANGE(y,x,h,w) ((y)<0||(x)<0||(y)>=(h)||(x)>=(w))
#define dump(...)
const signed INF_=1001001001; const long long INF=1001001001001001001LL;
const int DX[9]={0,1,0,-1,1,1,-1,-1,0},DY[9]={-1,0,1,0,-1,1,1,-1,0};
template<class T> ostream& operator<<(ostream &os,const vector<T> &v) {
    ITR(i,begin(v),end(v))os<<*i<<(i==end(v)-1?"":" ");return os;}
template<class T> istream& operator>>(istream &is,vector<T> &v) {
    ITR(i,begin(v),end(v)) is>>*i;return is;}
template<class T,class U> istream& operator>>(istream &is, pair<T,U> &p) {
    is>>p.first>>p.second;return is;}
template<class T, class U> bool chmax(T &a,const U &b){return a<b?a=b,1:0;}
template<class T, class U> bool chmin(T &a,const U &b){return a>b?a=b,1:0;}
template<class T> using heap=priority_queue<T,vector<T>,greater<T>>;
struct before_main_function {
    before_main_function() {
        cin.tie(0); ios::sync_with_stdio(false);
        cout << setprecision(15) << fixed;
        #define endl "\n"
    }
} before_main_function;
//------------------8<------------------------------------8<--------------------

template<typename Monoid>
struct SegmentTree {
    using T = typename Monoid::T;
    const size_t n;
    vector<T> t;

    void prop_to(std::size_t i) { t[i] = Monoid::op(t[i << 1], t[i << 1 | 1]); }
    SegmentTree(size_t size, const T& v = Monoid::identity()) {
        n = 1;
        while (n < size) n <<= 1;
        t.resize(n << 1, v);
    }
    template <class InputIt>
    SegmentTree(InputIt first, InputIt last) : n(distance(first, last)), t(n << 1, Monoid::identity()) {
        copy(first, last, begin(t) + n);
        for (size_t i = n; i > 0; i--) prop_to(i);
    }
    static T change_update(const T& a, const T& b) { return b; }
    static T change_add(const T& a, const T& b) { return a + b; }
    void update(size_t i, const T& v, const function<T(T, T)>& func = change_update) {
        i += n;
        t[i] = func(t[i], v);
        while (i >>= 1) prop_to(i);
    }
    T query(size_t l, size_t r) {
        T res = Monoid::identity();
        for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
            if (l & 1) res = Monoid::op(res, t[l++]);
            if (r & 1) res = Monoid::op(res, t[--r]);
        }
        return res;
    }
    T get(size_t i) { return t[i + n]; }
};

struct RMQ {
    using T = int;
    static T op(T a, T b) { return min(a, b); }
    static constexpr T identity() { return (1LL << 31) - 1; }
};

struct RSQ {
    using T = int;
    static T op(T a, T b) { return a + b; }
    static constexpr T identity() { return 0; }
};

signed main() {
    int n, q;
    cin >> n >> q;
    SegmentTree<RSQ> seg(n);
    while (q--) {
        int com, x, y;
        cin >> com >> x >> y;
        if (com) cout << seg.query(x - 1, y) << endl;
        else seg.update(x - 1, y, SegmentTree<RSQ>::change_add);
    }
    return 0;
}



Compiler output:
a.cc: In constructor 'SegmentTree<Monoid>::SegmentTree(size_t, const T&)':
a.cc:59:11: error: assignment of read-only member 'SegmentTree<Monoid>::n'
   59 |         n = 1;
      |         ~~^~~
a.cc:60:28: error: assignment of read-only member 'SegmentTree<Monoid>::n'
   60 |         while (n < size) n <<= 1;
      |                          ~~^~~~~
a.cc: In instantiation of 'SegmentTree<Monoid>::SegmentTree(size_t, const T&) [with Monoid = RSQ; size_t = long unsigned int; T = long long int]':
a.cc:101:27:   required from here
  101 |     SegmentTree<RSQ> seg(n);
      |                           ^
a.cc:58:5: error: uninitialized const member in 'const size_t' {aka 'const long unsigned int'} [-fpermissive]
   58 |     SegmentTree(size_t size, const T& v = Monoid::identity()) {
      |     ^~~~~~~~~~~
a.cc:54:18: note: 'const size_t SegmentTree<RSQ>::n' should be initialized
   54 |     const size_t n;
      |                  ^