Codifica e decodifica Basetop 10 con C ++

Base64 è un set di caratteri di 64 caratteri, in cui ogni personaggio è composto da 6 bit. Tutti questi 64 caratteri sono caratteri stampabili. Un personaggio è un simbolo. Quindi, ogni simbolo del set di caratteri di base 64 è costituito da 6 bit. Tali sei bit sono chiamati sestet. Un byte o un ottetto è composto da 8 bit. Il set di caratteri ASCII è composto da 127 caratteri, alcuni dei quali non sono stampabili. Quindi, alcuni personaggi del set di caratteri ASCII non sono simboli. Un simbolo per il set di caratteri ASCII è composto da 8 bit.

I dati nel computer sono archiviati in byte di 8 bit ciascuno. I dati vengono inviati dal computer in byte di 8 bit ciascuno. I dati vengono ricevuti nel computer in byte di 8 bit ciascuno.

Un flusso di byte può essere convertito in un flusso di sestet (6 bit per simbolo). E questa è la codifica di base64. Un flusso di sestet può essere convertito in un flusso di byte. E questa è la decodifica di base64. In altre parole, un flusso di caratteri ASCII può essere convertito in un flusso di simboli sextet. Questo è codifica e il contrario è la decodifica. Il flusso di simboli sextet, convertito da un flusso di simboli di ottetto (byte), è più lungo del flusso di simboli di ottetto per numero. In altre parole, un flusso di caratteri Base64 è più lungo del flusso corrispondente di caratteri ASCII. Bene, codifica in base64 e decodifica da esso non è così semplice come appena espresso.

Questo articolo spiega la codifica e la decodifica di Base64 con il linguaggio del computer C ++. La prima parte dell'articolo spiega la codifica e la decodifica di base64. La seconda parte mostra come alcune funzionalità C ++ possono essere utilizzate per codificare e decodificare Base64. In questo articolo, la parola "ottetto" e "byte" sono usate in modo intercambiabile.

Contenuto dell'articolo

• Passando alla base 64
• Codifica base64
• Nuova lunghezza
• Decodifica Base64
• Errore di trasmissione
• Caratteristiche del bit C ++
• Conclusione

Passando alla base 64

Un alfabeto o un set di caratteri di 2 simboli può essere rappresentato con un bit per simbolo. Lascia che i simboli dell'alfabeto siano costituiti da: zero e uno. In questo caso, zero è bit 0 e uno è bit 1.

Un alfabeto o un set di caratteri di 4 simboli può essere rappresentato con due bit per simbolo. Lascia che i simboli dell'alfabeto siano costituiti da: 0, 1, 2, 3. In questa situazione, 0 è 00, 1 è 01, 2 è 10 e 3 è 11.

Un alfabeto di 8 simboli può essere rappresentato con tre bit per simbolo. Lascia che i simboli dell'alfabeto siano costituiti da: 0, 1, 2, 3, 4, 5, 6, 7. In questa situazione, 0 è 000, 1 è 001, 2 è 010, 3 è 011, 4 è 100, 5 è 101, 6 è 110 e 7 è 111.

Un alfabeto di 16 simboli può essere rappresentato con quattro bit per simbolo. Lascia che i simboli dell'alfabeto siano costituiti da: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, A, B, C, D, E, F. In questa situazione, 0 è 0000, 1 è 0001, 2 è 0010, 3 è 0011, 4 è 0100, 5 è 0101, 6 è 0110, 7 è 0111, 8 è 1000, 9 è 1001, a è 1010, b è 1011, c è 1100, d è 1101, E è 1110 e F è 1111.

Un alfabeto di 32 simboli diversi può essere rappresentato con cinque bit per simbolo.

