Skočiť na obsah


Programovanie v jazyku C a C#

Návody pre začiatočníkov a pokročilých



Fórum: Škôlka jazyka C
- - - - -
Fotografia

Bitové operácie


Operácie s bitmi - vysvetlenie princípu

Jedná sa o tieto operácie:
1. Bitový súčin.
2. Bitový súčet.
3. Bitový exkluzívny súčet.
4. Bitový posun doľava.
5. Bitový posun doprava.
6. Negácia bit po bite.

Napísal som na to program v céčku.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CISTI system("cls") // vycisti obrazovku
#define PAUZA system("pause") // pozastavi beh programu
 
char* des_dvoj(unsigned int desiatkove);
int dvoj_des(char *dvojkove);
void bit_sucin(char *bin1, char *bin2);
void bit_sucet(char *bin1, char *bin2);
void bit_exklu_sucet(char *bin1, char *bin2);
void bit_posunLavy(char *bin, int posun);
void bit_posunPravy(char *bin, int posun);
void bit_negacia(char *bin);
int mocnina_dvoch(int kolko);
 
 
int main (void)
{
    char *bin, *hex;
    int a, b, vyber;
 
    bin = (char *) malloc(33);
    hex = (char *) malloc(9);
    printf("<<< Ukazka principu prace bitovych operacii. >>>\n\n"
           "Zadajte dve cele cisla typu int:\n");
    scanf("%d%d", &a, &b);
    for (;;) {
        CISTI;
        printf("Boli zadane cisla %d a %d\n\n", a, b);
        printf("    ** MENU **\n\n"
               "1. Bitovy sucin.\n"
               "2. Bitovy sucet.\n"
               "3. Bitovy exluzivny sucet.\n"
               "4. Bitovy posun dolava.\n"
               "5. Bitovy posun doprava.\n"
               "6. Negacia bit po bite.\n"
               "7. Zmena vstupnych cisiel\n"
               "0. Koniec programu\n\n"
               "Vyberte si: ");
        scanf("%d", &vyber);
        switch (vyber) {
            /* bitovy sucin */
            case 1:
                CISTI;
                printf("Zadane cele cisla %d a %d prevedieme na binarne:\n", a, b);
                printf("%s  a  %s\n\n", des_dvoj(a), des_dvoj(b));
                printf("Zapis bitoveho sucinu decimalnych cisiel.\n"
                        "%d & %d = %d\n\n", a, b, a & b);
                bit_sucin(des_dvoj(a), des_dvoj(b));
                PAUZA;
                break;
            /* bitovy sucet */
            case 2:
                CISTI;
                printf("Zadane cele cisla %d a %d prevedieme na binarne:\n", a, b);
                printf("%s  a  %s\n\n", des_dvoj(a), des_dvoj(b));
                printf("Zapis bitoveho suctu decimalnych cisiel.\n"
                        "%d | %d = %d\n\n", a, b, a | b);
                bit_sucet(des_dvoj(a), des_dvoj(b));
                PAUZA;
                break;
            /* bitovy exkluzivny sucet */
            case 3:
                CISTI;
                printf("Zadane cele cisla %d a %d prevedieme na binarne:\n", a, b);
                printf("%s  a  %s\n\n", des_dvoj(a), des_dvoj(b));
                printf("Zapis bitoveho exkluzivneho suctu decimalnych cisiel.\n"
                        "%d ^ %d = %d\n\n", a, b, a ^ b);
                bit_exklu_sucet(des_dvoj(a), des_dvoj(b));
                PAUZA;
                break;
            /* bitovy posun do lava */
            case 4:
                CISTI;
                printf("Boli zadane cele cisla %d a %d, prve cislo prevedieme na binarne.\n", a, b);
                printf("%s\n\n", des_dvoj(a));
                printf("Zapis bitoveho posunu decimalneho cisla do lava o n bitov.\n"
                        "%d << %d = %d\n\n"
                        "Vysledok je vlastne:\ncislo %d vynasobene %d mocninou dvoch, teda cislom %d.\n\n"
                        , a, b, a << b, a, b, mocnina_dvoch(b));
                bit_posunLavy(des_dvoj(a), b);
                PAUZA;
                break;
 
            /* bitovy posun do prava */
            case 5:
                CISTI;
                printf("Boli zadane cele cisla %d a %d, prve cislo prevedieme na binarne.\n", a, b);
                printf("%s\n\n", des_dvoj(a));
                printf("Zapis bitoveho posunu decimalneho cisla do lava o n bitov.\n"
                        "%d >> %d = %d\n\n"
                        "Vysledok je vlastne:\ncislo %d vydelene %d mocninou dvoch, teda cislom %d.\n\n"
                        , a, b, a >> b, a, b, mocnina_dvoch(b));
                bit_posunPravy(des_dvoj(a), b);
                PAUZA;
                break;
 
            /* negacia bit po bite */
            case 6:
                CISTI;
                printf("Boli zadane cele cisla %d a %d, potrebujeme len prve cislo.\n", a, b);
                printf("Zapis negacie bitu po bite decimalneho cisla.\n"
                        "~%d = %d\n\n", a, ~a);
                bit_negacia(des_dvoj(a));
                PAUZA;
                break;
 
            /* zmena vstupnych cisiel */
            case 7:
                CISTI;
                printf("Zadajte dve cele cisla typu int:\n");
                scanf("%d%d", &a, &b);
                break;
 
            /* ukoncit priogram */
            case 0:
                CISTI;
                printf("\n              *********************\n"
                       "              ***  K O N I E C  ***\n"
                       "              *********************\n\n");
                return 1;
            default:
                printf(" Mimo rozsah vyberu!\n\n");
                PAUZA;
        }
    }
 
    return 0;
}
 
