Reprezentacia cisla v unsigned int – C / C++ – Fórum – Programujte.com

Zdravim,

zaujimalo by ma ako je ulozene hexadecimalne cislo 0xAAA6AA6A ktore je ulozene v premennej o type unsigned int.

Konkretne som zosmolil nasledujuci kod (ano je to dost prasacke)

#include <stdio.h>
#include <math.h>

const int MAX = 32;

int main()
{
    unsigned int manchester = 0xAAA6AA6A;

    double mask = 0;
    unsigned int mask2 = 0;

    for (int i = 0; i < MAX; i++)
    {
        mask = pow(2.0, (i-1));
        mask2 = mask;


        if (manchester & mask2 )
            printf("1");
        else
            printf("0");
    }

    printf("\n");

    return 0;
}

vystup je 00101011001010101011001010101010

ked si vsak prevediem AAA6AA6A do binarnej sustavy tak dostavam

10101010101001101010101001101010.

Respektive ma niekto nejaky napad ako by som mohol pracovat s priamim bynarnim kodom ked ho nacitam cez funkciu scanf trebars ?

Dakujem za pripadnu pomoc.

#include <stdio.h>


int main(int argc, char **argv) {
  unsigned int manchester = 0xAAA6AA6A, i;
  for ( i = 0x80000000; i>0; i>>=1 ) { // pripadne i = 1u << 31; ..
    printf("%d", ((manchester & i) != 0) );
  }
  printf("\n");

  return 0;
}

hmm Dakujem,

viacmenej by ma zaujimalo preco je tam prave konstanta 0x80000000 a co konkratne znamena (i>>=1, bitovy posun doprava o 1 ? Preco ?). A existuje nejaky jednoduchy sposob pracovania s priamim bynarnim kodom po nacitani ho v hexadecimalke ? Konkretne by mi prislo dost narocne to takto prevadzat zvlast a potom zapisovat bit po bite do nejakej premennej a potom snim az pracovat.

Dakujem za pripadnu odpoved.

/*jde vicemene o to mit tam:
10000000000000000000000000000000  (0x80000000)
a kdyz udelas  i >>= 1 tak vznikne toto:
01000000000000000000000000000000
00100000000000000000000000000000
00010000000000000000000000000000
00001000000000000000000000000000
00000100000000000000000000000000
a tak dale...

jinak samozrejme muzes udelat i opacne:
*/
unsigned int j=1;
for (i=1; i<32; ++i, j<<=1) {
  ...
}
// akorat to bude vypisovany odzadu

ok takze v podstate to znamena ze to hexadecimalne cislo sa uklada v priamom bynarnom kode a nie v nejakom doplnkovom atd ?

Cize ten moj zdrojak je v podstate zly ? A jak by som mohol pristupovat konkretne k hocijakemu bitu toho cisla 0xAAA6AA6A ? Jak tam je ulozene to podciarknute acko ? Na najvyssej adrese alebo ?

v pocitaci je vsechno v binarnim kodu.. pouziva se dvojkova soustava a cokoliv zobrazujes tak se prepocitava do desitkove soustavy...

pristup k libovolnemu bitu je jednoduchy:    int bit = (cislo & (1u << bit)) != 0   (nebo se to da narvat do unsigned char a podobny ciselny hodnoty)

pripadne varianta:    .. = (cislo >> bit) & 1;   (bacha pozice bitu je pocitana od nuly takze 0 az 31)

a k ulozeni:  0x12345678  tak  1 je nejvice platny nibble (skupina 4bitu) a kde presne bude v RAM zalezi na architekture procesoru..  jsou dve -- little endian a big endian  - v obvyklych procesorech se pouziva little endian a znamena to ze v Ram budou hodnoty cca takto:  0x78 0x 56 0x34 0x12  ( to bys nasel pokud zapises na disk tak jak je - jen binarne )

Pak sou procesory co to maji opacne (PA-RISC, SPARC, PowerPC....)

ano, ale mna konkretne zaujima :