Questo ci porta a un alfabeto di 64 simboli diversi. Un alfabeto di 64 simboli diversi può essere rappresentato con sei bit per simbolo. C'è un set di carattere particolare di 64 simboli diversi, chiamati Base64. In questo set, i primi 26 simboli sono le 26 lettere maiuscole della lingua parlata inglese, nel suo ordine. Questi 26 simboli sono i primi numeri binari da 0 a 25, in cui ogni simbolo è un sestetto, sei bit. I prossimi numeri binari da 26 a 51 sono le 26 lettere minuscole della lingua parlata inglese, nel suo ordine; Ancora una volta, ogni simbolo, un sestetto. I prossimi numeri binari da 52 a 61 sono le 10 cifre arabe, nel loro ordine; Tuttavia, ogni simbolo, un sestetto.

Il numero binario per 62 è per il simbolo +e il numero binario per 63 è per il simbolo / . Base64 ha varianti diverse. Quindi alcune varianti hanno simboli diversi per il numero binario di 62 e 63.

La tabella Base64, che mostra corrispondenze per indice, numero binario e carattere, è:

L'alfabeto base64

Indice	Binario	CHAR	Indice	Binario	CHAR	Indice	Binario	CHAR	Indice	Binario	CHAR
0	000000	UN	16	010000	Q	32	100000	G	48	110000	w
1	000001	B	17	010001	R	33	100001	H	49	110001	X
2	000010	C	18	010010	S	34	100010	io	50	110010	y
3	000011	D	19	010011	T	35	100011	J	51	110011	z
4	000100	E	20	010100	U	36	100100	K	52	110100	0
5	000101	F	21	010101	V	37	100101	l	53	110101	1
6	000110	G	22	010110	W	38	100110	M	54	110110	2
7	000111	H	23	010111	X	39	100111	N	55	110111	3
8	001000	IO	24	011000	Y	40	101000	o	56	111000	4
9	001001	J	25	011001	Z	41	101001	P	57	111001	5
10	001010	K	26	011010	UN	42	101010	Q	58	111010	6
11	001011	L	27	011011	B	43	101011	R	59	111011	7
12	001100	M	28	011100	C	44	101100	S	60	111100	8
13	001101	N	29	011101	D	45	101101	T	61	111101	9
14	001110	O	30	011110	e	46	101110	u	62	111110	+
15	001111	P	31	011111	F	47	101111	v	63	111111	/

Imbottitura =

In realtà ci sono 65 simboli. L'ultimo simbolo è =, il cui numero binario è ancora composto da 6 bit, che è 111101. Non è in conflitto con il simbolo di base64 di 9 - vedi sotto.

Codifica base64
SEXTET BIT-FIELDS

Considera la parola:

cane

Ci sono tre byte ASCII per questa parola, che sono:

01100100 01101111 01100111

partecipato. Questi sono 3 ottetti ma sono costituiti da 4 sestetti come segue:

011001 000110 111101 100111

Dalla tabella Alfabeto Base64 sopra, questi 4 sestet sono i simboli,

Zg9n

Si noti che la codifica del "cane" in base64 è "zg9n", che non è comprensibile.

Base64 codifica una sequenza di 3 ottetti (byte) in una sequenza di 4 sestetti. 3 ottetti o 4 sestetti sono 24 bit.

Considera ora la seguente parola:

Esso

Ci sono due ottetti ASCII per questa parola, che sono:

01101001 01110100

partecipato. Questi sono 2 ottetti ma sono costituiti da 2 sestetti e 4 bit. Un flusso di caratteri Base64 è composto da sestet (6 bit per carattere). Quindi, due zero bit devono essere aggiunti a questi 16 bit per avere 3 sestetti, cioè:

011010 010111 010000

Non è tutto. La sequenza di base64 è composta da 4 sestet per gruppo; cioè, 24 bit per gruppo. Il carattere di imbottitura = è 111101. Due bit zero sono già stati aggiunti ai 16 bit per avere 18 bit. Quindi, se i 6 bit di imbottitura del carattere di imbottitura vengono aggiunti ai 18 bit, ci saranno 24 bit come richiesto. Questo è:

011010 010111 010000 111101

