Koding og avkoding av Basetop 10 med C ++

Base64 er et karaktersett med 64 tegn, der hver karakter består av 6 biter. Alle disse 64 tegnene er utskrivbare tegn. En karakter er et symbol. Så hvert symbol på basen 64 tegnsett består av 6 biter. Slike seks biter kalles en sextett. En byte eller oktett består av 8 biter. ASCII -karaktersettet består av 127 tegn, hvorav noen ikke kan skrives ut. Så noen tegn i ASCII -karaktersettet er ikke symboler. Et symbol for ASCII -karaktersettet består av 8 biter.

Data i datamaskinen lagres i byte på 8 biter hver. Data sendes ut av datamaskinen i byte på 8 biter hver. Data mottas i datamaskinen i byte på 8 biter hver.

En strøm av byte kan konverteres til en strøm av sextett (6 biter per symbol). Og det er base64 koding. En strøm av sextett kan konverteres til en strøm av byte. Og det er base64 avkoding. Med andre ord, en strøm av ASCII -tegn kan konverteres til en strøm av sekstett -symboler. Dette er koding, og det motsatte er avkoding. Strømmen av sekstettsymboler, konvertert fra en strøm av oktett (byte) symboler, er lengre enn strømmen av oktettsymboler etter tall. Med andre ord, en strøm av base64 tegn er lengre enn den tilsvarende strømmen av ASCII -tegn. Vel, koding i base64 og avkoding fra den er ikke så grei som bare uttrykt.

Denne artikkelen forklarer koding og avkoding av base64 med C ++ dataspråk. Den første delen av artikkelen forklarer Base64 -koding og avkoding riktig. Den andre delen viser hvordan noen C ++ -funksjoner kan brukes til å kode og avkode base64. I denne artikkelen brukes ordet "oktett" og "byte" om hverandre.

Artikkelinnhold

• Beveger seg opp til base 64
• Koding Base64
• Ny lengde
• Avkoding Base64
• Overføringsfeil
• C ++ bitfunksjoner
• Konklusjon

Beveger seg opp til base 64

Et alfabet eller et tegnsett med 2 symboler kan være representert med en bit per symbol. La alfabetets symboler bestå av: null og en. I dette tilfellet er null bit 0, og en er bit 1.

Et alfabet eller et tegnsett med 4 symboler kan være representert med to biter per symbol. La alfabetets symboler bestå av: 0, 1, 2, 3. I denne situasjonen er 0 00, 1 er 01, 2 er 10, og 3 er 11.

Et alfabet med 8 symboler kan være representert med tre biter per symbol. La alfabetets symboler bestå av: 0, 1, 2, 3, 4, 5, 6, 7. I denne situasjonen er 0 000, 1 er 001, 2 er 010, 3 er 011, 4 er 100, 5 er 101, 6 er 110 og 7 er 111.

Et alfabet med 16 symboler kan være representert med fire biter per symbol. La alfabetets symboler bestå av: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f. I denne situasjonen er 0 0000, 1 er 0001, 2 er 0010, 3 er 0011, 4 er 0100, 5 er 0101, 6 er 0110, 7 er 0111, 8 er 1000, 9 er 1001, a er 1010, B er 1011, C er 1100, D er 1101, E er 1110 og F er 1111.

Et alfabet med 32 forskjellige symboler kan være representert med fem biter per symbol.

Dette fører oss til et alfabet med 64 forskjellige symboler. Et alfabet med 64 forskjellige symboler kan være representert med seks biter per symbol. Det er et bestemt tegnsett med 64 forskjellige symboler, kalt base64. I dette settet er de første 26 symbolene de 26 store bokstavene til det engelske talespråket, i sin orden. Disse 26 symbolene er de første binære tallene fra 0 til 25, der hvert symbol er et sekstett, seks biter. De neste binære tallene fra 26 til 51 er de 26 små bokstavene til det engelske talespråket, i sin orden; Igjen, hvert symbol, et sekstett. De neste binære tallene fra 52 til 61 er de 10 arabiske sifrene, i deres orden; Fortsatt hvert symbol, et sekstett.

Det binære tallet for 62 er for symbolet +, og det binære tallet for 63 er for symbolet / . Base64 har forskjellige varianter. Så noen varianter har forskjellige symboler for det binære antallet 62 og 63.

