基本思路
十进制转换为N进制的基本方法：除N取余法
方法介绍（十转十六为例）
例如300转换为十六进制：

300 ÷ 16 = 18 ……余12即C

18 ÷ 16 = 1……余2即2

1 ÷16 = 0……余1即1

此时结果为0，结束取余，将取出的余数逆向排列即：12C

则12C即为300的十六进制数

总结为：除十六取余直至结果为0，最后将余数逆向排列
C++代码
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
 string str;
 char c;
 int x,t,i = 0,sum = 0;
 cin >> x;
 do
 {
  t = x % 16;
  x = x / 16;
  if (t < 10)
  {
   c = '0' + t;
   str = c + str;
  }
  else
  {
   c = 'A' + t - 10;
   str = c + str;
  }
 } while (x);
 cout << str;
 return 0;
}
注：字符c与字符串衔接时，需要前接。

在介绍这个方法之前，我想来介绍一下移位运算符

          移位运算符分为左移和右移

          左移:相当于把当前的数值的二进制位数左移移位，末尾进行0补齐

          右移:相当于把当前的数值的二进制位数右移移位，分为逻辑右移和算数右移

                   算术右移(>>):若是无符号数，则空缺补0，若是负数，空缺补1

                   逻辑右移(>>>):不管是什么类型，空缺自动补0

                   例如:i=15(0000 1111),移位两位 i>>2 ，i变为0000 0011(3)

                   一般在实际操作中多用>>>

算法思想

         如果是要转换为16进制,则我们把要进行转换的数值num与15(1111)进行‘与’运算，得到的结果正好是末尾4位的二进制值,然后用10进制能够进行表示，然后我们把num>>>4,把新得到的最后4位来再次进行计算来结果，如果num为0则不必再进行移位操作。同理转换为8进制或者2进制,我们只需要把进行15(1111)依次的变为7(111)/1(1)，然后相应的移位的位数进行修改即可

代码

    /*base代表满多少进1，offset代表右移多少位数*/
    public static void trans(int num,int base ,int offset)
    {
        if(num == 0)
        {
                System.out.println("0");
                return;
        }
        //对应关系表
        char chs []={'0','1','2','3','4',
                    '5','6','7','8',
                    '9','A','B','C',
                    'D','E','F'};
        /*定义一个临时容器*/
        char arr []=new char [32];//因为int是4个字节是32位

        int pos = arr.length;
        while (num!=0)
        {
            int temp = num & base; //与当前位数进行‘与’运算求得最后4/3/1位数的结果
            arr[--pos] = chs[temp];//逆置存储得到的结果
            num = num >>> offset; //右移
        }
        for(int x =pos;x<arr.length;x++)
            System.out.print(arr[x]);
        System.out.println();

    }

 

方法1:使用进制转换
转载：https://zhidao.baidu.com/question/51006929.html
#include <stdio.h>
#include <string.h>
 
/* 十六进制数转换为十进制数 */
long hexToDec(char *source);
 
/* 返回ch字符在sign数组中的序号 */
int getIndexOfSigns(char ch);
 
int main()
{
    char *hex = "75BCD15";
 
    printf("16进制数：\t%s\n", hex);
    printf("10进制数：\t%ld\n", hexToDec(hex));
 
    return 0;
}
 
/* 十六进制数转换为十进制数 */
long hexToDec(char *source)
{
    long sum = 0;
    long t = 1;
    int i, len;
 
    len = strlen(source);
    for(i=len-1; i>=0; i--)
    {
        sum += t * getIndexOfSigns(*(source + i));
        t *= 16;
    }  
 
    return sum;
}
 
/* 返回ch字符在sign数组中的序号 */
int getIndexOfSigns(char ch)
{
    if(ch >= '0' && ch <= '9')
    {
        return ch - '0';
    }
    if(ch >= 'A' && ch <='F') 
    {
        return ch - 'A' + 10;
    }
    if(ch >= 'a' && ch <= 'f')
    {
        return ch - 'a' + 10;
    }
    return -1;
}
方法2：可以使用sscanf函数将以字符串形式的十六进制数转换为整型的十六进制
sscanf函数的用法与printf函数很像，都是以格式化的形式进行操作，例如如下的例子中，sscanf("A23CD", "%x", &a);
"%x"是将字符串A23CD以十六进制形式输入a中，如果将"%x"换成为"%d"的话，就是将字符串A23CD以十进制形式输入a中，这显然是错误的，因为将A23CD转换为十进制的时候，无法解析A，CD等字符，所以得出的结果就是错误的。
int a;
sscanf("A23CD", "%x", &a);
printf("%x\n",a);
printf("%d\n",a);
linux@ubuntu:~/test$ ./a.out 
a23cd
664525

代码如下:
# -*- coding = utf-8 -*-
# @Time : 2021/1/23 16:10
# @Author : Suage
# @File : SysConvert.py

from threading import Lock