Gli ultimi sei bit dell'ultimo sestetto sono il sestetto di imbottitura, = . Questi 24 bit sono costituiti da 4 sestetti, di cui l'ultimo sestetto ha i primi 4 bit del simbolo di base64, seguiti da due bit zero.

Ora, considera la seguente parola personaggio:

IO

C'è un ottetto ASCII per questa parola, che è:

01001001

Questo è 1 ottetto ma è composto da 1 sestetto e 2 bit. Un flusso di caratteri Base64 è composto da sestet (6 bit per carattere). Quindi, quattro bit zero devono essere aggiunti a questi 8 bit per avere 2 sestetti, cioè:

010010 010000

Non è tutto. La sequenza di base64 è composta da 4 sestet per gruppo; cioè, 24 bit per gruppo. Il carattere di imbottitura = è 111101, che è lungo sei bit. Quattro zero bit sono già stati aggiunti agli 8 bit per avere 12 bit. Questo non è fino a quattro sestetti. Quindi, devono essere aggiunti altri due sestetti di imbottitura per creare 4 sestet, cioè:

010010 010000 111101 111101

Flusso di output di base64

Nel programma, è necessario realizzare una serie di cartoni da bastoncini dell'alfabeto di base64, dove l'indice 0 ha il carattere di 8 bit, a; L'indice 1 ha il carattere di 8 bit, b; L'indice 2 ha il carattere di 8 bit, c, fino a quando l'indice 63 ha il carattere di 8 bit, / .

Quindi, l'output per la parola di tre personaggi, "cane" sarà "zg9n" di quattro byte, espresso in bit come

01011010 01000111 00111001 01101110

dove z è 01011010 di 8 bit; G è 01000111 di 8 bit; 9 è 00111001 di 8 bit e n è 01101110 di 8 bit. Ciò significa che da tre byte della stringa originale, vengono emessi quattro byte. Questi quattro byte sono valori dell'array alfabeto di base64, in cui ogni valore è un byte.

L'output per la parola di due caratteri, "esso" sarà "axq =" di quattro byte, espressi in bit come

01100001 01011000 01010001 00111101

ottenuto dall'array. Ciò significa che da due byte, quattro byte sono ancora emessi.

L'output per la parola di un personaggio, "i" sarà "sq ==" di quattro byte, espresso in bit come

01010011 01010001 00111101 00111101

Ciò significa che da un byte, quattro byte sono ancora emessi.

Un sestetto di 61 (111101) viene eliminato come 9 (00111001). Un sestetto di = (111101) viene emesso come = (00111101).

Nuova lunghezza

Ci sono tre situazioni da considerare qui per avere una stima per la nuova lunghezza.

• La lunghezza originale della stringa è un multiplo di 3, E.G., 3, 6, 9, 12, 15, ecc. In questo caso, la nuova lunghezza sarà esattamente 133.33% della lunghezza originale perché tre ottetti finiscono come quattro ottetti.
• La lunghezza originale della stringa è lunga due byte o termina con due byte, dopo un multiplo di 3. In questo caso, la nuova lunghezza sarà superiore a 133.Il 33% della lunghezza originale perché una parte di stringa di due ottetti finisce come quattro ottetti.
• La lunghezza originale della stringa è lunga un byte o termina con un byte dopo un multiplo di 3. In questo caso, la nuova lunghezza sarà superiore a 133.Il 33% della lunghezza originale (più sopra del caso precedente), poiché una parte di stringa di un ottetto finisce come quattro ottetti.

Lunghezza massima di linea

Dopo essere passato dalla stringa originale attraverso l'array alfabeto di base64 e di finire con ottetti di almeno 133.33% di lunghezza, nessuna stringa di output deve essere lunga più di 76 ottetti. Quando una stringa di output è lunga 76 caratteri, è necessario aggiungere un personaggio newline prima di altri 76 ottetti, oppure vengano aggiunti meno caratteri. Una lunga stringa di output ha tutte le sezioni, composta da 76 caratteri ciascuna, tranne l'ultima, se non è fino a 76 caratteri. I programmatori di separatore di linee utilizzati sono probabilmente il carattere di nuova linea, '\ n'; ma dovrebbe essere "\ r \ n".

