Binary ACSII Text Converter - Help

So basically I have an array of hex numbers representing a binary number. Each binary number is 1/5th layer of the over all font.

For example... the letter A

1
2
3
4
5
6
7
........    B00000000    0x00
.****...    B01111000    0x78
...*.*..    B00010100    0x14
...*..*.    B00010010    0x12
...*.*..    B00010100    0x14
.****...    B01111000    0x78
........    B00000000    0x00



As you can see each HEX number is a layer in the font which consists of in the above example 7 layers.

Now what I would like to do is create a C++ program, so I can visualize a HEX font array that I got off the internet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <iostream>
using namespace std;

const char font[][5] = {
            {0x00,0x00,0x00,0x00,0x00},   //   0x20 32
            {0x00,0x00,0x6f,0x00,0x00},   // ! 0x21 33
            {0x00,0x07,0x00,0x07,0x00},   // " 0x22 34
            {0x14,0x7f,0x14,0x7f,0x14},   // # 0x23 35
            {0x00,0x07,0x04,0x1e,0x00},   // $ 0x24 36
            {0x23,0x13,0x08,0x64,0x62},   // % 0x25 37
            {0x36,0x49,0x56,0x20,0x50},   // & 0x26 38
            {0x00,0x00,0x07,0x00,0x00},   // ' 0x27 39
            {0x00,0x1c,0x22,0x41,0x00},   // ( 0x28 40
            {0x00,0x41,0x22,0x1c,0x00},   // ) 0x29 41
            {0x14,0x08,0x3e,0x08,0x14},   // * 0x2a 42
            {0x08,0x08,0x3e,0x08,0x08},   // + 0x2b 43
            {0x00,0x50,0x30,0x00,0x00},   // , 0x2c 44
            {0x08,0x08,0x08,0x08,0x08},   // - 0x2d 45
            {0x00,0x60,0x60,0x00,0x00},   // . 0x2e 46
            {0x20,0x10,0x08,0x04,0x02},   // / 0x2f 47
            {0x3e,0x51,0x49,0x45,0x3e},   // 0 0x30 48
            {0x00,0x42,0x7f,0x40,0x00},   // 1 0x31 49
            {0x42,0x61,0x51,0x49,0x46},   // 2 0x32 50
            {0x21,0x41,0x45,0x4b,0x31},   // 3 0x33 51
            {0x18,0x14,0x12,0x7f,0x10},   // 4 0x34 52
            {0x27,0x45,0x45,0x45,0x39},   // 5 0x35 53
            {0x3c,0x4a,0x49,0x49,0x30},   // 6 0x36 54
            {0x01,0x71,0x09,0x05,0x03},   // 7 0x37 55
            {0x36,0x49,0x49,0x49,0x36},   // 8 0x38 56
            {0x06,0x49,0x49,0x29,0x1e},   // 9 0x39 57
            {0x00,0x36,0x36,0x00,0x00},   // : 0x3a 58
            {0x00,0x56,0x36,0x00,0x00},   // ; 0x3b 59
            {0x08,0x14,0x22,0x41,0x00},   // < 0x3c 60
            {0x14,0x14,0x14,0x14,0x14},   // = 0x3d 61
            {0x00,0x41,0x22,0x14,0x08},   // > 0x3e 62
            {0x02,0x01,0x51,0x09,0x06},   // ? 0x3f 63
            {0x3e,0x41,0x5d,0x49,0x4e},   // @ 0x40 64
            {0x7e,0x09,0x09,0x09,0x7e},   // A 0x41 65
            {0x7f,0x49,0x49,0x49,0x36},   // B 0x42 66
            {0x3e,0x41,0x41,0x41,0x22},   // C 0x43 67
            {0x7f,0x41,0x41,0x41,0x3e},   // D 0x44 68
            {0x7f,0x49,0x49,0x49,0x41},   // E 0x45 69
            {0x7f,0x09,0x09,0x09,0x01},   // F 0x46 70
            {0x3e,0x41,0x49,0x49,0x7a},   // G 0x47 71
            {0x7f,0x08,0x08,0x08,0x7f},   // H 0x48 72
            {0x00,0x41,0x7f,0x41,0x00},   // I 0x49 73
            {0x20,0x40,0x41,0x3f,0x01},   // J 0x4a 74
            {0x7f,0x08,0x14,0x22,0x41},   // K 0x4b 75
            {0x7f,0x40,0x40,0x40,0x40},   // L 0x4c 76
            {0x7f,0x02,0x0c,0x02,0x7f},   // M 0x4d 77
            {0x7f,0x04,0x08,0x10,0x7f},   // N 0x4e 78
            {0x3e,0x41,0x41,0x41,0x3e},   // O 0x4f 79
            {0x7f,0x09,0x09,0x09,0x06},   // P 0x50 80
            {0x3e,0x41,0x51,0x21,0x5e},   // Q 0x51 81
            {0x7f,0x09,0x19,0x29,0x46},   // R 0x52 82
            {0x46,0x49,0x49,0x49,0x31},   // S 0x53 83
            {0x01,0x01,0x7f,0x01,0x01},   // T 0x54 84
            {0x3f,0x40,0x40,0x40,0x3f},   // U 0x55 85
            {0x0f,0x30,0x40,0x30,0x0f},   // V 0x56 86
            {0x3f,0x40,0x30,0x40,0x3f},   // W 0x57 87
            {0x63,0x14,0x08,0x14,0x63},   // X 0x58 88
            {0x07,0x08,0x70,0x08,0x07},   // Y 0x59 89
            {0x61,0x51,0x49,0x45,0x43},   // Z 0x5a 90
            {0x3c,0x4a,0x49,0x29,0x1e},   // [ 0x5b 91
            {0x02,0x04,0x08,0x10,0x20},   // \ 0x5c 92
            {0x00,0x41,0x7f,0x00,0x00},   // ] 0x5d 93
            {0x04,0x02,0x01,0x02,0x04},   // ^ 0x5e 94
            {0x40,0x40,0x40,0x40,0x40},   // _ 0x5f 95
            {0x00,0x00,0x03,0x04,0x00},   // ` 0x60 96
            {0x20,0x54,0x54,0x54,0x78},   // a 0x61 97
            {0x7f,0x48,0x44,0x44,0x38},   // b 0x62 98
            {0x38,0x44,0x44,0x44,0x20},   // c 0x63 99
            {0x38,0x44,0x44,0x48,0x7f},   // d 0x64 100
            {0x38,0x54,0x54,0x54,0x18},   // e 0x65 101
            {0x08,0x7e,0x09,0x01,0x02},   // f 0x66 102
            {0x0c,0x52,0x52,0x52,0x3e},   // g 0x67 103
            {0x7f,0x08,0x04,0x04,0x78},   // h 0x68 104
            {0x00,0x44,0x7d,0x40,0x00},   // i 0x69 105
            {0x20,0x40,0x44,0x3d,0x00},   // j 0x6a 106
            {0x00,0x7f,0x10,0x28,0x44},   // k 0x6b 107
            {0x00,0x41,0x7f,0x40,0x00},   // l 0x6c 108
            {0x7c,0x04,0x18,0x04,0x78},   // m 0x6d 109
            {0x7c,0x08,0x04,0x04,0x78},   // n 0x6e 110
            {0x38,0x44,0x44,0x44,0x38},   // o 0x6f 111
            {0x7c,0x14,0x14,0x14,0x08},   // p 0x70 112
            {0x08,0x14,0x14,0x18,0x7c},   // q 0x71 113
            {0x7c,0x08,0x04,0x04,0x08},   // r 0x72 114
            {0x48,0x54,0x54,0x54,0x20},   // s 0x73 115
            {0x04,0x3f,0x44,0x40,0x20},   // t 0x74 116
            {0x3c,0x40,0x40,0x20,0x7c},   // u 0x75 117
            {0x1c,0x20,0x40,0x20,0x1c},   // v 0x76 118
            {0x3c,0x40,0x30,0x40,0x3c},   // w 0x77 119
            {0x44,0x28,0x10,0x28,0x44},   // x 0x78 120
            {0x0c,0x50,0x50,0x50,0x3c},   // y 0x79 121
            {0x44,0x64,0x54,0x4c,0x44},   // z 0x7a 122
            {0x00,0x08,0x36,0x41,0x41},   // { 0x7b 123
            {0x00,0x00,0x7f,0x00,0x00},   // | 0x7c 124
            {0x41,0x41,0x36,0x08,0x00},   // } 0x7d 125
            {0x04,0x02,0x04,0x08,0x04},   // ~ 0x7e 126
      };
      
string word;
      
int main(){
     
     cout << "Enter a word and it will be converted to Binary ASCII text: ";
     cin >> word;  
     
     int i = word.size();

     for (int j = 0; j < 5; j++){        //This should stack the 5 layers
         for (int k = 0; k < i; k++){    //This should space each row of letters
             int l = word[j];            //Gets the current letter
             cout << font[l][k] << " ";  //Displays the corresponding ASCII letter from the array
             }
             cout << endl;
         }
     
        system("pause");
        return(0);    
     }


Basically I am asking two things. How can I make this display the correct representing letter in the array when a user inputs his own text.

And secondly, how can I output the HEX numbers that is in the array as a binary number.

Any and all help is appreciated. If you have a better way of coding this, please let me know.

-Adrian
1
2
3
4
5
	string input;
	cin >> input;

	for (unsigned i=0;i<input.length();i++)
		cout << hex << static_cast<unsigned>(input.c_str()[i]) << " : " << input.c_str()[i] << endl;


how to print number in binary representation you can search this site
Topic archived. No new replies allowed.