povadzme ze si nacitam cislo AAA6AA6A a ulozim ho do premennej typu unsigned int. Teraz by som chcel porovnavat vsetky susedne dvojice bitov (tu by bolo mi dobre dat nejaky typ jak to robit). To cislo AAA6AA6A je teda ulozene v priamom kode 

? (10101010101001101010101001101010) . Alebo ho bude treba na ten priamy kod nejak previest ? Ja som si totiz myslel ze vsetky cisla su ulozene v dvojkovom doplnkovom kode a desatinne cisla su ulozene vo formate ktory popisuje standart IEEE 754.

Dakujem za pripadnu odpoved.

v doplnkovem kode sou ukladany jen cisla se znamenkem ..

pokud chces nacist neco jako AAA6AA6A tak muzes vyuzit funkce z knihoven, nebo si to prevest sam...

neni to nic slozityho (byva to jeden z prvnich ukolu co dostavaj studenti programovani - prevody mezi ciselnejma soustavama)

Ja to ale nepotrebujem prevadzat , to by som menil specifikator %d na %X vo funkcii printf atd a sa mi to zobrazi jak chcem . Proste ma zaujima ze ked to cislo sa ulozi do premennej ci tam bude v priamom kode , alebo v nejakom doplnkovom atd. Takze cisto teoreticky : Ked nacitam cislo AAA6AA6A a ulozim ho do premennej unsigned int a budem porovnavat dvojicu susednych bitov tak budem pracovat s 10101010101001101010101001101010 a nie s nejakym binarakom v inom tvare ...

nejak sa v tom asi stracam :D

#include <stdio.h>

int main(void)
{
    unsigned int hex = 0xAAA6AA6A;
    unsigned int bum;
    int i = 1;
    while(i < 32)
{
    bum = (hex >> i) & 1;
    printf("%u", bum);
    i++;
}
    printf("\n");
    return 0;
}

toto mi vypise to binarne opacne (aspon dufam) (asi kvoli tomu little endian predpokladam ?). No a ked miesto 0xAAA6AA6A dam 0xF tak to miesto 1111... vypise len 111... , kde je prosim chyba ?

no u tohodle na tom nezalezi.. se to prevadi stejnym zpusobem

ty mas problem v tom ze 0. bit je nejmene platny bit (vaha 1) a 31 s vahou 2^31 ... + samozrejme zacinas od 1 takze prijdes o ten LSB (nejmene platny bit)

hmm to bola fakt dost blba chyba :( Este by ma zaujimalo jak porovnavat dve dvojcie bitov tak aby prva dvojica vypisala vzdy 1. Konkretne mam na mysli :

 printf("1");
    int result = 1;

    for (int j = 2; j < 28; j += 2)
    {


        unsigned int aktual0 = (hex >> j) & 1;
        unsigned int aktual1 = (hex >> (j+1)) & 1;
        unsigned int aktual2 = (hex >> (j+2)) & 1;
        unsigned int aktual3 = (hex >> (j+3)) & 1;

        if (aktual0 == aktual1 || aktual2 == aktual3)
        {
            printf("niet"); break;
        }
        else if (aktual0 == aktual2 && aktual1 == aktual3)
        {
            if (result == 0){
                printf("0");
            }
            else
                printf("1");

        }
        else if (aktual0 != aktual2 || aktual1 != aktual3)
        {
            if (result == 0)
            {
                printf("1");
                result = 1;
            }
            else
            {
                printf("0");
                result = 0;
            }
        }

    }

Konkretne by som to mal zosmolit tak, aby prva dvojica bitov hodila jednotku, ak je druha dvojica rovnaka ako prva tak da 0, ak tretia rovnaka ako druha tak 0 ak stvrta rozdielna od tretej tak 1 atd... Proste ak su dve dvojice po sebe rovnake tak sa vrati predosla hodnota, ak nie tak sa vrati opacna hodnota. Snad to bude dobre vidiet na priklade

mame trebars bin cislo 10 10 10 10 10 01 10    tak mi to vypise 1 0 0 0 0 1 1,

pre 10 01 10 10 01 10 01 by to hodilo 1 1 1 0 1 1 1

pre 10 01 10 10 10 10 01 by to hodilo 1 1 1 0 0 0 1

atd. Henten kod mi nejak nejde (hex je cislo kde su tie dvojice bitov a result je predchadzajuca hodnota). Pri zhode 00 or 11 to ma vypisat nejaku hlasku a skoncit ...

Je uz dost neskoro tak to necham lezat do zajtra :).

