C-keeles kahendarvude kuvamine: bittoperatsioonid ja uus C23 %b täpsustaja

1. Sissejuhatus

Mis on kahendsüsteem ja miks see on oluline?

Kahendsüsteem on arvutimaailma kõige põhilisem arvuesituse viis. Nullide ja ühtede kombinatsioonidega kujutatakse nii mälus olevaid andmeid kui ka riistvara seisundit. Programmeerimises kasutatakse kahendsüsteemi sageli bittide töötlemisel, olekute haldamisel ja binaarfailide analüüsimisel.

C-keel on laialdaselt kasutatav keel tõhusate programmide kirjutamiseks, kuid standardraamatukogus puudub otsene viis kahendarvude kuvamiseks. Selles artiklis selgitame samm-sammult, kuidas C-keeles kahendarve kuvada, tuues välja nii lihtsad näited algajatele kui ka praktilised koodinäited ning käsitledes uusimat C23 standardit.

2. Arvude kuvamise põhialused C-keeles | 10nd-, 16nd- ja 8nd-süsteem

Standardsete vormingutäpsustajate selgitus

C-keeles saab numbreid ekraanile kuvada printf funktsiooni abil. Allpool on toodud tüüpilised vormingutäpsustajad ja nende kasutus:

• %d: kümnendsüsteem (täisarvu vaikimisi esitus)
• %o: kaheksandsüsteem (tihti algab 0-ga)
• %x / %X: kuueteistkümnendsüsteem (väiketähed / suurtähed)

Näiteks järgmine kood kuvab arvu mitmes vormingus:

#include <stdio.h>

