Перевод числа из hex в dec

#include <iostream>
#include <string>
#include <stack>
#include <strstream>
 
using namespace std;
 
pair<int, string> divide_by_10(const string& dividend);
 
int main()
{
 
    string hex_str = "ABCDEF1";
    stack<int> digits;
    pair<int, string> residual_quotient;
 
    cout << "Hex string: " << hex_str << endl;
 
    while (hex_str != "0")
    {
        residual_quotient = divide_by_10(hex_str);
        digits.push(residual_quotient.first);
        hex_str = residual_quotient.second;
    }
 
    cout << "Dec string: ";
    while (!digits.empty())
    {
        cout << digits.top();
        digits.pop();
    }
    cout << endl;
    
}
 
pair<int, string> divide_by_10(const string& dividend)
{
    string quotient, tmp;
    int residual = 0,
        dividend_num;
    size_t length = dividend.length();
    strstream converter;
 
    for (size_t i = 0; i < length; ++i)
    {
        converter << dividend[i] << endl;
        converter >> hex >> dividend_num;
 
        dividend_num += residual * 16;
        residual = dividend_num % 10;
 
        converter << hex << (dividend_num / 10) << endl;
        converter >> tmp;
        quotient.append(tmp);
 
    }
 
    if ((quotient[0] == '0') && (quotient.length() > 1))
        quotient.erase(quotient.begin(), ++quotient.begin());
 
    return make_pair(residual, quotient);
}

///////////////////////////////////////////////////////////////////////////////
//1.
///////////////////////////////////////////////////////////////////////////////
//как можно перевести 16-ричное число произвольной длины
//(например, заданное с помощью строки) в десятичную сс?
//(также можно в строку)
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                 T_str;
typedef std::vector     < int   >   T_big_num;
///////////////////////////////////////////////////////////////////////////////
void    mult_to_16( T_big_num   &   big_num )
{
    for( auto   &   elem    :   big_num )
    {
        elem    *=  16;
    }
}
///////////////////////////////////////////////////////////////////////////////
void    add_to_bignum
    (
        T_big_num   &   big_num,
        int             num
    )
{
    big_num.front()  +=  num;
}
///////////////////////////////////////////////////////////////////////////////
void    normalize( T_big_num   &   big_num )
{
    int     remainder{};
 
    for( auto   &   elem    :   big_num )
    {
        elem        +=  remainder;
        remainder   =   elem / 10;
        elem        %=  10;
    }//for
 
    if( remainder )
    {
        big_num.push_back( remainder );
    }
 
    if  (
            big_num.back()  >   9
        )
    {
        normalize( big_num );
    }
}
///////////////////////////////////////////////////////////////////////////////
T_str   big_num_to_str( T_big_num   &   big_num )
{
    T_str   res;
 
    std::transform
        (
            big_num.rbegin      (),
            big_num.rend        (),
            std::back_inserter  ( res ),
 
            []  ( auto  num )
            {
                return  '0'     +   num;
            }
        );
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
T_str   hex_to_dec( T_str   const   &   hex_str )
{
    T_big_num   big_num_res(1);
 
    for( auto   &   dig_symb    :   hex_str )
    {
        mult_to_16( big_num_res );
 
        auto    dig     =   std::stoi   (
                                            T_str( 1, dig_symb ),
                                            0,
                                            16
                                        );
 
        add_to_bignum
            (
                big_num_res,
                dig
            );
 
        normalize( big_num_res );
    }//for
 
    return  big_num_to_str( big_num_res );
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_str   s   =   "FFAADA5343DADADAE45343FFFAFCEFFAADA5343DADADAE4534"
                    "3FFFAFCEFFAADA5343DADADAE45343FFFAFCE";
 
    std::cout   <<  hex_to_dec(s)
                <<  std::endl;
}

while(hex_str != "0")
{ ... }

do
{ ...  } while(hex_str != "0")

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
 
unsigned f_fromHex(const char& digit)
{
    switch (digit)
    {
    case 'A':
        return 10;
        break;
    case 'B':
        return 11;
        break;
    case 'C':
        return 12;
        break;
    case 'D':
        return 13;
        break;
    case 'E':
        return 14;
        break;
    case 'F':
        return 15;
        break;
    default:
        return digit - '0';
        break;
    }
}
 
unsigned f_convert(const string& str);
 
void f_strDevide(string& number, string& result)
{
    string forReturn;
    
    auto temp(0u);
    for (auto head(number.cbegin()), cur(head), end(number.cend() - 1);
        head != end; ++head)
    {
        temp = f_convert(string(cur, head + 1));
 
        if (temp / 10)
        {
            forReturn += to_string(temp / 10);
            cur = head;
            temp = 0;
        }
        else if (!forReturn.empty())
        {
            forReturn.push_back('0');
        }
    }
}
 
string f_toDec(string hex)
{
    string result;
 
    while (hex.size() > 1)
        f_strDevide(hex, result);
 
    auto digit(f_fromHex(*hex.begin()));
    result += to_string(digit % 10);
 
    if (digit /= 10)
        result += to_string(digit);
 
    reverse(hex.begin(), hex.end());
    return result;
}
 
int main()
{
    string number("1FFFF");
    system("pause");
}