GArray*
g_array_set_size (GArray *farray,
          guint   length)
{
  GRealArray *array = (GRealArray*) farray;
  if (length > array->len)
    {
      g_array_maybe_expand (array, length - array->len);
      
      if (array->clear)
    g_array_elt_zero (array, array->len, length - array->len);
    }
#ifdef ENABLE_GC_FRIENDLY  
  else if (length < array->len)
    g_array_elt_zero (array, length, array->len - length);
#endif /* ENABLE_GC_FRIENDLY */  
  
  array->len = length;
  
  g_array_zero_terminate (array);
  
  return farray;
}

static gint
g_nearest_pow (gint num)
{
  gint n = 1;

  while (n < num)
    n <<= 1;

  return n;
}

static void
g_array_maybe_expand (GRealArray *array,
              gint        len)
{
  guint want_alloc = g_array_elt_len (array, array->len + len + 
                      array->zero_terminated);

  if (want_alloc > array->alloc)
    {
      want_alloc = g_nearest_pow (want_alloc);
      want_alloc = MAX (want_alloc, MIN_ARRAY_SIZE);

      array->data = g_realloc (array->data, want_alloc);

#ifdef ENABLE_GC_FRIENDLY
      memset (array->data + array->alloc, 0, want_alloc - array->alloc);
#endif /* ENABLE_GC_FRIENDLY */

      array->alloc = want_alloc;
    }
}

#define g_array_elt_len(array,i) ((array)->elt_size * (i))
#define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i)))

size_t c = a + b;
assert(c >= std::min(a, b));

unsigned int a = ...;
unsigned int b = ...;
...
unsigned int a_half = a / 2;
unsigned int b_half = b / 2;
unsigned int max_half = UINT_MAX / 2;

unsigned int AplusB = 0;

if ( a_half + b_half < max_half )
  // a и b можно складывать
  AplusB = a + b;
else
  // возможно переполнение
  throw ...;

if ( a + b < a )
{
    // overflow!
}

BFE>unsigned int a = ...;
BFE>unsigned int b = ...;
BFE>...
BFE>unsigned int a_half = a / 2;
BFE>unsigned int b_half = b / 2;
BFE>unsigned int max_half = UINT_MAX / 2;

BFE>unsigned int AplusB = 0;

BFE>if ( a_half + b_half < max_half )
BFE>  // a и b можно складывать
BFE>  AplusB = a + b;
BFE>else
BFE>  // возможно переполнение
BFE>  throw ...;
BFE>

size_type _Count = 0;
        _Distance(_First, _Last, _Count);
        size_type _Capacity = capacity();

        if (_Count == 0)
            ;
        else if (max_size() - size() < _Count)
            _Xlen();    // result too long
        else if (_Capacity < size() + _Count)
            {    // not enough room, reallocate
            _Capacity = max_size() - _Capacity / 2 < _Capacity
                ? 0 : _Capacity + _Capacity / 2;    // try to grow by 50%
            if (_Capacity < size() + _Count)
                _Capacity = size() + _Count;
            pointer _Newvec = this->_Alval.allocate(_Capacity);
            pointer _Ptr = _Newvec;

            _TRY_BEGIN
            _Ptr = _Umove(_Myfirst, _VEC_ITER_BASE(_Where),
                _Newvec);    // copy prefix
            _Ptr = _Ucopy(_First, _Last, _Ptr);    // add new stuff
            _Umove(_VEC_ITER_BASE(_Where), _Mylast, _Ptr);    // copy suffix
            _CATCH_ALL
            _Destroy(_Newvec, _Ptr);
            this->_Alval.deallocate(_Newvec, _Capacity);
            _RERAISE;
            _CATCH_END

            _Count += size();
            if (_Myfirst != 0)
                {    // destroy and deallocate old array
                _Destroy(_Myfirst, _Mylast);
                this->_Alval.deallocate(_Myfirst, _Myend - _Myfirst);
                }

 #if _HAS_ITERATOR_DEBUGGING
            this->_Orphan_all();
 #endif /* _HAS_ITERATOR_DEBUGGING */

            _Myend = _Newvec + _Capacity;
            _Mylast = _Newvec + _Count;
            _Myfirst = _Newvec;
            }
        else
            {    // new stuff fits, append and rotate into place
            _Ucopy(_First, _Last, _Mylast);

            _Reverse(_Where._Myptr, _Mylast);
            _Reverse(_Mylast, _Mylast + _Count);
            _Reverse(_Where._Myptr, _Mylast + _Count);

            _Mylast += _Count;

 #if _HAS_ITERATOR_DEBUGGING
            _Orphan_range(_Where._Myptr, _Mylast);
 #endif /* _HAS_ITERATOR_DEBUGGING */

            }
        }

short *_Last = 0x80000002, *_First = 0x2;
    _Off += _Last - _First;
00414F72 8B 45 0C         mov         eax,dword ptr [_Last] 
00414F75 2B 45 08         sub         eax,dword ptr [_First] 
00414F78 D1 F8            sar         eax,1 ; вот тут если знаковй бит есть быть беде
00414F7A 8B 4D 10         mov         ecx,dword ptr [_Off] 
00414F7D 03 01            add         eax,dword ptr [ecx] 
00414F7F 8B 55 10         mov         edx,dword ptr [_Off] 
00414F82 89 02            mov         dword ptr [edx],eax

5.5
If during the evaluation of an expression, the result is not mathematically defined or not in the range of representable
values for its type, the behavior is undefined, unless such an expression is a constant expression
(5.19), in which case the program is ill-formed.

[Note: most existing implementations of C + + ignore integer
overflows. Treatment of division by zero, forming a remainder using a zero divisor, and all floating point
exceptions vary among machines, and is usually adjustable by a library function. ]

3.9.1 Fundamental types
4 Unsigned integers, declared unsigned, shall obey the laws of arithmetic modulo 2n where n is the number
of bits in the value representation of that particular size of integer.41)

41) This implies that unsigned arithmetic does not overflow because a result that cannot be represented by the resulting unsigned integer
type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting unsigned integer
type.

if ( a + b < a )
Q>>{
Q>>    // overflow!
Q>>}

Unsigned integers, declared unsigned, shall obey the laws of arithmetic modulo 2**n where n is the number
of bits in the value representation of that particular size of integer.

if ( a + b < a )
Q>{
Q>    // overflow!
Q>}

if ( a + b < MAX(a,b) )
{
    // overflow!
}