[c++] dvojisko

Lp

int des;
cin >> des;

for (int i = des; i > 0; i /= 2)
cout << i % 2;

cout << endl;

Program pretvori iz desetiškega dvojiško. Samo ven mi vrže številke od zadaj. Kako jih naj obrnem? Vržem vse v polje in berem od zadaj naprej?

Hvala

tako kot je gundolf rekel, to boš najlažje naredil z rekurzijo. Lahko pa seveda udejaniš svojo idejo in ostanke shraniš v tabelo, to pa izpišeš od odzadaj... A če rekurzijo že znaš, je to veliko enostavnejša rešitev.


--------resitev------

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

void rekurzija (int i)
{
     if (i>0) rekurzija(i/2);
     printf("%d", i%2);
}

int main(int argc, char *argv[])
{
  int stevilo;
  printf("Stevilo: ");
  scanf("%d", &stevilo);
  rekurzija(stevilo);
  printf("\n");
  system("PAUSE");	
  return 0;
}

Lp

Tako še ne obvladam. Zakaj mi to ne dela? Imam polje z vsemi ničlami, ki bi jih rad nadomestil od zadaj z dvojiškim številom. Ostale bi ostale ničle (8-bit zapis).

#include <iostream>
using namespace std;

int main() {
    int des, dv;
    char polje[] = {'0', '0', '0', '0', '0', '0', '0', '0', '\0'};
    cin >> des;
    
    for (int i = des; i > 0; i /= 2) {
            dv = i % 2;
               for (int j = 8; j > 0; j--) {
                   dv = polje[j];
               }
    }
    
    for (int i = 0; i < 9; i++) {
        cout << polje[i];
    }   

    system("pause");
    return 0;    
}

Hvala

Snow tvoj način je super, samo v celoti ne štekam tega:

kaj pomeni znak << med enko in 7-i?

 (1 << (7-i))) ? 1 : 0) ;

Spremenil sem v dolzino 8, ker tako zahteva naloga.

Bit shift. Gre za premikanje (vseh) bitov v spremenljivki. V tem primeru v levo. V našem primeru nas zanima bit po bit, zato bomo uporabili en bit, ki ga premaknemo za ustrezno število mest.

1<<0 = 1 (binarno: 00000001)
1<<1 = 2 (binarno: 00000010)
1<<2 = 4 (binarno: 00000100)
.
.
.
1<<7 = 128  (binarno: 10000000)

Ko imamo ustrezno naštiman bit, pa izvedemo binarni and. Ta nam vrne vrednost 1 le če sta oba bita 1. Ker ima naš operand le en postavljen bit, tako testiramo ali je v vpisani cifri določen bit postavljen.


Zadnje čase se dosti ukvarjam s programiranjem mikrokontrolerjev (microchip PIC), kjer je takšno znanje manipulacije bitov s C/C++ zelo potrebno.

Naredil bi še obratno.. ne vem če je v redu.

    for (int j = 2; j < 8; j++) {
     for (int i = 1; i < 8; i *= 2) {
         vsota += (polje[j] * i);
     }
    }
    
    cout  << 1 + vsota << endl;

Vneseš osembitni zapis. Moral bi narediti da z dva množi, ko pride do prve enke. Prekomplicirano. Ne vem zakaj mi noben drug način ne pade na pamet.
Snow da pretvorba iz desetiškega v dvojiški je Boolova metoda (bitni in)?

Dvojna zanka nikakor ne sodi v pretvarjanje številskih sistemov. Ampak se mi zdi da tadrugo zanko notri tlačiš le zato, ker ne veš, da bi lahko obe tvoji 'zančni' spremenljivki spreminjal znotraj iste zanke:
for (int j = 1, i=2; j < 8; j++, i *= 2)
Pa tudi tako ni nujno, saj ti ni treba znotraj for stavka vseh spremenljivk definirat, preverjat in spreminjat.

unsigned int a=0; //vsi biti na 0
unsigned int i=0;

a = a | 1<<i; //prize i-ti bit (biti gredo od 0 do 7).
a|= 1<<i; //isto kot zgoraj, samo krajsi zapis

Se pravi pogledaš če v polje[i] 1, in če je postaviš i-ti bit. Za i od 0 do 7. Vrstni red pri tem seveda ni pomemben.

Tutankhamun:
probaj

int a = 0;
a = a++ + a++ + a++;
printf("%d",a);

in se čudi rezultatu izpisanega a.

Ok - slab primer

int a = 0;
int b = 0;

b = a++ + a++ + a++;
printf("%d %d",a, b);

boljse?

Ali pa tak..

 i = *(buff + p) << 24 | *(buff + (p++) +1) << 16 | *(buff + (p++) + 2) << 8 | *(buff + (p++) + 3); 

Celotna pretvorba.

#include <iostream>
using namespace std;

int main() {
    int bin[8];
    unsigned int a = 0;
    
    for(int i = 0; i < 8; i++) {
          cin >> bin[i];
          
          if (bin[i] == 1) {
          a |= 1 << (7-i);
    }
    }
    
    cout << a;
    
    system("pause");
    return 0;
}

No, pa že nekaj več vemo..