Base64 -tabellen, som viser korrespondanser for indeksen, binært antall og karakter, er:

Base64 alfabetet

Indeks	Binær	Røye	Indeks	Binær	Røye	Indeks	Binær	Røye	Indeks	Binær	Røye
0	000000	EN	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	Jeg	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	Jeg	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	en	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
1. 3	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	/

Polstring =

Det er faktisk 65 symboler. Det siste symbolet er =, hvis binære tall fremdeles består av 6 biter, som er 111101. Det er ikke i konflikt med base64 -symbolet på 9 - se nedenfor.

Koding Base64
Sexet bit-felt

Tenk på ordet:

hund

Det er tre ASCII -byte for dette ordet, som er:

01100100 01111111 01100111

ble med. Dette er 3 oktetter, men består av 4 seksteter som følger:

011001 000110 111101 100111

Fra base64 alfabetetabellen ovenfor er disse 4 sekstettene symbolene,

Zg9n

Legg merke til at kodingen av "hund" til base64 er "ZG9N", som ikke er forståelig.

Base64 koder for en sekvens på 3 oktetter (byte) til en sekvens på 4 sekstetter. 3 oktetter eller 4 sextett er 24 biter.

Tenk nå på følgende ord:

den

Det er to ASCII -oktetter for dette ordet, som er:

01101001 01110100

ble med. Dette er 2 oktetter, men består av 2 seksteter og 4 biter. En strøm av base64 tegn består av seksteter (6 biter per karakter). Så to nullbiter må legges til disse 16 bitene for å ha 3 seksteter, det vil si:

011010 010111 010000

Det er ikke alt. Base64 -sekvensen består av 4 seksteter per gruppe; det vil si 24 biter per gruppe. Polstringskarakteren = er 111101. To nullbiter har allerede blitt lagt til de 16 bitene for å ha 18 biter. Så hvis de 6 polstringsbitene i polstringskarakteren blir lagt til de 18 bitene, vil det være 24 biter etter behov. Det er:

011010 010111 010000 111101

De seks siste bitene av den siste sekstetten er polstringsekten, = . Disse 24 bitene består av 4 seksteter, hvorav den siste-men-en sekstetten har de første 4 bitene av base64-symbolet, etterfulgt av to nullbiter.

Vurder nå følgende ett karakterord:

Jeg

Det er en ASCII -oktett for dette ordet, som er:

01001001

Dette er 1 oktett, men består av 1 sekstett og 2 biter. En strøm av base64 tegn består av seksteter (6 biter per karakter). Så fire nullbiter må legges til disse 8 bitene for å ha 2 seksteter, det vil si:

010010 010000

Det er ikke alt. Base64 -sekvensen består av 4 seksteter per gruppe; det vil si 24 biter per gruppe. Polstringskarakteren = er 111101, som er seks biter lang. Fire nullbiter har allerede blitt lagt til de 8 bitene for å ha 12 biter. Dette er ikke opptil fire seksteter. Så to flere polstetter må legges ved for å lage 4 sekstetter, det vil si:

010010 010000 111101 111101

Utgangsstrøm av base64

I programmet må det lages en array-of-chars av base64-alfabetet, der indeks 0 har karakteren av 8 biter, a; Indeks 1 har karakteren av 8 biter, B; Indeks 2 har karakteren av 8 biter, C, inntil indeks 63 har karakteren av 8 biter, / .

Så, utgangen for ordet til tre tegn, "hund" vil være "zg9n" av fire byte, uttrykt i biter som

01011010 01000111 00111001 01101110

hvor z er 01011010 av 8 biter; G er 01000111 av 8 biter; 9 er 00111001 av 8 biter, og N er 01101110 av 8 biter. Dette betyr at fra tre byte av den opprinnelige strengen er fire byte utført. Disse fire byte er verdier av base64 alfabet -array, der hver verdi er en byte.

Utgangen for ordet til to tegn, “It” vil være “axq =” av fire byte, uttrykt i biter som

01100001 01011000 01010001 00111101

hentet fra matrisen. Dette betyr at fra to byte er fire byte fremdeles ut.

Utgangen for ordet med ett tegn, "jeg" vil være "sq ==" av fire byte, uttrykt i biter som

01010011 01010001 00111101 00111101