int mocnina_dvoch(int kolko)
{
    int i, mocnitel = 1;
 
    for (i = 1; i <= kolko; i++)
        mocnitel *= 2;
    return mocnitel;
}
 
/* negacia bit po bite */
void bit_negacia(char *bin)
{
    int i, rozdiel;
    char *binpom, *binvon;
 
    binpom = (char *) malloc(33);
    binpom[0] = '\0';
    binvon = (char *) malloc(33);
    binvon[0] = '\0';
        printf("Binarne cislo sa berie ako 32 bitove (v mojom PC),\n"
               "tak pred neho doplnime nuly do velkosti 32 bitov.\n\n");
        rozdiel = 32 - strlen(bin);
        for (i = 0; i < rozdiel; i++)
            binpom[i] = '0';
        binpom = strcat(binpom, bin);
        printf("Mame teda binarne cislo %s.\n", binpom);
        printf("Princip je nasledovny:\n"
                "Vsetky bity sa zmenia na opacnu hodnotu.\n\n");
        for (i = 0; i < strlen(binpom); i++) {
            binvon[i] = binpom[i] == '1' ? '0' : '1';
        }
        binvon[i] ='\0';
        printf("\nVysledne bin cislo je teda %s\na to je %d decimalne.\n\n", binvon, dvoj_des(binvon));
    //}
    //else
        //printf("Posun mimo rozsah!\n\n");
}
 
/* bitovy posun do prava */
void bit_posunPravy(char *bin, int posun)
{
    int i;
 
    if (strlen(bin) > posun) {
        printf("Mame teda binarne cislo %s a cislo posunu bitov do prava je %d.\n", bin, posun);
        printf("Princip je nasledovny:\n"
                "Z pravej strany binarneho cisla\n"
                "zmazeme tolko cisiel, o kolko sa ma\n"
                "cislo posunut do prava.\n\n");
        bin[strlen(bin) - posun] = '\0';
        printf("\nVysledne bin cislo je teda %s a to je %d decimalne.\n\n", bin, dvoj_des(bin));
    }
    else
        printf("Posun mimo rozsah!\n\n");
}
 
/* bitovy posun do lava */
void bit_posunLavy(char *bin, int posun)
{
    int i;
 
    if ((strlen(bin) + posun) < 32) {
        printf("Mame teda binarne cislo %s a cislo posunu bitov do lava je %d.\n", bin, posun);
        printf("Princip je nasledovny:\n"
                "Na pravu stranu za binarne cislo\n"
                "dopiseme tolko nul, o kolko sa ma\n"
                "cislo posunut do lava.\n\n");
        for (i = 0; i < posun; i++) {
            bin = strcat(bin, "0");
        }
        printf("\nVysledne bin cislo je teda %s a to je %d decimalne.\n\n", bin, dvoj_des(bin));
    }
    else
        printf("Posun mimo rozsah!\n\n");
}
 
