Дробные числа: перевод в другую систему счисления

#include <iostream>
 
using namespace std;
 
int main()
{
    setlocale(LC_ALL, "rus");
    int n, b, k, c;
    cout << "Введите число в 10-ой системе счисления" << endl;
    cin >> n;
    k = 1;
    c = 0;
    while (n > 0)
    {
        b = n % 8; //остаток от деления на 8
        n /= 8;  //деление на 8 (уменьшение)
        c += b * pow(10, k - 1); //остаток от деления умножить на 10 в степени  к-1
        b = 0;   //для того что бы можно было вновь занести остаток при делении на 8
        k++; //увеличение на 1 (для степени)
    }
    
  
      
    cout <<"В 8-ой системе счисления: "<< c<< endl;
    return 0;
}

/******************************************************************************/
/*                          Verevkin, CodeBlocks c++                          */
/******************************************************************************/
 
 
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
 
/* 123.45 = 1 * 8^2 + 2 * 8^1 + 3 * 8^0 + 4 * 8^-1 + 5 * 8^-2 =
          = 64 + 16 + 3 + 0.5 + 0.078125 = 83,578125
 
   1010011.100101 = 0x53 + 1/2 + 1/16 + 1/64 =
                  = 83 + 0.5 + 0,0625 + 0,015625 = 83,578125 */
 
#define isoctal(x) (x > 0x2F && x < 0x38)
#define ishexademical(x) (isdigit(x) || (x > 0x40 && x < 0x47) || (x > 0x60 && x < 0x67))
 
// обрезка нулей слева и справа
char* trim_zeroes(char* src)
{
  // обрезка справа
  char* ptr = src + strlen(src) - 1;
  while (ptr > src && *ptr == '0') *ptr-- = 0;
 
  // обрезка слева
  ptr = src;
  while (*ptr == '0' && *(ptr + 1) != '.') ptr++;
 
  if (!*ptr) strcpy(src, "0");
  else strcpy(src, ptr);
 
  return src;
}
 
   
 
bool is_oct_str(char* src)
{
  if (!src || !*src) return false;
 
  int pc = 0;
  while (*src)
  {
    if (*src == '.') pc++;
    else if (!isoctal(*src)) return false;
    src++;
  }
 
  return pc < 2;
}
 
bool is_hex_str(char* src)
{
  if (!src || !*src) return false;
 
  int pc = 0;
  while (*src)
  {
    if (*src == '.') pc++;
    else if (!ishexademical(*src)) return false;
    src++;
  }
 
  return pc < 2;
}
 
bool is_dec_str(char* src)
{
  if (!src || !*src) return false;
 
  int pc = 0;
  while (*src)
  {
    if (*src == '.') pc++;
    else if (!isdigit(*src)) return false;
    src++;
  }
 
  return pc < 2;
}
 
 
char* oct2bin(char* src, char* dest)
{
  static const char* TRIADE[8] =
    {"000", "001", "010", "011", "100", "101", "110", "111"};
 
  char* ptr = dest;
  *dest = 0;
 
  while (*src)
    if (isoctal(*src)) strcat(ptr, TRIADE[*src++ - 0x30]);
    else strncat(ptr, src++, 1); // копирование невосьмеричного символа
 
  return trim_zeroes(dest);
}
 
int get_hex_index(char hex_digit)
{
  if (isdigit(hex_digit)) return hex_digit - 0x30;
  return (hex_digit > 0x60) ? hex_digit - 0x57 : hex_digit - 0x37;
}
 
char* hex2bin(char* src, char* dest)
{
  static const char* TETRADE[16] =
    {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
     "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"};
 
  char* ptr = dest;
  *dest = 0;
 
  while (*src)
    if (ishexademical(*src)) strcat(ptr, TETRADE[get_hex_index(*src++)]);
    else strncat(ptr, src++, 1); // копирование нешестнадцатеричного символа
 
  return trim_zeroes(dest);
}
 
bool try_oct2numb(char* src, double &value)
{
  if (!is_oct_str(src)) return false; // неверный ввод
 
  value = 0.0; 
  char* dot_pos = strchr(src, '.');
  
  if (!dot_pos) 
  {
    uint64_t temp;
    sscanf(src, "%I64o", &temp);
    value = temp;
    return true; // целое
  }
  
  char* frac_pos = dot_pos + 1; // начало дробной части
  
  // целая часть
  uint64_t int_factor = 1; // положительная степень числа 8
  while (--dot_pos >= src)  
  {
    value += int_factor * (*dot_pos - 0x30);   
    int_factor *= 8;
  }
  
  // дробная часть 
  double frac_factor = 0.125; // 1.0 / 8.0;
  
  while (*frac_pos)
  {
    value += frac_factor * (*frac_pos++ - 0x30);   
    frac_factor /= 8.0;
  }
  
  return true;
}
 