Decodifica Base64

Per decodificare, eseguire il contrario della codifica. Usa il seguente algoritmo:

• Se la stringa ricevuta è più lunga di 76 caratteri (ottetti), dividere la stringa lunga in un array di stringhe, rimuovendo il separatore di linee, che può essere "\ r \ n" o "\ n '.
• Se c'è più di una riga di 76 caratteri ciascuno, allora significa tutte le linee tranne l'ultima composta da gruppi di quattro caratteri ciascuno. Ogni gruppo si tradurrà in tre caratteri usando l'array alfabeto di base64. I quattro byte devono essere convertiti in sei sestetti prima di essere convertiti in tre ottetti.
• L'ultima riga, o l'unica riga che la stringa avrebbe potuto avere, è ancora costituita da gruppi di quattro caratteri. L'ultimo gruppo di quattro caratteri può provocare uno o due caratteri. Per sapere se l'ultimo gruppo di quattro caratteri si tradurrà in un personaggio, controlla se gli ultimi due ottetti del gruppo sono ciascuno ASCII, =. Se il gruppo si traduce in due caratteri, solo l'ultimo ottetto dovrebbe essere ASCII, =. Qualsiasi sequenza quadrupla di caratteri davanti a quest'ultima sequenza quadrupla è gestita come nel passaggio precedente.

Errore di trasmissione

All'estremità ricevente, qualsiasi carattere diverso da quello del carattere di separazione della linea o dei caratteri che non è un valore dell'array alfabeto di base64 indica un errore di trasmissione; e dovrebbe essere gestito. La gestione degli errori di trasmissione non è affrontato in questo articolo. Nota: la presenza del byte, = tra i 76 caratteri, non è un errore di trasmissione.

Caratteristiche del bit C ++

I membri fondamentali dell'elemento struct possono essere assegnati un numero di bit diversi da 8. Il seguente programma illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
struct s3
senza segno int a: 6;
Insigned Int B: 6;
Insigned Int C: 6;
Insigned Int D: 6;
S3;
int main ()

S3.a = 25;
S3.b = 6;
S3.c = 61;
S3.d = 39;
cout<restituzione 0;

L'output è:

25, 6, 61, 39

I numeri interi di output sono assegnati. Tuttavia, ciascuno occupa 6 bit nella memoria e non 8 o 32 bit. Nota come viene assegnato il numero di bit, nella dichiarazione, con il colon.

Estrarre i primi 6 bit dall'ottetto

C ++ non ha una funzione o un operatore per estrarre il primo set di bit da un ottetto. Per estrarre i primi 6 bit, spostare il contenuto dell'ottetto per 2 posti. I due bit liberati sull'estremità sinistra sono riempiti con zeri. L'ottetto risultante, che dovrebbe essere un carattere senza segno, è ora un numero intero, rappresentato dai primi 6 bit dell'ottetto. Quindi assegnare l'ottetto risultante a un membro della struttura della struttura di 6 bit. L'operatore di spostamento a destra è >>, da non confondere con l'operatore di estrazione dell'oggetto Cout.

Supponendo che il membro Struttura a 6 bit sia, S3.A, quindi i primi 6 bit del personaggio 'd' vengono estratti come segue:

non firmato char ch1 = 'd';
CH1 = CH1 >> 2;
S3.A = CH1;

Il valore di S3.A può ora essere usato per indicizzare l'array alfabeto di base64.

Producendo il secondo sestetto da 3 caratteri

I secondi sei bit sono costituiti dagli ultimi due bit del primo ottetto e dai successivi 4 bit del secondo ottetto. L'idea è di ottenere gli ultimi due bit nella quinta e sesta posizione del suo ottetto e rendere zero il resto dei pezzi dell'ottetto; poi in termini di bit e con i primi quattro bit del secondo ottetto che è stato spostato a destra fino alla sua fine.

