Определить, является ли введенный текст записью целого числа или записью вещественного числа

// Вхождение символа C в состав набора символов Charset
bool CharInCharset(char C, string Charset)
{
  while (*Charset)
    if (*Charset++ == C) return true;
    
  return false;
}
 
// Подсчёт количества вхождений символа C в строке S
UINT GetCharCount(char C, string S)
{
  UINT Count = 0;
  
  while (*S)
    if (*S++ == C) Count++;
    
  return Count;
}
 
// Проверка: строка есть целое десятичное число
bool StrIsDec(string S)
{
  if (!*S) return false; // строка пустая?
  if (*S == '0') return false; // с нуля - только восьмеричные числа
  if ((*S == '-') || (*S == '+')) S++; // Впереди может быть знак минус или плюс
  
  while (*S)
    if (!CharInCharset(*S++, DecDigits)) return false;
    
  return true;
}
 
// Проверка: строка есть целое шестнадцатеричное число
bool StrIsHex(string S)
{
  if (!*S) return false; // строка пустая?
  if (strnicmp(S, "0x", 2)) return false; // строка начинается на (0x | 0X)?
 
  S += 2; // Продвигаю указатель на 2 символа (пропускаю 0x)
 
  while (*S)
    if (!CharInCharset(*S++, HexDigits)) return false;
 
  return true;
}
 
// Проверка: строка есть целое восьмеричное число
bool StrIsOct(string S)
{
  if (!*S) return false; // строка пустая?
  if (strncmp(S, "0", 1)) return false; // строка начинается на 0?
 
  while (*S)
    if (!CharInCharset(*S++, OctDigits)) return false;
 
  return true;
}
 
// Проверка: строка есть число с плавающей точкой (дробное)
bool StrIsFloat(string S)
{
  int eCount = 0;
 
  if (!*S) return false; // строка пустая?
  if ((*S == '-') || (*S == '+')) S++; // Впереди может быть знак минус или плюс
 
  // Строка должна начинаться цифрой (если есть знак - после знака):
  if (!CharInCharset(*S, DecDigits)) return false;
  
  // Строка должна кончаться цифрой:
  if (!CharInCharset(S[strlen(S) - 1], DecDigits)) return false;
  
  // Десятичная точка может быть одна или не быть совсем
  if (GetCharCount('.', S) > 1) return false;
  
  // Показатель 10^x (e или E) может быть только 1 шт.
  eCount = GetCharCount('e', S) + GetCharCount('E', S);
  if (eCount > 1) return false;
 
  // Проверка валидности символов
  while (*S)
    if (!CharInCharset(*S++, FloatSymbols)) return false;
 
  return true;
}
 
// Перевод строки в 16-битное целое со знаком.
// Возвращает true, если строка есть (10-чное | 16-чное | 8-чное)
bool TryStr2Int(string S, int* Value)
{
  string Format;
  if (StrIsDec(S)) Format = "%d";
  else if (StrIsHex(S)) Format = "0x%x";
       else if (StrIsOct(S)) Format = "%o";
            else return false;
 
  return sscanf(S, Format, Value);
}
 
// Перевод строки в 32-битное целое со знаком.
// Возвращает true, если строка есть (10-чное | 16-чное | 8-чное)
bool TryStr2Long(string S, long* Value)
{
  string Format;
  if (StrIsDec(S)) Format = "%ld";
  else if (StrIsHex(S)) Format = "0x%lx";
       else if (StrIsOct(S)) Format = "%lo";
            else return false;
 
  return sscanf(S, Format, Value);
}
 
// Перевод строки в десятичное (с пл. точкой) со знаком
bool TryStr2Float(string S, float* Value)
{
  //AddStr2Log(S, "S"); // для отладки
 
  if (StrIsFloat(S))
    return sscanf(S, "%f", Value);
  else
    return false;
}
 
// Перевод строки в десятичное (с пл. точкой) со знаком двойной точности
bool TryStr2Double(string S, double* Value)
{
  //AddStr2Log(S, "S");
 
  if (StrIsFloat(S))
    return sscanf(S, "%lf", Value);
  else
    return false;
}
 
// Проверка длины введённого числа на разрядность
// BitCount = (16 | 32)
// ==== интервалы для 16 бит: ====
//  - -32768...+32767
//  - 0x0000...0xFFFF
//  - 0000000...0177777
// ==== интервалы для 32 бит: ====
//  - -2147483648...+2147483647
//  - 0x00000000...0xFFFFFFFF
//  - 00000000000...37777777777
bool CheckIntLength(string Value, char BitCount)
{
  string Limit; // Эталон
 
  // ----------- 16-битные ------------
  if (BitCount == 16)
  {
    if (StrIsDec(Value)) // Десятичные
    {
      if (*Value == '-')           Limit = "-32768";  // отрицательное
      else if (*Value == '+')      Limit = "+32767";  // положительное с плюсом
             else                  Limit = "32767";   // положительное, начинающееся с цифры
    } // if
    else if (StrIsHex(Value))      Limit = "0xFFFF";  // 16-ричные
         else if (StrIsOct(Value)) Limit = "0177777"; // 8-ричные
                else return false;                    // Ваще не число!
  } // if (BitCount == 16)
  
  // ----------- 32-битные ------------
  else
  {
    if (StrIsDec(Value)) // Десятичные
    {
      if (*Value == '-')           Limit = "-2147483648";  // отрицательное
      else if (*Value == '+')      Limit = "+2147483647";  // положительное с плюсом
             else                  Limit = "2147483647";   // положительное, начинающееся с цифры
    } // if
    else if (StrIsHex(Value))      Limit = "0xFFFFFFFF";   // 16-ричные
         else if (StrIsOct(Value)) Limit = "37777777777";  // 8-ричные
                else return false;                         // Ваще не число!
  } // else
  
  // сразу на выход, если длина строки не равна длине эталона
  // функция strcmpi() выдаёт тогда неверный результат, а мне оно не надо
  if (strlen(Limit) < strlen(Value)) return false;
  if (strlen(Limit) > strlen(Value)) return true;
  
  // И только при равенстве длин этих строк их можно нормально сравнивайть побайтно
  if (strcmpi(Value, Limit) > 0) return false;
  else                           return true;
}