#include <iostream>
#include <limits>

int add (int x, int y)
{
   if  ((x > 0 && y > 0 && x > (std::numeric_limits <int>::max () - y)) ||
   (x < 0 && y < 0 && x < (std::numeric_limits <int>::min () - y)))
   {
      std::cout << "Error" << std::endl;
      exit (EXIT_FAILURE);
   }
   else
   {
      return (x + y);
   }
}

int main ()
{
   int a = add (25, 10);
   std::cout << a << std::endl; 
   int b = add (std::numeric_limits <int>::max (), std::numeric_limits <int>::max ());
   return 0;
}

template <typename T>
T add (T x, T y)
{
   if  ((x > 0 && y > 0 && x > (std::numeric_limits <T>::max () - y)) ||
   (x < 0 && y < 0 && x < (std::numeric_limits <T>::min () - y)))
   {
      std::cout << "Error" << std::endl;
      exit (EXIT_FAILURE);
   }
   else
   {
      return (x + y);
   }
}

bool add(int* result, int x, int y)
{
  *result = x + y;
  return *result >= x && *result >= y;
}

short add (short x, short y) {
  int tmp = x + y; // можно отложить проверку если short действительно короче чем int
  if (tmp < std::numeric_limits<short>::min() || tmp > std::numeric_limits<short>::max())
    throw "overflow";
  return tmp;
}

template<typename T>
T add (T x, T y)
{
  T result = x + y;
  assert(y > 0 == result > x);
  return result;  
}

int checked_add(int a, int b) {
  int sum = a + b;
  int ssd = a ^ b; // на самом деле нам нужен только старший бит
  if ((ssd >= 0) && ((ssd ^ sum) < 0))
    throw integer_overflow();
  return sum;
}

int checked_add(int a, int b) {
  __asm__((
     " add %0,%1\n"
     " jo overflowed"
     : "=0" (a): "r"(a), "r"(b): "flags"
  ));
  return a;
overflowed:
  throw integer_overflow();
}

extern "C" int __addvdi3(int a, int b) { // функция проверки, будет вызываться при сложении двух int
    long long tmp = (long long)a + b;
    int res = a + b;
    if (tmp != res) { // или другой способ проверки
        fprintf(stderr, "Overflow!\n"); // желаемое действие при переполнении
        raise(SIGABRT);
    }
    return res;
}

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.

