ASCII码表以及不同进制间的O(1)转换

一、ASCII码表

ASCII全称为American Standard Code for Information Interchange，美国信息交换标准代码。其值范围为0-127，总共128个字符。

下面我们对着128个字符进行输出，分为五列：二进制、八进制、十进制、十六进制、字符。具体程序如下：

// 生成ASCII码表

#include <iostream>

#include <fstream>

#include <string>

using namespace std;

string IntTo_(int num, int radix, string& ret)

{

    int index = ret.size() - ;

    while (num != )

    {

        int tmp = num % radix;

        if (tmp != )

        {

            if (tmp < )

            {

                ret[index] = '' + tmp;

            }

            else

            {

                ret[index] = 'A' + tmp - ;

            }

        }

        num /= radix;

        --index;

    }

    return ret;

}

string IntToBinary(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

string IntToOct(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

string IntToDec(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

string IntToHex(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

void CreateASCII(int begin, int end)

{

    if (begin <  || end > ) // 越界

    {

        return;

    }

    ofstream fout("result.txt");

    if (!fout)

    {

        cerr << "File error!" << endl;

        exit();

    }

    cout << "二进制\t\t八进制\t十进制\t十六进制\t字符\n";

    fout << "二进制\t\t八进制\t十进制\t十六进制\t字符\n";

    for (auto i = begin; i <= end; ++i)

    {

        cout << IntToBinary(i) << '\t' << IntToOct(i) << '\t' << IntToDec(i) << '\t' << IntToHex(i) << '\t' << '\t' << (char)i << endl;

        fout << IntToBinary(i) << '\t' << IntToOct(i) << '\t' << IntToDec(i) << '\t' << IntToHex(i) << '\t' << '\t' << (char)i << endl;

    }

}

int main()

{

    CreateASCII(, );

    //CreateASCII('A', 'Z');

    //CreateASCII('a', 'z');

    //CreateASCII('0', '9');

    return ;

}

二进制        八进制    十进制    十六进制    字符

00000000    000    000    00

00000001    001    001    01

00000010    002    002    02

00000011    003    003    03

00000100    004    004    04

00000101    005    005    05

00000110    006    006    06

00000111    007    007    07

00001000    010    008    08

00001001    011    009    09

00001010    012    010    0A        

00001011    013    011    0B

00001100    014    012    0C

00001101    015    013    0D        

00001110    016    014    0E

00001111    017    015    0F

00010000    020    016    10

00010001    021    017    11

00010010    022    018    12

00010011    023    019    13

00010100    024    020    14

00010101    025    021    15

00010110    026    022    16

00010111    027    023    17

00011000    030    024    18

00011001    031    025    19

00011010    032    026    1A

00011011    033    027    1B

00011100    034    028    1C

00011101    035    029    1D

00011110    036    030    1E

00011111    037    031    1F

00100000    040    032    20

00100001    041    033    21        !

00100010    042    034    22        "

00100011    043    035    23        #

00100100    044    036    24        $

00100101    045    037    25        %

00100110    046    038    26        &

00100111    047    039    27        '

00101000    050    040    28        (

00101001    051    041    29        )

00101010    052    042    2A        *

00101011    053    043    2B        +

00101100    054    044    2C        ,

00101101    055    045    2D        -

00101110    056    046    2E        .

00101111    057    047    2F        /

00110000    060    048    30        0

00110001    061    049    31        1

00110010    062    050    32        2

00110011    063    051    33        3

00110100    064    052    34        4

00110101    065    053    35        5

00110110    066    054    36        6

00110111    067    055    37        7

00111000    070    056    38        8

00111001    071    057    39        9

00111010    072    058    3A        :

00111011    073    059    3B        ;

00111100    074    060    3C        <

00111101    075    061    3D        =

00111110    076    062    3E        >

00111111    077    063    3F        ?

01000000    100    064    40        @

01000001    101    065    41        A

01000010    102    066    42        B

01000011    103    067    43        C

01000100    104    068    44        D

01000101    105    069    45        E

01000110    106    070    46        F

01000111    107    071    47        G

01001000    110    072    48        H

01001001    111    073    49        I

01001010    112    074    4A        J

01001011    113    075    4B        K

01001100    114    076    4C        L

01001101    115    077    4D        M

01001110    116    078    4E        N

01001111    117    079    4F        O

01010000    120    080    50        P

01010001    121    081    51        Q

01010010    122    082    52        R

01010011    123    083    53        S

01010100    124    084    54        T

01010101    125    085    55        U

01010110    126    086    56        V

01010111    127    087    57        W

01011000    130    088    58        X

01011001    131    089    59        Y

01011010    132    090    5A        Z

01011011    133    091    5B        [

01011100    134    092    5C        \

01011101    135    093    5D        ]

01011110    136    094    5E        ^

01011111    137    095    5F        _

01100000    140    096    60        `

01100001    141    097    61        a

01100010    142    098    62        b

01100011    143    099    63        c

01100100    144    100    64        d

01100101    145    101    65        e

01100110    146    102    66        f

01100111    147    103    67        g

01101000    150    104    68        h

01101001    151    105    69        i

01101010    152    106    6A        j

01101011    153    107    6B        k

01101100    154    108    6C        l

01101101    155    109    6D        m

01101110    156    110    6E        n

01101111    157    111    6F        o

01110000    160    112    70        p

01110001    161    113    71        q

01110010    162    114    72        r

01110011    163    115    73        s

01110100    164    116    74        t

01110101    165    117    75        u

01110110    166    118    76        v

01110111    167    119    77        w

01111000    170    120    78        x

01111001    171    121    79        y

01111010    172    122    7A        z

01111011    173    123    7B        {

01111100    174    124    7C        |

01111101    175    125    7D        }

01111110    176    126    7E        ~

01111111    177    127    7F

二、不同进制间的O(1)转换

实现二进制、八进制、十进制、十六进制四种进制之间的O(1)转换

// 十六进制、八进制、十进制到二进制的直译

#include <iostream>

#include <fstream>

#include <vector>

#include <map>

#include <string>

using namespace std;

string IntTo_(int num, int radix, string& ret)

{

    int index = ret.size() - ;

    while (num != )

    {

        int tmp = num % radix;

        if (tmp != )

        {

            if (tmp < )

            {

                ret[index] = '' + tmp;

            }

            else

            {

                ret[index] = 'A' + tmp - ;

            }

        }

        num /= radix;

        --index;

    }

    return ret;

}

string IntToBinary(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

string IntToOct(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

string IntToDec(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

string IntToHex(int num)

{

    string ret(, '');

    return IntTo_(num, , ret);

}

struct FourSystem

{

    string binary;

    string oct;

    string dec;

    string hex;

    int    num;

    int    index;

};

void CreateSystem(vector<FourSystem>& System, map<string, int>& binaryMap, map<string, int>& octMap,

                                          map<string, int>& decMap,    map<string, int>& hexMap,

                                          map<int   , int>& intMap)

{

    System.clear();

    binaryMap.clear();

    octMap.clear();

    decMap.clear();

    hexMap.clear();

    intMap.clear();

    FourSystem tmp;

    //System.push_back(tmp);

    //binaryMap[""];

    //octMap[""];

    //decMap[""];

    //hexMap[""];

    //intMap[-1];

    for (auto i = ; i != ; ++i)

    {

        tmp.binary = IntToBinary(i);

        tmp.oct    = IntToOct(i);

        tmp.dec    = IntToDec(i);

        tmp.hex    = IntToHex(i);

        tmp.num    = i;

        tmp.index  = i;

        System.push_back(tmp);

        binaryMap[tmp.binary] = i;

        octMap[tmp.oct]       = i;

        decMap[tmp.dec]       = i;

        hexMap[tmp.hex]       = i;

        intMap[tmp.num]       = i;

    }

}

int main()

{

    vector<FourSystem> System;

    map<string, int> binaryMap, octMap, decMap, hexMap;

    map<int   , int> intMap;

    CreateSystem(System, binaryMap, octMap, decMap, hexMap, intMap);

    int index = binaryMap[""]; //

    cout << "" << endl;

    cout << System[index].binary << '\t' << System[index].oct << '\t' << System[index].dec << '\t'

         << System[index].hex    << '\t' << System[index].num << endl;

    index = octMap[""]; //

    cout << "" << endl;

    cout << System[index].binary << '\t' << System[index].oct << '\t' << System[index].dec << '\t'

         << System[index].hex    << '\t' << System[index].num << endl;

    index = decMap[""]; //

    cout << "" << endl;

    cout << System[index].binary << '\t' << System[index].oct << '\t' << System[index].dec << '\t'

         << System[index].hex    << '\t' << System[index].num << endl;

    index = hexMap[""]; //

    cout << "" << endl;

    cout << System[index].binary << '\t' << System[index].oct << '\t' << System[index].dec << '\t'

         << System[index].hex    << '\t' << System[index].num << endl;

    index = intMap[]; //

    cout <<  << endl;

    cout << System[index].binary << '\t' << System[index].oct << '\t' << System[index].dec << '\t'

         << System[index].hex    << '\t' << System[index].num << endl;

    index = hexMap["7F"]; // 7F

    cout << "7F" << endl;

    cout << System[index].binary << '\t' << System[index].oct << '\t' << System[index].dec << '\t'

        << System[index].hex    << '\t' << System[index].num << endl;

    return ;

}

我们定义了结构体：FourSystem，用于存储一个数字对应的二进制、八进制、十进制、十六进制形式，CreateSystem函数用于初始化System数组，并且对binaryMap、octMap、decMap、hexMap、intMap等从形式到索引的映射进行初始化。预处理之后，针对特定的进制形式，只需根据特定的映射找到对应的索引，即可得到对应的其他进制形式。

这里需要我们针对特定的进制形式，指定特定的映射，当然也可以进行智能识别，比如如果长度为8，则对应于binaryMap；如果长度是2，则对应于hexMap；如果类型为int，则对应于intMap。对于octMap和decMap如果含有大于等于’8’的字符则对应于decMap；如果不含有，则只能我们人工指定其进制形式。当然，我们也可以根据上下文、应用场景进行区分。

ASCII码表以及不同进制间的O(1)转换的更多相关文章

Java 整数型的进制间的互相转换
/** * 整数型, 进制间的互相转换 */ public class IntConversion { public static void main(String[] args) { int num ...
Java 进制间的转换
package com.touch.onlinedu; public class Test { public static void main(String[] args) { // 1 : 0001 ...
java byte数组与16进制间的相互转换
java byte数组与16进制间的相互转换 CreationTime--2018年6月11日15点34分 Author:Marydon 1.准备工作 import java.util.Array ...
ByteArray、16进制、字符串之间的转换
ByteArray.16进制.字符串之间的转换: package fengzi.convert { import flash.utils.ByteArray; public class ByteArr ...
python中字母与ASCII码之间的转换以及进制间的转换
字母与ascii码: ord(c):参数是长度为1的字符串,简称字符.当参数为统一对象时(unicode object),返回能代表该字符的统一编码,当参数为8比特的字符串时,返回该字节的值.例如,o ...
ASCII, Unicode, UTF-8, 8进制, 16进制等各种编码学习理解笔记
字符编码的发展历史 Unicode和UTF-8有何区别? 在这个问题下的于洋的最高票回答中,比较完整地介绍了字符编码的发展历史,为了便于记忆,再次简要概括一番. 一个字节:最初一个字节的标准是混乱的, ...
ASCII码与16进制的互相转换(表)
所谓的ASCII和16进制都只是概念上的东西,在计算机中通通是二进制转换应该是输出的转换,同样是一个数,在计算机内存中表示是一样的,只是输出不一样ASCII是针对字符的编码,几乎是键盘上的字符的编码 ...
Java进制间的转换
最近学习了Java间的进制转换,记录下自己的学习心得,希望可以帮到前来查看的朋友们,如果有不懂的地方可以在下方评论留言,我们一起学习进步,只有自己足够强大才能弥补不足,多学习, 任意进制到十进制的转换 ...
Ascii码、16进制与 char
对于一个非计算机专业出身的人,以前只知道计算机中所有的数据都是以二进制形式进行存储,计算,通信的.但是人类文明中,主要的信息展现以文本的形式展现的.如果使用内存中的0和1来表示文本一直 ...

随机推荐

Electrom will-download pause function
1.code from github url-link: https://github.com/electron/electron/issues/7712 // to store downloadIt ...
1.3.2、CDH 搭建Hadoop在安装之前(端口---Cloudera Navigator加密使用的端口)
列出的所有端口都是TCP. 在下表中,每个端口的“ 访问要求”列通常是“内部”或“外部”.在此上下文中,“内部”表示端口仅用于组件之间的通信; “外部”表示该端口可用于内部或外部通信. 零件服务港 ...
Real Time Rendering 2
[Real Time Rendering 2] 1.The light vector l is usually defined pointing in a direction opposite to ...
Bootstrap Popover
[Bootstrap Popover] 1.设置一个popover需要添加以下设置: 1)data-toggle="popover" 2)title="Example p ...
Centos7 安装mysql5.7.24
从mysql官网下载 mysql-5.7.24-linux-glibc2.12-x86_64.tar.gz 拷贝到Centos的/opt目录下 1. 解压缩 tar -xzvf mysql-5.7.2 ...
js中switch/case分支的值可以是变量或表达式
在一些高级语言如C#中,switch分支的值只能是常量,而js中可以是变量或表达式: <!DOCTYPE html> <html lang="en"> &l ...
Jmeter（三十九）获取响应结果中参数出现的次数（转载）
转载自 http://www.cnblogs.com/yangxia-test 在测试中,有时候会遇到要统计响应结果中某个参数出现了多少次,如果量级很大,一个一个数不太现实,下面讲一下实现自动打印出该 ...
python3获得命令行输入的参数
外部直接执行python文件时,我们有时需要获得命令行的参数获得命令行参数的两种方式 1.通过sys.argv sys.argv:获得一个参数列表,第一个值为文件名本身,通过sys.argv ...
powerdesigenr设置主外键颜色
使用PowerDesigner时,它默认table的字体大小颜色等非常难看: 如果通过 Symbol ---> Format进行设置,只能对选中的最修改,新建的Table无效. 可以通过如下修改 ...
Dedecms织梦内容页获取当前页面顶级栏目名称方法
Dedecms织梦做站的时候,需要在当前页面调用顶级栏目名称的时候,织梦默认{dede:field name='typename' /} 可以获取当前栏目页上一级栏目的名称,而不是当前栏目顶级栏目名称 ...

ASCII码表以及不同进制间的O(1)转换

ASCII码表以及不同进制间的O(1)转换的更多相关文章

随机推荐

热门专题