Dette betyr at fra en byte er fire byte fremdeles ut.

En sekstett på 61 (111101) er utpekt som 9 (00111001). En sekstett av = (111101) er utført som = (00111101).

Ny lengde

Det er tre situasjoner å vurdere her for å ha et estimat for den nye lengden.

• Den opprinnelige lengden på strengen er et multiplum av 3, e.g., 3, 6, 9, 12, 15, etc. I dette tilfellet vil den nye lengden være nøyaktig 133.33% av den opprinnelige lengden fordi tre oktetter ender opp som fire oktetter.
• Den opprinnelige lengden på strengen er to byte lang, eller den ender med to byte, etter et multiplum av 3. I dette tilfellet vil den nye lengden være over 133.33% av den opprinnelige lengden fordi en strengdel av to oktetter ender opp som fire oktetter.
• Den opprinnelige lengden på strengen er en byte lang, eller den ender med en byte etter et multiplum av 3. I dette tilfellet vil den nye lengden være over 133.33% av den opprinnelige lengden (mer over enn forrige tilfelle), fordi en strengdel av en oktett ender opp som fire oktetter.

Maksimal lengde på linjen

Etter å ha gått fra den originale strengen gjennom Base64 Alfabet -arrayen og endt opp med oktetter på minst 133.33% lang, ingen utgangsstreng må være mer enn 76 oktetter lange. Når en utgangsstreng er 76 tegn lang, må et nytt linjetegn legges til før ytterligere 76 oktetter, eller færre tegn blir lagt til. En lang utgangsstreng har alle seksjoner, bestående av 76 tegn hver, bortsett fra den siste, hvis den ikke er opptil 76 tegn. Bruken av linjeseparatorprogrammerere er sannsynligvis Newline -karakteren, '\ n'; Men det er ment å være "\ r \ n".

Avkoding Base64

For å avkode, gjør det motsatte av koding. Bruk følgende algoritme:

• Hvis den mottatte strengen er lengre enn 76 tegn (oktetter), del den lange strengen i en rekke strenger, og fjerner linjeseparatoren, som kan være “\ r \ n” eller '\ n'.
• Hvis det er mer enn en linje med 76 tegn hver, betyr det alle linjene bortsett fra den siste består av grupper på fire tegn hver. Hver gruppe vil resultere i tre tegn som bruker base64 alfabetet array. De fire byte må konverteres til seks seksteter før de blir konvertert til tre oktetter.
• Den siste linjen, eller den eneste linjen strengen kan ha hatt, består fortsatt av grupper på fire tegn. Den siste gruppen på fire tegn kan enten resultere i ett eller to tegn. For å vite om den siste gruppen på fire karakterer vil resultere i ett tegn, sjekk om de to siste oktettene i gruppen er hver ASCII, =. Hvis gruppen resulterer i to tegn, skal bare den siste okteten være ASCII, =. Enhver firedoblet sekvens av tegn foran denne siste firedoblede sekvensen håndteres som i forrige trinn.

Overføringsfeil

Ved mottaksenden indikerer ethvert annet tegn enn linjeseparasjonskarakteren eller tegn som ikke er en verdi av base64 alfabetarray en overføringsfeil; og bør håndteres. Håndtering av overføringsfeil blir ikke adressert i denne artikkelen. Merk: Tilstedeværelsen av byte, = blant de 76 tegnene, er ikke en overføringsfeil.

C ++ bitfunksjoner

Grunnleggende medlemmer av Struct -elementet kan gis et antall andre biter enn 8. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
struct S3
usignert int a: 6;
usignert int B: 6;
usignert int c: 6;
usignert int d: 6;
S3;
int main ()

S3.a = 25;
S3.B = 6;
S3.C = 61;
S3.d = 39;
cout<retur 0;

Utgangen er:

25, 6, 61, 39

Utgangens heltall er som tilordnet. Imidlertid okkuperer hver 6 biter i minnet og ikke 8 eller 32 biter. Legg merke til hvordan antall biter er tildelt, i erklæringen, med tykktarmen.

Trekke ut første 6 biter fra oktet