Dvojiški komplement? Mislim, da je to pretvorba iz pozitivnega v negativno število ali obratno.

Invertiraš vse bite, in prišteješ 1.

Kako invertiraš bit(e)? Uporabiš ekskluzivni ali (XOR) na bitu, ki ga želiš invertirati.

Če želiš invertirati spodnjih osem bitov narediš takole:

 var ^= 0xff; // 11111111 v dvojiškem, 255 v desetiškem

Pomeni, da prevajalnik ne najde funkcije ki jo kličeš.

Dvojiški komplement drugače:

0000 0010 = 2 (10-desetiško)
1111 1101 = negiran 0000 0010
1111 1110 = 1111 1101 + 1 = -2 (10)

1111 1110 = -2 (10)
0000 0001 = negiran 1111 1110
0000 0010 = 0000 0001 + 1 = 2 (10)

Negiraš oz. invertiraš v C/C++ drugače lahko tudi z operatorjem ~ ampak v tem primeru se negirajo vsi biti.

int main() {
	int vred[] = {0, 0, 0, 0, 1, 1, 1, 1}; // 15
	int i;
	
/*	// negiranje
	for (i = 0; i < 8; i++) {
		vred[i] = !vred[i];
//	 oz. bolj razumljivo:
//		if(vred[i] == 1)
//			vred[i] = 0;
//		else
//			vred[i] = 1;
	}
	
	// sestevanje
	int vred2[] = {0, 0, 0, 0, 0, 0, 0, 1};
	int prenos = 0;
	for (i = 7; i >= 0; i--) {
		int temp = vred[i] + vred2[i] + prenos;
		vred[i] = !!(temp % 2);
		prenos = !!(temp > 1);
//		 oz. bolj razumljivo: 
//		if (temp % 2 == 1)
//			vred[i] = 1;
//		else
//			vred[i] = 0;
//		if (temp > 1)
//			prenos = 1;
//		else
//			prenos = 0;

	}
	*/
	// alternativa: direktno pozitivno v negativno (dvojiski komplement) oz. kombinirano negiranje in sestevanje 1
        // ideja: prenos das na 1 namesto 0 na zacetku in lahko popolnoma pozabis na vred2[] = {0, 0, 0, 0, 0, 0, 0, 1};
	int prenos = 1;
	for (i = 7; i >= 0; i--) {
		int temp = !vred[i] + prenos;
		vred[i] = !!(temp % 2);
		prenos = !!(temp > 1);
	}
	
	// 8 mestni ("8 bitni") array 1 in 0 v predznacen integer
	unsigned char temp = 0;
	int integerVrednost;
	for (i = 0; i < 8; i++) {
		temp |= vred[i] << 7-i;
	}
	integerVrednost = (int)(char) temp;
	
	cout<<integerVrednost<<endl;
	return 0;
}

Upam, da ti bo pomagalo.

Po moje si zadel owca. Čeprav se mi zdi, da tako kot je napisano ni nič bolj prav, kot bi pa bilo brez negacije. Se pravi, da je notri zaradi neutemeljenega strahu pred dejstvom, da se vsak int lahko implicitno pretvori v bool.

vred[i] = !!(temp % 2);
Zgoraj pretvoriš int z dvojno negacijo v bool iste vrednosti in ga zapišeš v int, namesto da bi int zapisal direktno v int. Malo čudno.
prenos = !!(temp > 1);
Tule pa pretvoriš bool (ki je itak lahko le 1 ali 0) preko dvojne negacije v bool z isto vrednostjo (se pravi ne narediš nič) in ga nato zapišeš v int. Tule je pomoje strah, da bo (temp > 1) vrnilo true kot nek int != 1. Ampak po tej logiki bi moral obstajat tudi strah, da bo negacija vrnila true kot nek int != 1.

Če bi hotel neko ultra varnost tudi pred najbolj neumnimi prevajalniki, bi jaz napisal takole:
vred[i] = temp % 2; // same int operacije, nimaš kej zgrešit.
prenos = (temp > 1 ? 1: 0); // pameten prevajalnik bo itak poenostavil tole v operacije brez skokov - nobene kazni v hitrosti torej.

A sem zadel Quikee?

Edit:
Okay, kaj delam? Prvi stavek je valda tudi takole:
vred[i] = temp & 1;

Sem pa še pomislil, da je tole čudno, ko je temp negativen, kar pa sicer v danem primeru nikoli ne more bit, ampak takrat pa lahko dvojna negacija kaj pametnega naredi. Čeprav bi rekel, da več škode takeli hacki naredijo kot pa koristi,

> int temp = (vred[i] ^ 0x01) + prenos;
Kaj pa:
int temp = 1 - vred[i] + prenos;

Vsaj kadar želiš pretvarjati 1 v 0 in obratno je to eden izmed bolj očitnih načinov. Čeprav za moje pojme je tudi xor v redu.

Ampak nazadnje bomo ugotovil (kot da zdaj še nismo), da je najlaže najprej iz tabelce v int fliknt vse potem naredit želeno operacijo na intu in pretvorit nazaj v tabelco. Samo zakaj imam občutek, da bi prfoxi to smatrali za goljufanje? :)