Dik za pripadnu pomoc ...

"Proste ak su dve dvojice po sebe rovnake tak sa vrati predosla hodnota, ak nie tak sa vrati opacna hodnota. Snad to bude dobre vidiet na priklade"

To som zase trepol blbost, ak su dve dvojice po sebe rovnake tak sa vrati 0 inac 1 ...

nu muzes vyuzit posun a jinou bitovou masku...

treba

for (int i=30; i>=0; i-=2) {
  unsigned char stav = (manchester >> i) & 3;
  if ( stav == 0 || stav == 3 ) {
    ... chyba ... // je nesmysl aby byly cisla 0b11 neb 0b00 (aspon v tomto kodovani)
  } else {
    stav >>=1; // stav je ted 0/1 podle toho jaka hodnota byla opravdu poslana
  }
}

hmm to je nejak vysoko na mna :D z toho kodu co som zosmolil  vyssie tak ak by premenna hex obsahovala 0xAAA6AA6A       (10 10 10 10 10 10 01 10 10 10 10 10 01 10 10 10)  tak by to malo vypisat 1000001100001100 .  Ja proste nejak neviem najist chybu v tom kode .

a co třeba? :)

UINT hex = 0xAAA6AA6A;
cout << bitset<sizeof(UINT) * 8>(hex);
// -> 10101010101001101010101001101010

Nemozem pouzivat prvky jazyka C++. Nieje mi celkom jasne jak by som mohol vyuzit

for (int i=30; i>=0; i-=2) {
  unsigned char stav = (manchester >> i) & 3;
  if ( stav == 0 || stav == 3 ) {
    ... chyba ... // je nesmysl aby byly cisla 0b11 neb 0b00 (aspon v tomto kodovani)
  } else {
    stav >>=1; // stav je ted 0/1 podle toho jaka hodnota byla opravdu poslana
  }
}