C ++ har ikke en funksjon eller operatør for å trekke ut det første settet med biter fra en oktett. For å hente ut de første 6 bitene, må du skifte innholdet i oktetten med 2 steder. De fraflyttede to bitene på venstre ende er fylt med nuller. Den resulterende oktetten, som skal være en usignert røye, er nå et heltall, representert med de første 6 bitene av oktetten. Tilordne deretter den resulterende oktetten til et struct bit-felt medlem av 6 biter. Den rette skiftoperatøren er >>, for ikke å forveksle med utvinningsoperatøren av Cout -objektet.

Forutsatt at Struct 6-bit-feltmedlemmet er, S3.A, da blir de første 6 bitene av karakteren 'D' trukket ut som følger:

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

Verdien av S3.A kan nå brukes til å indeksere base64 alfabetet array.

Produserer andre sekstett fra 3 tegn

De andre seks bitene består av de to siste bitene av den første oktetten og de neste 4 bitene av den andre oktetten. Tanken er å få de to siste bitene inn i femte og sjette plassering av oktetten og gjøre resten av oktets biter null; deretter bitmessig og det med de fire første bitene av den andre oktetten som har blitt rettet mot slutten.

Venstre-skiftende de to siste bitene til femte og sjette plassering utføres av den bitvise venstre-skiftoperatøren, <<, 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:

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

På dette tidspunktet har de ledede bitene blitt fylt med nuller, mens de ikke-vaglede skiftede bitene som ikke er påkrevd, er fremdeles der. For å lage resten av bitene i I null, må jeg være bitmessig og med 00110000, som er heltallet, 96. Følgende uttalelse gjør det:

i = i & 96;

Følgende kodesegment forskyver de fire første bitene av den andre oktetten til de fire siste bit -stillingene:

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

De fraflyttede bitene er fylt med nuller. På dette tidspunktet har jeg 8 biter, og J har 8 biter. Alle 1 -er i disse to usignerte rolleene er nå i sine rette posisjoner. For å få røye, for den andre sekten, må disse to 8-biters chars være bitsmessig og som følger:

usignert char ch2 = i & j;

CH2 har fortsatt 8 biter. For å gjøre det til seks biter, må det tilordnes et strustbitfeltmedlem på 6 biter. Hvis Struct Bit-Field-medlemmet er S3.B, da vil oppgaven bli gjort som følger:

S3.B = CH2;

Fremover, S3.B vil bli brukt i stedet for CH2 for å indeksere base64 alfabetet array.

Legger til to nuller for tredje sekstett

Når sekvensen som skal kodes har to tegn, må den tredje sekstetten legges til to nuller. Anta at en oktett allerede er prefiks av to nullbiter, og de neste fire bitene er de rette bitene. For å lage de to siste bitene av denne oktetten, to nuller, bitmessig og oktetten med 11111100, som er heltallet, 252. Følgende uttalelse gjør det:

usignert char ch3 = oktett og 252;

CH3 har nå alle de seks siste bitene, som er de nødvendige bitene, selv om den fremdeles består av 8 biter. For å gjøre det til seks biter, må det tilordnes et strustbitfeltmedlem på 6 biter. Hvis Struct Bit-Field-medlemmet er S3.C, da vil oppgaven bli gjort som følger:

S3.C = CH3;

Fremover, S3.C vil bli brukt i stedet for CH2 for å indeksere base64 alfabetet array.

Resten av bithåndteringen kan gjøres som forklart i denne delen.

Base64 alfabet -matrise

For koding skal matrisen være noe sånt som,

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

Avkoding er den omvendte prosessen. Så et uordnet kart skal brukes til denne strukturen, noe som,

uordnede_map umap = 'a', 0, 'b', 1, 'c', 2, - - - '/', 63;

Strengklassen

Strengklassen skal brukes til de totale ikke-kodede og kodede sekvensene. Resten av programmeringen er normal C ++ programmering.

Konklusjon

Base64 er et karaktersett med 64 tegn, der hver karakter består av 6 biter. For koding konverteres hver tre-byte av den originale strengen til fire sekstetter på 6 biter hver. Disse sekstettene brukes som indekser for base64 alfabetetabellen for koding. Hvis sekvensen består av to tegn, oppnås fire seksteter fremdeles, med den siste sekstetten, som nummer 61. Hvis sekvensen består av ett tegn, oppnås fire seksteter fremdeles, med de to siste sekstettene, som er to av tallet 61.

Avkoding gjør det motsatte.