int main() {
    int num = 42;

    printf("Kümnendsüsteem: %d
", num);
    printf("Kaheksandsüsteem: %o
", num);
    printf("Kuueteistkümnendsüsteem: %x
", num);

    return 0;
}

Väljundinäide:

Kümnendsüsteem: 42
Kaheksandsüsteem: 52
Kuueteistkümnendsüsteem: 2a

Miks puudub kahendarvude vormingutäpsustaja?

C-keele standardraamatukogus puudub kahendsüsteemi jaoks mõeldud vormingutäpsustaja. Selle põhjuseks on ajalooline kujundusfilosoofia: kuna C loodi algselt süsteemiprogrammeerimiseks, peeti olulisemaks mälu tõhusat kasutamist kui kahendsüsteemis kuvamist.

3. Kahendarvude kuvamine C-keeles (koodinäidetega)

Meetod bittoperaatoritega

C-keeles saab kahendarvude kuvamist saavutada bittoperatsioonide abil. Allpool on näide koodist, mis kuvab 8-bitise arvu kahendsüsteemis:

#include <stdio.h>

void printBinary(int num) {
    for (int i = 7; i >= 0; i--) {
        printf("%d", (num >> i) & 1);
    }
    printf("
");
}

int main() {
    int num = 42;
    printf("Kahendsüsteem: ");
    printBinary(num);

    return 0;
}

Väljundinäide:

Kahendsüsteem: 00101010

Koodi selgitus

• (num >> i): nihutab arvu num paremale, et tuua vastav bitt madalaimale positsioonile.
• & 1: eraldab madalaima biti.
• printf: väljastab iga biti järjestikku.

See meetod on lihtne ja paindlik, võimaldades kasutada ükskõik millist täisarvu.

Universaalne enda kirjutatud funktsioon

Kahendarvude kuvamist saab muuta paindlikumaks, kirjutades funktsiooni, mis toetab suvalist bitilaiust:

#include <stdio.h>

void printBinaryGeneric(unsigned int num, int bitWidth) {
    for (int i = bitWidth - 1; i >= 0; i--) {
        printf("%d", (num >> i) & 1);
    }
    printf("
");
}

int main() {
    int num = 42;
    printf("16-bitine kahendsüsteem: ");
    printBinaryGeneric(num, 16);

    return 0;
}

Väljundinäide:

16-bitine kahendsüsteem: 0000000000101010

Konkreetseid kasutusjuhtumeid

1. Bitilippude haldamine

Bittide abil saab mitut lippu hallata üheainsa muutuja sees. Näiteks järgmistes olukordades:

• Kontrollida, kas lipp on sees või väljas.
• Lülitada konkreetne lipp sisse.
• Lülitada konkreetne lipp välja.

2. Silumiseks mõeldud väljund

Programmi silumisel võib olla vaja kontrollida mälu sisu kahendsüsteemis. Sellistes olukordades on kahendarvude kuvamine väga kasulik.

4. Uus funktsioon C23 standardis: %b täpsustaja

%b-täpsustaja ülevaade

Varasemates C-keele versioonides ei olnud standardset viisi kahendarvude kuvamiseks vormingutäpsustajaga. Kuid C23 standard tõi kaasa uue täpsustaja:

• %b: vormingutäpsustaja kahendarvude kuvamiseks.

See muudab kahendarvude kuvamise palju lihtsamaks, ilma et peaks ise lisafunktsioone kirjutama.

Koodinäide: kahendarvude kuvamine C23 %b täpsustajaga

Alljärgnev on lihtne näide, kus kasutatakse %b täpsustajat:

#include <stdio.h>

int main() {
    int num = 42;

    printf("Kahendsüsteem: %b
", num);

    return 0;
}

Väljundinäide:

Kahendsüsteem: 101010

%b-täpsustaja eelised

1. Lihtsus

• Pole vaja keerulisi bittoperatsioone ega tsükleid, kood jääb puhtam ja lühem.

1. Loetavus

• See ühtlustab koodi teiste täpsustajatega ja parandab üldist loetavust.

Kompilaatori tugi

Kuna C23 standard on uus, ei toeta kõik kompilaatorid veel %b-täpsustajat. Allpool on kokkuvõte praegusest olukorrast:

• Toetatud kompilaatorid
• GCC: osaline tugi alates versioonist 12.
• Clang: tugi viimastes versioonides.
• Mitte toetatud kompilaatorid
• Vananenud GCC ja Clang versioonid või mõned spetsiifilised kompilaatorid ei pruugi seda toetada.

Mida teha, kui sinu keskkond ei toeta?

Kui sinu kompilaator ei toeta C23 standardit ega %b-täpsustajat, on võimalik kasutada järgmisi lahendusi:

1. Kasuta enda kirjutatud funktsiooni

Kasutada saab varem näidatud funktsioone, mis tuginevad bittoperatsioonidele (nt printBinary).

2. Kasuta kolmandate osapoolte teeke

Mõned teegid (nt glib) pakuvad mugavaid tööriistu kahendarvude kuvamiseks.

3. Uuenda arenduskeskkonda

Soovi korral paigalda uus kompilaatori versioon, et kasutada C23 funktsionaalsust.

5. Diagrammid: kahendarvude kuvamine ja bittide töötlemine

5.1 Kahendarvudeks teisendamise protsess

Allpool on näide, kuidas teisendada kümnendarv kahendarvuks:

Näide: teisenda kümnendarv „42” kahendarvuks

1. 42 ÷ 2 (jaga ja salvesta jääk)

• Jagatis: 21, jääk: 0

1. 21 ÷ 2

• Jagatis: 10, jääk: 1

1. 10 ÷ 2

• Jagatis: 5, jääk: 0

1. 5 ÷ 2

• Jagatis: 2, jääk: 1

1. 2 ÷ 2

• Jagatis: 1, jääk: 0

1. 1 ÷ 2

• Jagatis: 0, jääk: 1

Kui loeme jäägid tagurpidi, saame tulemuseks „101010”, mis on arvu 42 kahendarvuline kuju.

Diagramm: teisendamisprotsess

42 ÷ 2 = 21 ... 0
21 ÷ 2 = 10 ... 1
10 ÷ 2 = 5  ... 0
5  ÷ 2 = 2  ... 1
2  ÷ 2 = 1  ... 0
1  ÷ 2 = 0  ... 1
--------------
Kahendsüsteem: 101010

See protsess on sama ka programmi sees ning aitab paremini mõista koodi tööpõhimõtteid.

5.2 Bittoperatsioonide visuaalne selgitus

Bittoperatsioone kasutatakse konkreetsete bittide muutmiseks arvus. Allpool on toodud näited tüüpilistest operatsioonidest – nihkeoperatsioonid.

Parem nihkeoperatsioon (>>)

Parem nihkeoperatsioon liigutab arvu bitte paremale.

• Näide: nihuta kahendarvu „101010” ühe positsiooni võrra paremale
• Algväärtus: 101010 (kümnendarv: 42)
• Paremale nihutatud: 010101 (kümnendarv: 21)

Diagramm: parem nihutus

Algväärtus:    101010
Parem nihutus: 010101

Kasutus:

• Arvu kahega jagamise tulemuse saamine (täisarvuna).
• Spetsiifiliste bittide eraldamine.

Vasak nihkeoperatsioon (<<)

Vasak nihkeoperatsioon liigutab arvu bitte vasakule.

• Näide: nihuta kahendarvu „101010” ühe positsiooni võrra vasakule
• Algväärtus: 101010 (kümnendarv: 42)
• Vasakule nihutatud: 1010100 (kümnendarv: 84)

Diagramm: vasak nihutus

Algväärtus:   101010
Vasak nihutus: 1010100

Kasutus:

• Arvu kahekordistamine.
• Kiire korrutamise realiseerimine.

5.3 Bittide haldamine maskidega

Maskoperatsioone kasutatakse konkreetsete bittide muutmiseks. Vaatame näidet:

Näide: lülita neljas bitt sisse (OR operatsioon)

• Algväärtus: 00001010 (kümnendarv: 10)
• Mask: 00010000 (ainult neljas bitt on 1)
• Tulemus: 00011010 (kümnendarv: 26)

Diagramm: OR operatsiooni tööpõhimõte

  00001010  (algväärtus)
| 00010000  (mask)
------------
  00011010  (tulemus)

Kasutus:

• Konkreetse biti sisselülitamine.
• Lippude haldamine.

6. KKK (Korduma kippuvad küsimused)

K1: Miks ei ole C-keeles standardset kahendsüsteemi vormingutäpsustajat?

V:
Kui C-keelt algselt kavandati, oli peamine eesmärk programmide tõhusus. Seetõttu lisati standardraamatukogusse ainult kümnend-, kaheksand- ja kuueteistkümnendsüsteemi väljund, samas kui kahendsüsteemi peeti liiga spetsiifiliseks kasutusjuhuks.
C23 standardis lisatud %b-täpsustaja muudab aga nüüd kahendsüsteemi kuvamise palju lihtsamaks.

K2: Mida teha, kui C23 %b-täpsustaja ei ole minu keskkonnas saadaval?

V:
Kui sinu kompilaator ei toeta C23 standardit, proovi järgmisi võimalusi:

1. Kasuta enda kirjutatud funktsiooni
   Näiteks funktsioon printBinary, mis põhineb bittoperatsioonidel.
2. Paigalda toetatud kompilaator
   Laadi alla ja kasuta uusimat GCC või Clang versiooni.
3. Kasuta kolmandate osapoolte teeke
   Mõned teegid sisaldavad abifunktsioone kahendsüsteemi väljundiks.

K3: Kas on tõsi, et Pythonis ja Javas on kahendarvude kuvamine lihtsam?

V:
Jah, Pythonis ja Javas on see väga lihtne. Näited:

Python

num = 42
print(bin(num))  # väljund: 0b101010

Java

int num = 42;
System.out.println(Integer.toBinaryString(num));  // väljund: 101010

Nendes keeltes on olemas sisseehitatud funktsioonid, samas kui C-keeles tuleb kasutada kas bittoperatsioone või C23 uusi võimalusi.

K4: Miks ei anna „parem nihutus” alati oodatud tulemust?

V:
Kontrolli järgmisi punkte:

1. Kasutad märgiga täisarvu

• Märgiga täisarvude (nt int) puhul võib paremale nihutamisel säilida märgibitt (aritmeetiline nihutus).
• Lahendus: kasuta märgita tüüpe (nt unsigned int).

1. Nihke ulatus on liiga suur

• Kui nihutatavate bittide arv ületab andmetüübi laiuse (nt 32 bitti), võib tulemus olla määratlemata.
• Kontrolli, et nihke väärtus oleks sobiv.

K5: Miks mõnikord jääb printf-i kahendsüsteemi väljund lühemaks kui oodatud?

V:
See juhtub, kui bittide arv pole fikseeritud. Probleemi lahendamiseks kasuta funktsiooni, mis kuvab alati määratud arvu bitte.

Näide 16-bitise väljundi jaoks:

void printBinaryFixed(unsigned int num) {
    for (int i = 15; i >= 0; i--) {
        printf("%d", (num >> i) & 1);
    }
    printf("
");
}

Nii tagatakse alati kindla pikkusega väljund.

K6: Kas kahendarvude kuvamist kasutatakse ka päris projektides?

V:
Jah, eriti järgmistes olukordades:

1. Riistvara juhtimine

• Seadmedraiverite arendamine, kus seadeid tehakse bittide kaupa.

1. Binaarandmete analüüs

• Failiformaatide või võrguprotokollide analüüsimisel.

1. Silumine

• Lippude või olekute kontrollimiseks.

K7: Millised õppematerjalid aitavad bittoperatsioone ja kahendsüsteemi paremini mõista?

V:
Soovitatavad ressursid:

• Raamatud
• „C-keele programmeerimise sissejuhatus” – katab alused ja bittoperatsioonid.
• „Süsteemiprogrammeerimine C-keeles” – praktilised rakendused.
• Veebiallikad
• GeeksforGeeks: põhjalikud selgitused kahendsüsteemi ja bittoperatsioonide kohta.
• Qiita: palju artikleid, eriti jaapani keeles.

7. Kokkuvõte

Artikli kokkuvõte

Selles artiklis käsitlesime erinevaid viise, kuidas kuvada kahendarve C-keeles – alustades põhitõdedest ja lõpetades C23 uute võimalustega. Allpool on võrdlustabel meetodite ülevaatega:

Soovitused lugejale

• Proovi artiklis toodud koodinäiteid oma keskkonnas. Praktiline katsetamine aitab mõista kahendarvude kuvamist ja bittoperatsioone.
• Kasutage bittoperatsioone lippude haldamiseks või silumiseks oma projektides.

Soovitused edasiseks õppimiseks

1. Korda bittoperatsioonide aluseid

• Harjuta nihutus- ja loogikaoperatsioone (AND, OR), et arendada tõhusamaid programmeerimisoskusi.

1. Katseta C23 uusi funktsioone

• Proovi %b-täpsustajat ja tutvu teiste C23 täiustustega.

1. Võrdle teiste programmeerimiskeeltega

• Vaata, kuidas Python või Java lahendavad kahendarvude kuvamist, et mõista erinevusi ja sarnasusi C-keelega.