/* bytovy sucin - demostracia */
void bit_sucin(char *bin1, char *bin2)
{
    int i, rozdiel;
    char pom, *binpom, *binvon;
 
    binpom = (char *) malloc(33);
    binpom[0] = '\0';
    binvon = (char *) malloc(33);
    binvon[0] = '\0';
    printf("Ukazka na akom principe pracuje bitovy sucin.\n\n");
    if (strlen(bin1) >= strlen(bin2)) {
        rozdiel = strlen(bin1) - strlen(bin2);
        for (i = 0; i < rozdiel; i++)
            binpom[i] = '0';
        binpom[i] = '\0';
        binpom = strcat(binpom, bin2);
        printf("Mame teda dve binarne cisla: %s\t%s\n", bin1, binpom);
        printf("Princip je nasledovny:\n"
               "Vysledok sucinu dvoch bitov bude 1, \n"
               "pokial i-ty bit x a i-ty bit y budu 1, \n"
               "inaksie bude 0.\n\n");
        for (i = 0; i < strlen(bin1); i++) {
            pom = (bin1[i] == '1') && (binpom[i] == '1') ? '1': '0';
            printf("%2d. x = %c, y = %c vysledok %c\n", i + 1, bin1[i], binpom[i], pom);
            binvon[i] = pom;
        }
        binvon[i] = '\0';
    }
    else {
        rozdiel = strlen(bin2) - strlen(bin1);
        for (i = 0; i < rozdiel; i++)
            binpom[i] = '0';
        binpom[i] = '\0';
        binpom = strcat(binpom, bin1);
        printf("Mame teda dve binarne cisla: %s\t%s\n", binpom, bin2);
        printf("Princip je nasledovny:\n"
               "Vysledok sucinu dvoch bitov bude 1,\n"
               "pokial i-ty bit x a i-ty bit y budu 1,\n"
               "inaksie bude 0.\n\n");
        for (i = 0; i < strlen(bin2); i++) {
            pom = (bin2[i] == '1') && (binpom[i] == '1') ? '1': '0';
            printf("%2d. x = %c, y = %c vysledok %c\n", i + 1, binpom[i], bin2[i], pom);
            binvon[i] = pom;
        }
        binvon[i] = '\0';
    }
    printf("\nVysledne bin cislo je teda %s a to je %d decimalne.\n\n", binvon, dvoj_des(binvon));
}
 
/* bytovy sucet - demostracia */
void bit_sucet(char *bin1, char *bin2)
{
    int i, rozdiel;
    char pom, *binpom, *binvon;
 
    binpom = (char *) malloc(33);
    binpom[0] = '\0';
    binvon = (char *) malloc(33);
    binvon[0] = '\0';
    printf("Ukazka na akom principe pracuje bitovy sucet.\n\n");
    if (strlen(bin1) >= strlen(bin2)) {
        rozdiel = strlen(bin1) - strlen(bin2);
        for (i = 0; i < rozdiel; i++)
            binpom[i] = '0';
        binpom[i] = '\0';
        binpom = strcat(binpom, bin2);
        printf("Mame teda dve binarne cisla: %s\t%s\n", bin1, binpom);
        printf("Princip je nasledovny:\n"
               "Vysledok sucinu dvoch bitov bude 1,\n"
               "pokial i-ty bit x alebo i-ty bit y bude 1.\n"
               "Ak budu obidva nulove, bude vysledok 0.\n\n");
        for (i = 0; i < strlen(bin1); i++) {
            pom = (bin1[i] == '1') || (binpom[i] == '1') ? '1': '0';
            printf("%2d. x = %c, y = %c vysledok %c\n", i + 1, bin1[i], binpom[i], pom);
            binvon[i] = pom;
        }
        binvon[i] = '\0';
    }
    else {
        rozdiel = strlen(bin2) - strlen(bin1);
        for (i = 0; i < rozdiel; i++)
            binpom[i] = '0';
        binpom[i] = '\0';
        binpom = strcat(binpom, bin1);
        printf("Mame teda dve binarne cisla: %s\t%s\n", binpom, bin2);
        printf("Princip je nasledovny:\n"
               "Vysledok sucinu dvoch bitov bude 1,\n"
               "pokial i-ty bit x alebo i-ty bit y bude 1.\n"
               "Ak budu obidva nulove, bude vysledok 0.\n\n");
        for (i = 0; i < strlen(bin2); i++) {
            pom = (bin2[i] == '1') || (binpom[i] == '1') ? '1': '0';
            printf("%2d. x = %c, y = %c vysledok %c\n", i + 1, binpom[i], bin2[i], pom);
            binvon[i] = pom;
        }
        binvon[i] = '\0';
    }
    printf("\nVysledne bin cislo je teda %s a to je %d decimalne.\n\n", binvon, dvoj_des(binvon));
}
 
