Подсчитать количество цифр в числе, которое находится по формуле

#include <iostream>
#include <conio.h>
#include <cstring>
using namespace std;
 
class suma
{
    double x,y,z;
public:
    void get_xy()
    {
    cout<<"Введите x: ";
    cin>>x;
    cout<<"Введите y: ";
    cin>>y;
    cout<<"Введите z: ";
    cin>>z;
    }
double sum_xy()
{   
    cout<<"Средняя геометрическая прогрессия = ";
    return (x*y*z)/3;
}
} s1;
void main()
{
    setlocale(LC_ALL,"RUS");
    s1.get_xy();
    cout<<s1.sum_xy()<<"\n";
    system("pause");
}

    double n = 4.1234567;
    double e = 0.0000001;
    n = n - (int)n;
    int i = 0;
    int k = 0;
    do
    {
        n *= 10;
        cout << (int)n % 10;
        i++; //количество цифр после запятой
    } while (n - (int)n >= e);

/////////////////////////////////////////////////////////////////////////////////////////
//Подсчитать количество цифр в числе.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
int     count_digits_in_num( double     x )
{
    x   =   abs(x);
 
    std::ostringstream  sout;
 
    sout    <<  std::fixed
 
            <<  std::setprecision
                    (
                        std::numeric_limits<double>::digits10 + 5
                    )
 
            <<  x;
 
    T_str   str_val     =   sout.str();
 
    //test////////////////////////////////////////
    std::cout   <<  str_val
                <<  std::endl;
    //test////////////////////////////////////////
 
    auto    point_it    =   std::find_if
                                (
                                    str_val.begin   (),
                                    str_val.end     (),
 
                                    std::not1       (
                                                        std::ptr_fun( isdigit )
                                                    )
                                );
 
    if  (
            point_it    !=  str_val.end()
        )
    {
        while   (
                    str_val.back()  ==  '0'
                )
        {
            str_val.pop_back();
        }
 
        str_val.erase( point_it );
    }//if
 
    //test////////////////////////////////////////
    std::cout   <<  str_val
                <<  std::endl;
    //test////////////////////////////////////////
 
    return  str_val.size();
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "numerator\ta\t\t: ";
 
        double  a   =   0;
        std::cin    >>  a;
 
        double  b   =   0;
 
        do
        {
            std::cout   <<  "denominator\tb (!= 0)\t: ";
            std::cin    >>  b;
        }
        while( b == 0 );
 
        std::cout   <<  "digits in number a/b\t\t: "
                    <<  count_digits_in_num( a / b )
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}

typedef std::string     T_str;

x   =   abs(x);

std::numeric_limits<double>::digits10 + 5

isdigit

std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl

std::cout   <<  "\n\n\n"

#include <math.h>
#include <stdio.h>
 
int main()
{
    double d = abs(1.5);
    printf("%f\n", d);
}

std::cout << "\n\n\n"