class StringBuilder:
    def __init__(self, content=None, convert_way='STR', convert_function=None):
        if content is None:
            self.content = list()
        elif isinstance(content, str):
            self.content = list(content)
        else:
            if convert_way.lower() == 'str':
                self.content = list(str(content))
            elif convert_way.lower() == 'repr':
                self.content = list(repr(content))
            else:
                self.content = list(convert_function(content))

    def get_str(self):
        """
        以字符串形式输出内容

        :return: 内容
        """
        return ''.join(self.content)

    def append(self, text, location=-1):
        if location == -1:
            self.content.extend(text)
        else:
            for c in text: self.content.insert(location, c)

    def reverse(self):
        self.content.reverse()


class SysConvert:
    __unit: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_'

    def __init__(self):
        self.__lock = Lock()
        self.__input_number: str
        self.__sys_in: int
        self.__sys_out: int

    def set_unit(self, unit):
        """
        设置计数用字符

        :param unit: 计数用字符序列
        """
        self.__unit = unit

    def num_split(self):
        """
        拆解数字的整数部分和小数部分
        :return: 整数部分, 小数部分
        """
        return self.__input_number.split('.')

    def __is_int(self):
        """
        判断输入数字是否为整数
        :return: 整数返回True, 小时返回False
        """
        if '.' in self.__input_number: return False
        return True

    def __concert(self, input_num, input_sys, output_sys):
        """
        执行转换
        :return:转换结果
        """
        self.__input_number: str = input_num.upper().replace(' ', '')
        if self.__input_number[0] == '-':
            self.sign = False
            self.__input_number = self.__input_number[1:]
        else:
            self.sign = True
        self.__sys_in: int = input_sys
        self.__sys_out: int = output_sys
        is_int = self.__is_int()
        if is_int:
            if self.input_error(self.__input_number):
                return 'input error'
            return self.__int_concert(self.__input_number)

        int_part, float_part = self.num_split()

        if self.input_error(int_part) or self.input_error(float_part):
            return 'input error'

        number_part = f'{self.__int_concert(int_part)}.{self.__float_concert(float_part)}'
        if self.sign:
            return number_part
        return f'-{number_part}'

    def concert(self, input_num, input_sys, output_sys):
        """
        执行转换

        :param input_num: 输入数字
        :param input_sys: 输入数字进制
        :param output_sys: 输出数字进制
        :return: 转换结果
        """
        self.__lock.acquire()
        try:
            res = self.__concert(input_num, input_sys, output_sys)
        finally:
            self.__lock.release()
        return res

    def __int_concert(self, int_part):
        """
        整数部分转换为目标进制

        :param int_part: 要转换的数字
        :return: 转换结果
        """
        number = self.__any_sys_to_int(int_part)
        return self.__int_to_any_sys(number)

    def __any_sys_to_int(self, number):
        """
        将任何进制的整数部分转换为计算机可运算的整数类型

        :param number: 要转换的整数部分
        :return: 转换结果
        """
        res = 0
        number = number[::-1]
        for i in range(len(number)):
            res += self.__unit.index(number[i]) * pow(self.__sys_in, i)
        return res

    def __int_to_any_sys(self, num):
        """
        将整数类型的数字装换为目标进制的数字
        :param num: 要转换的数字
        :return: 转换结果
        """
        _sb: StringBuilder = StringBuilder()
        while True:
            num, y = divmod(num, self.__sys_out)
            _sb.append(self.__unit[y])
            if num < self.__sys_out:
                _sb.append(self.__unit[num])
                break
        _sb.reverse()
        return _sb.get_str().lstrip("0")

    def __float_concert(self, float_part):
        """
        小数部分转换为目标进制

        :param float_part: 要转换的小数部分(小数点后的部分)
        :return: 转换结果(小数点后面部分)
        """
        number = self.__any_sys_to_float(float_part)
        return self.__float_to_any_sys(number)

    def __any_sys_to_float(self, number):
        """
        将任何进制的整数部分转换为计算机可运算的整数类型

        :param number: 要转换的整数部分
        :return: 转换结果
        """
        res = 0
        number = number
        for i in range(len(number)):
            res += self.__unit.index(number[i]) * pow(1 / self.__sys_in, (i + 1))
        return res

    def __float_to_any_sys(self, num):
        """
        将整数类型的数字装换为目标进制的数字
        :param num: 要转换的数字
        :return: 转换结果
        """
        _sb: StringBuilder = StringBuilder()
        n = num
        for _ in range(15):
            n = n * self.__sys_out
            n_int = int(n)
            n = n - n_int
            _sb.append(self.__unit[n_int])
            if n == 0: break
        return _sb.get_str()

    def input_error(self, num):
        for c in num:
            if self.__unit.index(c) >= self.__sys_in: return True
        return False


if __name__ == '__main__':
    c1 = SysConvert()
    res1 = c1.concert(input_num='BYSUAGE.I', input_sys=36, output_sys=6)
    res2 = c1.concert(input_num=res1, input_sys=6, output_sys=36)
    print(res1, res2, sep='\n')

运行结果:

15544450142422.3

BYSUAGE.I
写了将近6个小时才写完, 好累…