k urcovaniu toho ci sa dve dvojice zhoduju or nie :(

Tak si pridame vypisy kdyz nemame zadnou predstavivost:

#include <stdio.h>

int main() {
  unsigned int manchester = 0xAA6AAA6A; // 0b10101010011010101010101001101010
  int i;
  for (int i=30; i>=0; i-=2) {
    unsigned int stav = (manchester >> i) & 3;
    if ( stav == 0 || stav == 3 ) {
    //... chyba ... // je nesmysl aby byly cisla 0b11 neb 0b00 (aspon v tomto kodovani)
    } else {
      printf("%d,%d\n",(stav&2)!=0,(stav&1)!=0);
      //stav >>=1; // stav je ted 0/1 podle toho jaka hodnota byla opravdu poslana
    }
  }
}

Ja by som to spravil takto:

#include <stdio.h>

int main(){
	unsigned long x = 0xAA6AAA6A;
	unsigned long y = (x ^ (x >> 2));

	for(unsigned long mask = 3; mask <= x; mask <<= 2){
		if( (mask & y) )putchar('1');
		else putchar('0');
	}
	putchar('1');
}

vypise to ale v opacnom poradi 

Nebo můžeš přes rekurzi 

void ToBinary(unsigned long value)
{
    unsigned long bin;

    if (value == 1)
    {
        printf("%lu", value);
        return;
    }
    bin = value % 2;
    ToBinary(value >> 1);    
    printf("%lu", bin);
}

// ToBinary(0xAAA6AA6A);

hmm mozna ma par ludi nepochopilo , ja som konkretne chcel aby z tej binarky ktora je ulozene v unsigned int

co je uplne dole ako dif. manchester vyslo to co je hore (data). K tomu som zosmolil 

 printf("1");
    int result = 1;

    for (int j = 2; j < 28; j += 2)
    {


        unsigned int aktual0 = (hex >> j) & 1;
        unsigned int aktual1 = (hex >> (j+1)) & 1;
        unsigned int aktual2 = (hex >> (j+2)) & 1;
        unsigned int aktual3 = (hex >> (j+3)) & 1;

        if (aktual0 == aktual1 || aktual2 == aktual3)
        {
            printf("niet"); break;
        }
        else if (aktual0 == aktual2 && aktual1 == aktual3)
        {
            if (result == 0){
                printf("0");
            }
            else
                printf("1");

        }
        else if (aktual0 != aktual2 || aktual1 != aktual3)
        {
            if (result == 0)
            {
                printf("1");
                result = 1;
            }
            else
            {
                printf("0");
                result = 0;
            }
        }

    }

niesu na nete nejake vystizne ukazky ako pracovat s  jednotlivimi bitmi v bajte ? Ono ja tym bitovim operaciam snad rozumiem ale par veci mi nieje jasnych.

s jednotlivými bity v byte pracuješ pomocí bitových operací jako bitový součin, bitový součet, bitový exkluzívní součet, posuny vpravo a vlevo. Pokud chci porovnat např. 6 a 2 bit v byte:

byte mybyte = 0x7e;

bool sesty = mybyte & 0x40;
bool druhy = mybyte & 0x02;
if (sesty == druhy)   {
  //oba byte maji stejnou hodnotu
}

lze to i zkrátit

byte mybyte = 0x7e;


if ( (mybyte & 0x40) == (mybyte & 0x02) )   {
  //oba byte maji stejnou hodnotu
}

Takto můžeš maskovat i skupiny bitů v bytech a porovnávat jejich hodnoty. Stejný postup jde použít i pro unsigned int

hu

aby ti neshodné bity vrátili 1 a shodné 0 můžeš použít EX-OR (exkluzívní součet)

hu

#21 Zajcev

Ten priklad co som napisal vyzsie funguje, len som vysledok vypisal od LSB. Funguje nasledovne:

10 10 10 10 10 10 01 10 10 10 10 10 01 10 10 10	// vstup x
xx 10 10 10 10 10 10 01 10 10 10 10 10 01 10 10 // (x >> 2)
xx 00 00 00 00 00 11 11 00 00 00 00 11 11 00 00 // x ^ (x >> 2)
//zobrazenie v 4 sustave:
xx 0  0  0  0  0  3  3  0  0  0  0  3  3  0  0	
//vypis na stdout :
1  0  0  0  0  0  1  1  0  0  0  0  1  1  0  0   //  <- vypisany odzadu

je tam jedna potencialna chyba, lepsie je dat vo for cykle podmienku mask < x 

no nevim ale manchester encoding a decoding sem pochopil naprosto jinak nez mas na diagramu ... se vubec neblizis ani S-PDIF protokolu...

hento je zo zadania ...

inac vitamin nwm ale tam konkretne mi to u mna pise 0011000000110001 ...

Skusil som este nieco taketo 

#include <stdio.h>
#include <unistd.h>

int main(void)
{
    usleep(100000);
    unsigned int hex = 0xAAA6AA6A;
    unsigned int begin = hex & 3;
    unsigned int previous, next, result = 1;

    printf ("1");

    for (int i = 2; i <=30; i += 2)
    {
        previous = (hex >> (i)) & 3;
        next = (hex >> (i+2)) & 3;

        if ((i == 2) && (begin == previous))
        {
            printf("0");
            result = 0;
            continue;
        }
        else if ((i == 2) && (begin != previous))
        {
            printf("1");
            result = 1;
            continue;
        }

        if ((result == 1) && (previous == next))
        {
            printf("0");
            result = 0;
        }
        else if ((result == 0) && (previous == next))
        {
            printf("0");
            result = 0;
        }
        else if ((result == 0) && (previous != next))
        {
            printf("1");
            result = 1;
        }
        else if ((result == 1) && (previous != next))
        {
            printf("0");
            result = 0;

        }


    }

    printf("\n");

    return 0;

}

a fakt tam nwm najist chybu :(((((((((((((((((((  V tej premennej begin su ulozene tie prve dve bity ... Previous je aktualna dvojica a next je dalsia dvojca bitov.

ta hodnota v x je len ilustracna, dosad si tam vlastnu hodnotu :)

a co vyslo z meho kodu:

0xAAA6AA6A =>  0b1111110111110111

nebo  0xA69596AA => 1101100010011111  (http://en.wikipedia.org/wiki/File:Manchester_code.png)

ta hodnota x tam je AAA6AA6A a vracia ti to 0011000000110001 a malo by to vratit to co je natom mojom diagmrame v data ... Inac ja nepotrebujem aby to pracovalo podla wikipedii ale podla toho diagramu. To jest prva dvojica bitov vzdy vrati 1, druha ak je rovnaka jak prva vrati 0 , tretia ak je rovnaka jak druha tak zase 0. Proste zmena hodnoty nastava len pri zmene 01 na 10 a naopak. Cize ore 10 01 10 01 01 to vrati 1 1 1 1 0 , pre 01 10 10 10 10 01 to vrati 1 1 0 0 0 1 atd.

Tiez na vstup budu vzdy davane len cisla ktore vyuziju cely unsigned int (obvykle 32b).  Tie cisla co som uvadzal o riadok vyssie su len ako ukazkove ...

Tak moj kod upraveny do podoby co by si chcel:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main(){
	uint32_t x = 0xAAA6AA6A;
	uint32_t y = (x ^ (x >> 2)) | (3<<30);
	uint32_t mask = (3<<30);
	
	do{
		if( (mask & x) == 0 ||  (mask & x) == mask){
			puts("\nchyba!");
			return EXIT_FAILURE;
		}
		if( (mask & y) )putchar('1');
		else putchar('0');
	}while(mask >>= 2);
	
	return EXIT_SUCCESS;
}

Ale netusim co je to za kodovanie, len to robi to co je na diagrame.

ten tvuj diagram je (jak uz sem tu psal jednou) totalni kravina...

10 = 1  pak najednou   10 = 0 , 10 = 0 .... o kus dal   01 = 1  pak najednou zase 10 = 1 ... naprosto nedeterministicky...

To co popisujes to je proste na stavovej automat... neda se udelat trivialnim logickym clenem jako skutecnej manchester..

totalna kravina ? Mozna ale ja to tak potrebujem :D ale ono sa to sprava jak pisem , prva dvojica bitov vzdy vrati 1 , preto ta 10 sa vyhodnoti na 1, potom zase 10 sa vyhodnoti na 0 pretoze nedoslo ku prechodu (10 je rovnake ako predtym 10).

Potom o kus dal sa 01 vyhodnoti na 1 pretoze doslo k prechodu (keby nasledovalo zase 01 tak sa vyhodnoti na 0 lebo nedoslo k prechodu) a pak najednou zase 10 sa vyhodnoti na 1 lebo doslo k prechodu ...

#32 Zajcev
zrovna sem udelal dekoder ale to co odhadujes tam ani nahodou nevyleze... jak to ze za tim prvnim parem jednotek neni zmena  01 ale  10?

vyleze cca toto:  1000001111110000

aha to je jeste daleko vetsi prasecina ... to kodovani

#include <stdio.h>

int main() {
  unsigned int manchester = 0xAAA6AA6A;
  int i, sp=1, stavB=1;
  for (int i=30; i>=0; i-=2) {
    unsigned int stav = (manchester >> i) & 3;

    if (stav==0 || stav==3) {
      printf("Error: stejne dva bity\n");
      return 1;
    }    if ( (sp==stav && stavB==1) || (sp!=stav && stavB==0) ) { // toggle
      stavB = !stavB;
    }
    sp = stav;
    printf("%d",stavB);
  }
  printf("\n");
}

po trose laborovani ...

njn Dik moc obom :)

Este taka malickost :) Keby som chcel ten retazec na vystupe premenit na cislo ktore odpoveda binarnemu ekvivalntu toho cisla akurat by som ho zobrazoval hexadecimalne , tak to asi spravit tak ze to ukladat do pola a potom previest na cislo alebo tie biti ukladat do nejakej premennej (bit po bite) a nejak im osetrit ich rád ... ?

proste budes mit na zacatku vysledek = 0;  a pak uvnitr    vysledek = (vysledek<<1) | stav;  nebo  vysledek = vysledek*2 + stav;

#34 KIIV
Ten tvoj program nevracia pre prvu dvojicu vzdy jednotku :)

#37 vitamin
prece mu to nevyresim vsechno :D

mimo to staci zmenit trosku inicializaci:

int i, sp=((manchester>>30)&3)^3 , stavB=sp>>1;

kazdopadne u me je videt ze uz jdu na nektery veci prilis slozite...

#39 KIIV
Vzdy to ide zlozitejsie : 

int main() {
	uint32_t x = 0xAAA6AA6A;
	
	enum state_e{
		StateBegin,
		State1,
		State2 
	}stav;
	
	stav = StateBegin;
	
	for (int8_t i = 30; i >= 0; i-= 2) {
		const uint8_t y = (x >> i) & 3;
		if( y == 0 ||  y == 3){
			puts("\nchyba!");
			return EXIT_FAILURE;
		}
		switch(stav){
			case StateBegin:
				putchar('1');
				if(y == 1)stav  = State1;
				if(y == 2)stav  = State2;
				break;
			case State1:
				if(y == 1)putchar('0');
				else{
					putchar('1');
					stav  = State2;
				}
				break;
			case State2:
				if(y == 2)putchar('0');
				else{
					putchar('1');
					stav  = State1;
				}
				break;
			default:
				return EXIT_FAILURE;			
		}
	}
    return EXIT_SUCCESS;


}

ok este taka otazocka , predtavme si ze mame cislo 830C -little endian a ja ho prevediem na big endian co by malo byt 0C83. Problem je ze ked to zobrazim pomocou printf tak sa mi zaciatocna 0 oreze a ja ju tam podla zadania musim mat ... Jak donutit printf aby zobrazoval vsetky nuly zlava ? Aebo jak mu mozem dat nejaku hodnotu podla coho tam tie 0 bude doplnat ?

co se podivat na moznosti printf a hlavne tech placeholderu?

krom toho nevidim moc duvod proc to resis .. pokud to neposilas po siti jinam nebo neprenasis na jiny pocitac tak to nehraje roli

Nj vyriesil som to tym placeholderom , Dik.

Este by ma zaujimalo , ze ked som tie bity ukladal do premennej podla tohto "vysledek = (vysledek<<1) | stav;"

a mam tam trebars ulozene 830C tak k dvom najvissim bitom sa dostanem tak ze to logicky vynasobim

(vysledek & 0xC0000000) >> 30 a k dvom najnizsim tak ze to vynasobim (vysledek & 0x03) ?

rad by som ich totiz porovnaval ... (Prve dva a posledne dva)

#44 Zajcev
staci ti (vysledek >> 30)  

Aha Dik. Este jedna otazocka mozna to bude zniet sialene

#include <stdio.h>

int main() {
  unsigned int manchester = 0xAAA6AA6A;
  sp=((manchester>>30)&3)^3 , stavB=sp>>1;
  for (int i=30; i>=0; i-=2) {
    unsigned int stav = (manchester >> i) & 3;

    if (stav==0 || stav==3) {
      printf("Error: stejne dva bity\n");
      return 1;
    }    if ( (sp==stav && stavB==1) || (sp!=stav && stavB==0) ) { // toggle
      stavB = !stavB;
    }
    sp = stav;
    printf("%d",stavB);
  }
  printf("\n");
}

keby som chcel aby bol prvy bit vzdy 0 tak by som musel zmenit jak ?

Napr vynulovanie prvych 2 bitov:

(cislo & (~0x3) )

psolednych 2 pri 32bit cisle:

(cislo & (~( 0x3<< 30) ) ) 

u me stacilo vynechat to  ^3

tj: sp=((manchester>>30)&3) , stavB=sp>>1;