R>>template<typename T>
R>>T add (T a, T b)
R>>{
R>>  T c = a + b;//если это знаковые целые? 
R>>  assert(b >= 0 == c >= a);
R>>  return c;  
R>>}
R>>

   SafeInt<int> a, b;
   <...>
   a += b;

 804857a:       8d 04 1e                lea    (%esi,%ebx,1),%eax
 804857d:       39 c6                   cmp    %eax,%esi
 804857f:       0f 9e c2                setle  %dl
 8048582:       c1 eb 1f                shr    $0x1f,%ebx
 8048585:       38 da                   cmp    %bl,%dl
 8048587:       74 45                   je     80485ce <main+0xde>

    template < typename E >
    static void AdditionThrow( const T& lhs, const U& rhs, T& result )
    {
        // 32-bit or less - one or both are signed
        __int32 x = (__int32)lhs;
        __int32 y = (__int32)rhs;
        __int32 tmp = x + y;

        if( (y >= 0) == (tmp >= x))
        {
            result = (T)tmp;
            return;
        }
        
        E::SafeIntOnOverflow();

N>    template < typename E >
N>    static void AdditionThrow( const T& lhs, const U& rhs, T& result )
N>    {
N>        // 32-bit or less - one or both are signed
N>        __int32 x = (__int32)lhs;
N>        __int32 y = (__int32)rhs;
N>        __int32 tmp = x + y;

N>        if( (y >= 0) == (tmp >= x))
N>        {
N>            result = (T)tmp;
N>            return;
N>        }
        
N>        E::SafeIntOnOverflow();
N>

1. мы "не замечаем" беззнаковое переполнение. Пример: складываем 0xFFFFFFFFU и 1U, переполнение налицо. Но при интерпретации этих слагаемых как знаковых, получим -1 + 1 = 0, т.е. все Ok;
   
2. выдаем "ложное срабатывание". Пример: складываем 0x7FFFFFFFU и 1U — для беззнаковых чисел это нормально, переполнения нет. Но при интерпретации этих слагаемых как знаковых, придем к ошибочному заключению, что было переполнение.

extern void p(int a, int b);

int main() {
  p(1, 1);
  p(0x30000000, 0x30000000);
  p(0x40000000, 0x40000000);
  p(0x50000000, 0x50000000);
  p(0xB0000000, 0xB0000000);
  p(0xC0000000, 0xC0000000);
  p(0xD0000000, 0xD0000000);
  p(-1, -1);
  return 0;
}

#include <stdio.h>
#include <limits.h>

void p(int a, int b)
{
  int result = a + b;
  int x1 = a ^ b;
  int ovf1, ovf2, ovf3, ovf4;
  if (x1 >= 0)
    ovf1 = ((a ^ result) < 0);
  else
    ovf1 = 0;
  if (b >= 0)
    ovf2 = (a > INT_MAX - b);
  else
    ovf2 = (a < INT_MIN - b);
  ovf3 = ((b >= 0) != (result >= a));
  ovf4 = ((b > 0) != (result > a));
  printf("%8x %8x %8x %1d:%1d:%1d:%1d\n", a, b, result,
      ovf1, ovf2, ovf3, ovf4);
}

       1        1        2 0:0:0:0
30000000 30000000 60000000 0:0:0:0
40000000 40000000 80000000 1:1:1:1
50000000 50000000 a0000000 1:1:1:1
b0000000 b0000000 60000000 1:1:1:1
c0000000 c0000000 80000000 0:0:0:0
d0000000 d0000000 a0000000 0:0:0:0
ffffffff ffffffff fffffffe 0:0:0:0

       1        1        2 0:0:0:0
30000000 30000000 60000000 0:0:0:0
40000000 40000000 80000000 1:1:0:0
50000000 50000000 a0000000 1:1:0:0
b0000000 b0000000 60000000 1:1:0:0
c0000000 c0000000 80000000 0:0:0:0
d0000000 d0000000 a0000000 0:0:0:0
ffffffff ffffffff fffffffe 0:0:0:0

R>Забавно. Но имеет право, поскольку, в отсутствие переполнения это выражение действительно всегда истинно, а при переполнении компилятор с оптимизатором делают что хотят, потому как UB

// Определение этой константы вынесено
// в отдельную единицу трансляции, чтобы
// оптимизатор не видел ее значения.
extern const unsigned char zero;

template<typename T>
T add (T a, T b)
{
  T c = a + b;
  assert(b >= zero == c >= a);
  return c;  
}

R>>Забавно. Но имеет право, поскольку, в отсутствие переполнения это выражение действительно всегда истинно, а при переполнении компилятор с оптимизатором делают что хотят, потому как UB

extern const int foobar;
int ovf3(int a, int b)
{
  int result = a + b;
  return ((b >= foobar) != (result >= a));
}

000000a0 <ovf3>:
  a0:   8b 44 24 08             mov    0x8(%esp),%eax ; это прочли b
  a4:   89 c1                   mov    %eax,%ecx      ; скопировали в %ecx
  a6:   c1 e9 1f                shr    $0x1f,%ecx     ; оставили от него один знак (то есть b<0)
  a9:   39 05 00 00 00 00       cmp    %eax,0x0       ; внешняя переменная foobar, адрес пока неизвестен
  af:   0f 9e c0                setle  %al            ; al - результат (b<foobar)
  b2:   0f b6 c0                movzbl %al,%eax       ; растянули его до полного %eax
  b5:   31 c8                   xor    %ecx,%eax      ; неравенство двух тестов, то есть (b<0) != (b<foobar)
  b7:   83 f0 01                xor    $0x1,%eax      ; булевская инверсия - превратили в равенство тестов
  ba:   c3                      ret