Spostamento di sinistra Gli ultimi due bit alla quinta e sesta posizione vengono eseguiti dall'operatore a spostamento a sinistra in bit, <<, which is not to be confused with the cout insertion operator. The following code segment left-shifts the last two bits of 'd' to the fifth and sixth positions:

char i = 'd'; D ';
i = i <<4;

A questo punto, i bit liberati sono stati riempiti con zeri, mentre i bit a turni non avacati che non sono richiesti sono ancora lì. Per fare il resto dei bit in I zero, devo essere in termini di bit e con 00110000, che è il numero intero, 96. La seguente affermazione lo fa:

i = i & 96;

Il seguente segmento di codice, sposta i primi quattro bit del secondo ottetto nelle ultime quattro posizioni:

char j = 'o';
j = j >> 4;

I bit liberati sono stati riempiti con zeri. A questo punto, ho 8 bit e J ha 8 bit. Tutti gli 1 in questi due carattere non firmati sono ora nelle loro giuste posizioni. Per ottenere il carbone, per il secondo sestetto, questi due carattere a 8 bit devono essere in termini di bit e, come segue:

char ch2 = i & j;

CH2 ha ancora 8 bit. Per renderlo sei bit, deve essere assegnato a un membro della striscia bit di 6 bit. Se il membro della striscia bit-field è S3.B, quindi l'incarico verrà eseguito come segue:

S3.B = CH2;

D'ora in poi, S3.B verrà utilizzato al posto di CH2 per indicizzare l'array alfabeto di base64.

Aggiunta di due zeri per il terzo sesto

Quando la sequenza da codificare ha due caratteri, il terzo sestetto deve essere aggiunto due zeri. Supponiamo che un ottetto sia già prefisso da due zero bit e che i prossimi quattro bit sono i bit giusti. Al fine di realizzare gli ultimi due bit di questo ottetto, due zeri, in termini di bit e ottetto con 11111100, che è il numero intero, 252. La seguente affermazione lo fa:

CHAR CH3 non firmato = ottetto e 252;

CH3 ora ha tutti gli ultimi sei bit, che sono i bit richiesti, anche se è ancora composto da 8 bit. Per renderlo sei bit, deve essere assegnato a un membro della striscia bit di 6 bit. Se il membro della striscia bit-field è S3.C, quindi l'incarico verrà eseguito come segue:

S3.C = CH3;

D'ora in poi, S3.c verrà utilizzato al posto di CH2 per indicizzare l'array alfabeto di base64.

Il resto della gestione del bit può essere eseguito come spiegato in questa sezione.

Array alfabeto di base64

Per la codifica, l'array dovrebbe essere qualcosa di simile,

non firmato char arr [] = 'a', 'b', 'c', - - '/';

La decodifica è il processo inverso. Quindi, una mappa non ordinata dovrebbe essere usata per questa struttura, qualcosa di simile,

UNORDERD_MAP Umap = 'a', 0, 'b', 1, 'c', 2, - - - '/', 63;

La classe stringa

La classe String dovrebbe essere utilizzata per le sequenze totali non codificate e codificate. Il resto della programmazione è normale programmazione C ++.

Conclusione

Base64 è un set di caratteri di 64 caratteri, in cui ogni personaggio è composto da 6 bit. Per la codifica, ogni tre byte della stringa originale viene convertito in quattro sestetti di 6 bit ciascuno. Questi sestet sono usati come indici per la tabella alfabeto Base64 per la codifica. Se la sequenza è composta da due caratteri, sono ancora ottenuti quattro sestetti, con l'ultimo sestetto, essendo il numero 61. Se la sequenza è composta da un carattere, sono ancora ottenuti quattro sestetti, con gli ultimi due sestetti, essendo due del numero 61.

La decodifica fa il contrario.