bool try_hex2numb(char* src, double &value)
{
  if (!is_hex_str(src)) return false; // неверный ввод
 
  value = 0.0; 
  char* dot_pos = strchr(src, '.');
  
  if (!dot_pos) 
  {
    uint64_t temp;
    sscanf(src, "%I64x", &temp);
    value = temp;
    return true; // целое
  }
  
  char* frac_pos = dot_pos + 1; // начало дробной части
  
  // целая часть
  uint64_t int_factor = 1; // положительная степень числа 16
  while (--dot_pos >= src)  
  {
    value += int_factor * get_hex_index(*dot_pos);   
    int_factor *= 16;
  }
  
  // дробная часть 
  double frac_factor = 0.0625; //1.0 / 16.0;
  
  while (*frac_pos)
  {
    value += frac_factor * get_hex_index(*frac_pos++);   
    frac_factor /= 16.0;
  }
  
  return true;
}
 
// разделение строки на 2 части по первой точке.
// Если точки нет, то вернёт left = src, right будет пустой строкой.
char* point_split(char* src, char* left, char* right)
{
  char* dot_pos = strchr(src, '.');
  
  if (!dot_pos) // точки нет
  {
    strcpy(left, src);
    *right = 0;
  }
  else // точка есть
  {
    strncpy(left, src, (dot_pos - src) / sizeof(char));
    strcpy(right, dot_pos + 1);
  }
  
  left[strlen(left)] = 0; // особенность strncpy()
  return left;
}
 
// перевод десятичного числа с фиксированной точкой в восьмеричную СС
// Пример для отладки 132.267(10) ----->204.2105(8)
bool try_dec2oct(char* src, char* dest)
{
  if (!is_dec_str(src)) return false; // неверный ввод
 
  char value[128], frac[128]; // буфера
  point_split(src, value, frac); // разделение
 
  uint64_t int_part = 0; // целая часть
  sscanf(value, "%I64u", &int_part);
  sprintf(dest, "%I64o", int_part);
  
  // дробная часть    
  unsigned frac_len = strlen(frac); 
  
  if (frac_len) // есть дробная часть
  {
    double frac_part; // дробная часть (с погрешностью)
    
    strcpy(value, "0.");
    strcat(value, frac);
    sscanf(value, "%lf", &frac_part);
   
    strcat(dest, ".");
    char* dptr = dest + strlen(dest);
    frac_len++; // корректировка кол-ва восьмеричных разрядов   
      
    while (frac_len--)
    {
      int_part = (unsigned)(8 * frac_part);
      *dptr++ = (char)(0x30 + int_part);
      frac_part = (8 * frac_part) - int_part;
    }
  }
   
  trim_zeroes(dest); 
  return true;
}
 
int main(int argc, char** argv)
{
  system("chcp 65001 & cls");
  char key, src[340], dest[1024];
 
  do
    {
      do printf("\n ?? Введи десятичное число: "); 
         //printf("\n ?? Введи восьмеричное число: "); 
         //printf("\n ?? Введи шестнадцатеричное число: "); 
      while (!gets(src));
 
      if (!is_dec_str(src)) 
         //(!is_oct_str(src)) 
         //(!is_hex_str(src)) 
      {
        printf(" !! Неверный ввод.\n");
        continue;
      }
 
      //printf(" ## Двоичный вид: %s\n", oct2bin(src, dest));
      //printf(" ## Двоичный вид: %s\n", hex2bin(src, dest));
      
      /*double value;
      if (try_oct2numb(src, value)) // (try_hex2numb(src, value))
        printf(" ## Десятичный вид: %.18lg\n", value);
      else printf(" ## Десятичный вид: ERROR\n");   */
      if (try_dec2oct(src, dest)) 
        printf(" ## Восьмеричный вид: %s\n", dest);
      else printf(" ## Восьмеричный вид: ERROR\n");
      
      printf("\n >> Ещё разок? [y/n]: ");
      key = getch();
    }
    while (key != 'n' && key != 'N' );
 
  printf("\n >> Жмакни чо-нить для выхода...");
  getch(); // ожидание клавиши
 
  return 0;
}