/* bytovy exkluzivny sucet - demostracia */
void bit_exklu_sucet(char *bin1, char *bin2)
{
    int i, rozdiel;
    char pom, *binpom, *binvon;
 
    binpom = (char *) malloc(33);
    binpom[0] = '\0';
    binvon = (char *) malloc(33);
    binvon[0] = '\0';
    printf("Ukazka na akom principe pracuje bitovy sucet.\n\n");
    if (strlen(bin1) >= strlen(bin2)) {
        rozdiel = strlen(bin1) - strlen(bin2);
        for (i = 0; i < rozdiel; i++)
            binpom[i] = '0';
        binpom[i] = '\0';
        binpom = strcat(binpom, bin2);
        printf("Mame teda dve binarne cisla: %s\t%s\n", bin1, binpom);
        printf("Princip je nasledovny:\n"
               "Vysledok sucinu dvoch bitov bude 1,\n"
               "pokial i-ty bit x sa nerovna i-temu bitu y,\n"
               "ak su obidva nulove, alebo obidva jednotkove,\n"
               "vysledok bude 0.\n\n");
        for (i = 0; i < strlen(bin1); i++) {
            pom = bin1[i] == binpom[i] ? '0': '1';
            printf("%2d. x = %c, y = %c vysledok %c\n", i + 1, bin1[i], binpom[i], pom);
            binvon[i] = pom;
        }
        binvon[i] = '\0';
    }
    else {
        rozdiel = strlen(bin2) - strlen(bin1);
        for (i = 0; i < rozdiel; i++)
            binpom[i] = '0';
        binpom[i] = '\0';
        binpom = strcat(binpom, bin1);
        printf("Mame teda dve binarne cisla: %s\t%s\n", binpom, bin2);
        printf("Princip je nasledovny:\n"
               "Vysledok sucinu dvoch bitov bude 1,\n"
               "pokial i-ty bit x alebo i-ty bit y bude 1.\n"
               "Ak budu obidva nulove, bude vysledok 0.\n\n");
        for (i = 0; i < strlen(bin2); i++) {
            pom = binpom[i] == bin2[i] ? '0' : '1';
            printf("%2d. x = %c, y = %c vysledok %c\n", i + 1, binpom[i], bin2[i], pom);
            binvon[i] = pom;
        }
        binvon[i] = '\0';
    }
    printf("\nVysledne bin cislo je teda %s a to je %d decimalne.\n\n", binvon, dvoj_des(binvon));
}
 
/* prevod z dvojkoveho na desiatkove, vystup desiatkove (int) */
int dvoj_des(char *dvojkove)
{
    int i, j, pocet, mocnitel;
    int descis = 0;
 
    /* vypis vypoctu mocnitelov */
    pocet = strlen(dvojkove);
    for (j = 0; j < pocet; j++) {
        mocnitel = 2;
        for (i = 1; i < (pocet - j) - 1; i++)
            mocnitel *= 2;
        if (j == (pocet - 1)) {
            if (dvojkove[j] == 0)
                mocnitel = 0;
            else
                mocnitel = 1;
        }
        /* vypocet desiatkoveho cisla a jeho vypis */
        descis += ((int) dvojkove[j] - 48) * mocnitel;
    }
    return descis;
}
 
/* prevod z desiatkoveho na dvojkove, vystup dvojkove (retazec) */
char* des_dvoj(unsigned int desiatkove)
{
    int i = 0, j, k = -1;
    char *p_dvojkove, *p_pom;
 
    p_dvojkove = (char *) malloc(33);
    p_pom = (char *) malloc(33);
 
    while (desiatkove != 0) {
        p_pom[i] = (desiatkove % 2) + 48;
        desiatkove /= 2;
        i++;
    }
    p_pom[i] = '\0';
    for (j = i; j >= 0; j--)
        p_dvojkove[j] = p_pom[k++];
    p_dvojkove[i + 1] = '\0';
    return (p_dvojkove);
}
  • 0

Popis: Operácie s bitmi - vysvetlenie princípu
Poznámky:
Odkazy:


0 Komentárov


Najlepšie lekcie


Najnovšie pridané lekcie


Najnovšie komentáre


Najviac komentované lekcie


Najviac zobrazené lekcie


Náhodné lekcie


Na tejto stránke bolo užívateľ(ov) za posledných 30 minút

členov, návštevníkov