/////////////////////////////////////////////////////////////////////////////////////////
//Подсчитать количество цифр в числе.
/////////////////////////////////////////////////////////////////////////////////////////
//В программе две различные функции для вычисления количества цифр в числе с плавающей точкой,
//выдающие одинаковый результат.
//
//Функция count_digits_in_num вычисляет количество цифр исходя из длин целой и дробной частей
//мантиссы и значения экспоненты.
//
//Функция count_digits_in_num_and_test_print манипулирует строковыми представлениями числа
//и выводит на печать тестовую информацию.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
typedef double          T_real;
/////////////////////////////////////////////////////////////////////////////////////////
int     count_digits_in_num( T_real     x )
{
    x   =   abs(x);
 
    std::ostringstream  sout;
 
    sout    <<  std::scientific
 
            <<  std::setprecision
                    (
                        std::numeric_limits<T_real>::digits10
                    )
 
            <<  x;
 
    T_str   str_val     =   sout.str();
 
    auto    e_it        =   std::find
                                (
                                    str_val.begin   (),
                                    str_val.end     (),
                                    'e'
                                );
 
    T_str   mantissa_str
                (
                    str_val.begin(),
                    e_it
                );
 
    auto    point_it    =   std::find_if
                                (
                                    mantissa_str.begin  (),
                                    mantissa_str.end    (),
 
                                    std::not1           (
                                                            std::ptr_fun( isdigit )
                                                        )
                                );
 
    while   (
                mantissa_str.back() == '0'
            )
    {
        mantissa_str.pop_back();
    }
 
    int     whole_part_len  =   std::distance
                                    (
                                        mantissa_str.begin(),
                                        point_it
                                    );
 
    int     frac_part_len   =       mantissa_str.size()
                                -   whole_part_len
                                -   1;
 
    T_str   exponent_str
                (
                    e_it + 1,
                    str_val.end()
                );
 
    auto    exponent    =   stoi( exponent_str );
 
    return  exponent    >=  0
                ?       whole_part_len
 
                    +   std::max
                            (
                                exponent,
                                frac_part_len
                            )
 
                :       std::max
                            (
                                abs( exponent ) + 1,
                                whole_part_len
                            )
 
                    +   frac_part_len;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     count_digits_in_num_and_test_print( T_real  x )
{
    x   =   abs(x);
 
    std::ostringstream  sout;
 
    sout    <<  std::scientific
 
            <<  std::setprecision
                    (
                        std::numeric_limits<T_real>::digits10
                    )
 
            <<  x;
 
    T_str   str_val     =   sout.str();
 
    //test////////////////////////////////////////
    std::cout   <<  str_val
                <<  std::endl;
    //test////////////////////////////////////////
 
    auto    e_it        =   std::find
                                (
                                    str_val.begin   (),
                                    str_val.end     (),
                                    'e'
                                );
 
    T_str   mantissa_str
                (
                    str_val.begin(),
                    e_it
                );
 
    //test////////////////////////////////////////
    std::cout   <<  mantissa_str
                <<  std::endl;
    //test////////////////////////////////////////
 
    auto    point_it    =   std::find_if
                                (
                                    mantissa_str.begin  (),
                                    mantissa_str.end    (),
 
                                    std::not1           (
                                                            std::ptr_fun( isdigit )
                                                        )
                                );
 
    auto    point_pos   =   std::distance
                                (
                                    mantissa_str.begin(),
                                    point_it
                                );
 
    while   (
                mantissa_str.back() == '0'
            )
    {
        mantissa_str.pop_back();
    }
 
    //test////////////////////////////////////////
    std::cout   <<  mantissa_str
                <<  std::endl;
    //test////////////////////////////////////////
 
    T_str   exponent_str
                (
                    e_it + 1,
                    str_val.end()
                );
 
    //test////////////////////////////////////////
    std::cout   <<  exponent_str
                <<  std::endl;
    //test////////////////////////////////////////
 
    auto    exponent    =   stoi( exponent_str );
 
    //test////////////////////////////////////////
    std::cout   <<  exponent
                <<  std::endl;
    //test////////////////////////////////////////
 
    while( exponent > 0 )
    {
        --exponent;
 
        if  (
                !isdigit
                    (
                        mantissa_str.back()
                    )
            )
        {
            mantissa_str.insert
                (
                    point_pos,
                    1,
                    '0'
                );
        }
        else
        {
            std::swap
                (
                    mantissa_str[ point_pos     ],
                    mantissa_str[ point_pos + 1 ]
                );
        }//else
 
        ++point_pos;
    }//while
 
    while( exponent < 0 )
    {
        ++exponent;
 
        if  (
                !isdigit
                    (
                        mantissa_str.front()
                    )
            )
        {
            mantissa_str.insert
                (
                    point_pos + 1,
                    1,
                    '0'
                );
        }
        else
        {
            std::swap
                (
                    mantissa_str[ point_pos     ],
                    mantissa_str[ point_pos - 1 ]
                );
 
            --point_pos;
        }//else
    }//while
 
    //test////////////////////////////////////////
    std::cout   <<  mantissa_str
                <<  std::endl;
    //test////////////////////////////////////////
 
    int     res     =   mantissa_str.size();
 
    if  (
            point_pos   !=  0
        )
    {
        --res;
    }
 
    return  res;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "numerator\ta\t\t: ";
 
        T_real  a   =   0;
        std::cin    >>  a;
 
        T_real  b   =   0;
 
        do
        {
            std::cout   <<  "denominator\tb (!= 0)\t: ";
            std::cin    >>  b;
        }
        while( b == 0 );
 
        std::cout   <<  "count_digits_in_num_and_test_print\t( a / b ): "
                    <<  count_digits_in_num_and_test_print( a / b )
                    <<  std::endl
 
                    <<  "count_digits_in_num\t\t\t( a / b ): "
                    <<  count_digits_in_num( a / b )
                    <<  std::endl
 
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}