Проверка правильности ввода для переменной типа short

int main()
{   
    short a, b, x, o;
    cout<<"Input a,b:";
    std::cin >> a >> b ;
    if (a>32768*-1 && a<32767)
    {
        x = a-b;
    }
   cout<<x;
   cin>>a;
   return 0;
}

#include <iostream>
#include <limits.h>
int main()
{   
    long a, b,temp;
    std::cout<<"Input a,b:";
    std::cin >> a >> b ;
    if (a>SHRT_MAX || a<SHRT_MIN)
        std::cout<<"Number "<<a<<" can't stored to short varible\n";
    if (b>SHRT_MAX || b<SHRT_MIN)
        std::cout<<"Number "<<b<<" can't stored to short varible\n";
    temp = a-b;
    if (temp>SHRT_MAX || temp<SHRT_MIN)
        std::cout<<"Result can't stored to short varible\n";
    else
    {
        short x=(short)temp;
        std::cout<<x;
    }
    system("pause");
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//Разработать алгоритм и написать программу вычисления заданного целочисленного 
//выражения для данных в формате 16 битов со знаком, используя оператор IF. 
//Промежуточные вычисления могут проводиться с использованием любых типов данных 
//(с обоснованием выбора типа данных), а тип результата Х - тоже должен быть 
//16 битов со знаком. Входные данные и результат вычислений должны быть проверены 
//на область допустимых значений.
///////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <limits>
#include <stdint.h>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
typedef long long       T_big_int;
typedef int16_t         T_int;
///////////////////////////////////////////////////////////////////////////////
const   T_int   INT_16_MIN  =   std::numeric_limits< T_int >::min();
const   T_int   INT_16_MAX  =   std::numeric_limits< T_int >::max();
///////////////////////////////////////////////////////////////////////////////
bool    number_is_in_range_of_int16( T_big_int  big_val )
{
    return      INT_16_MIN  <=  big_val
            &&  big_val     <=  INT_16_MAX;
}
///////////////////////////////////////////////////////////////////////////////
void    print_prompt_and_input_value_in_range_of_int16
    (
        T_str   const   &   prompt,
        T_int           &   val
    )
{
    T_big_int   big_val     =   0;
 
    do
    {
        std::cout   <<  prompt;
        std::cin    >>  big_val;
    }
    while   (
                !number_is_in_range_of_int16( big_val )
            );
 
    val     =   static_cast< T_int >    ( big_val );
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    for(;;)
    {
        std::cout   <<  "Введите числа в диапазоне ("
                    <<  INT_16_MIN
                    <<  ".."
                    <<  INT_16_MAX
                    <<  "):"
                    <<  std::endl;
 
        T_int     a;
        T_int     b;
        print_prompt_and_input_value_in_range_of_int16( "a = ", a   );
        std::cout   <<  std::endl;
        print_prompt_and_input_value_in_range_of_int16( "b = ", b   );
        T_big_int   x   =   a - b;
 
        if  (
                number_is_in_range_of_int16( x )
            )
        {
            std::cout   <<  std::endl
                        <<  "x = "
                        <<  x
                        <<  std::endl;
        }
        else
        {
            std::cout   <<  "Результат вычислений находится вне допустимого диапазона."
                        <<  std::endl;
        }//else
        std::cout   <<  std::endl;
    }//for
}

/*
   Разработать алгоритм и написать программу вычисления заданного целочисленного
   выражения для данных в формате 16 битов со знаком, используя оператор IF.
   Промежуточные вычисления могут проводиться с использованием любых типов
   данных (с обоснованием выбора типа данных), а тип результата Х - тоже должен
   быть 16 битов со знаком. Входные данные и результат вычислений должны быть
   проверены на область допустимых значений.
   */
 
#include <iostream>
 
using namespace std;
 
bool isShort(int num){
    short x;
    x = num & 0xFFFF;
    return (x == num);
}
 
int main()
{
    setlocale(0, "");
 
    short  x;
    int a, b, temp;
 
    cout << "Input a: ";
    cin >> a;
 
    while (!isShort(a)) {
        cout << "Введенное число не 16-ти битовое " << endl;
        cin >> a;
    }
 
    cout << "Input b: ";
    cin >> b;
 
    while (!isShort(b)) {
        cout << "Введенное число не 16-ти битовое " << endl;
        cin >> b;
    }
 
    temp = a - b;       // выражение
 
    if (isShort(temp)) {
        x = static_cast<short>(temp);  // можно не преобразовать
        cout << "Результат: a - b = " << x;
    }
    else
        cout << "Результат получился не 16-ти битовое " << temp;
 
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//Разработать алгоритм и написать программу вычисления заданного целочисленного 
//выражения для данных в формате 16 битов со знаком, используя оператор IF. 
//Промежуточные вычисления могут проводиться с использованием любых типов данных 
//(с обоснованием выбора типа данных), а тип результата Х - тоже должен быть 
//16 битов со знаком. Входные данные и результат вычислений должны быть проверены 
//на область допустимых значений.
///////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <limits>
#include <stdint.h>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
typedef int16_t         T_int;
///////////////////////////////////////////////////////////////////////////////
const   T_int   INT_16_MIN  =   std::numeric_limits< T_int >::min();
const   T_int   INT_16_MAX  =   std::numeric_limits< T_int >::max();
///////////////////////////////////////////////////////////////////////////////
void    print_prompt_and_input_value_in_range_of_int16
    (
        T_str   const   &   prompt,
        T_int           &   val
    )
{
    do
    {
        std::cin.clear();
        std::cout   <<  prompt;
    }
    while   (
                !( std::cin    >>  val )
            );
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    for(;;)
    {
        std::cout   <<  "Введите числа в диапазоне ("
                    <<  INT_16_MIN
                    <<  ".."
                    <<  INT_16_MAX
                    <<  "):"
                    <<  std::endl;
 
        T_int     a;
        T_int     b;
        print_prompt_and_input_value_in_range_of_int16( "a = ", a   );
        std::cout   <<  std::endl;
        print_prompt_and_input_value_in_range_of_int16( "b = ", b   );
 
        std::stringstream   sstream;
        sstream     <<  a - b;
        T_int   x   =   0;
 
        if  (
                sstream     >>  x
            )
        {
            std::cout   <<  std::endl
                        <<  "x = "
                        <<  x
                        <<  std::endl;
        }
        else
        {
            std::cout   <<  "Результат вычислений находится вне допустимого диапазона."
                        <<  std::endl;
        }//else
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}