[C++]binaire telmethoden*

Macros schreef op 22 november 2003 @ 13:53:
[...]
Er zijn standaard functies die 2 int's met elkaar XOR'en, bit voor bit zonder dat jij eerst iets naar bit arrays hoeft om te zetten. Deze functies hete bitwise functies, en je hebt ze voor OR, XOR en AND.
AND = &
OR = |
XOR = ^

Alleen jammer dat die 152bit getallen niet in een int passen.

zaterdag 22 november 2003 14:01

Acties:

Verwijderd

Topicstarter

neej maar ik dacht dat als ik bv het getal 10010 opsla in een int en dat ga xorren dat ie dat eerst intern omzet in een binair getal, dat xort en weer omzet in decimaal, maar dat is dus blijkbaar niet...??

zaterdag 22 november 2003 14:09

Acties:

Verwijderd

SuperRembo schreef op 22 november 2003 @ 14:01:
[...]

Alleen jammer dat die 152bit getallen niet in een int passen.

Dan gebruik je er een aantal... er gaan al snel 32 bits in een unsigned int, dus met 5 ints ben je er al...

zaterdag 22 november 2003 14:20

Acties:

Verwijderd

Verwijderd schreef op 22 november 2003 @ 14:01:
neej maar ik dacht dat als ik bv het getal 10010 opsla in een int en dat ga xorren dat ie dat eerst intern omzet in een binair getal, dat xort en weer omzet in decimaal, maar dat is dus blijkbaar niet...??

Ga je het getal 'tienduizend-en-tien' (wat in binair 10011100011010 is) opslaan, of ga je het getal 'achttien' (wat in binaire representatie 10010) is opslaan?

Voor een computer maakt het allemaal niet uit. Die rekent alleen met binaire waarden. Integers, floats, strings, alles bestaat voor de computer alleen maar uit bits, dus 1 of 0.

Om op je originele vraag terug te komen, je hebt 151 bits, en deze passen niet in een int of een __int64, dus je kan ze niet makkelijk decimaal weergeven. Jammer voor jou, moet je daar dus een functie voor schrijven die dit bit voor bit doet...

zaterdag 22 november 2003 14:23

Acties:

Verwijderd schreef op 22 november 2003 @ 14:09:
[...]
Dan gebruik je er een aantal... er gaan al snel 32 bits in een unsigned int, dus met 5 ints ben je er al...

Het xor-en is niet echt het probleem. Als ik het goed begrijp wil hij wil het resultaat op het scherm tonen als decimaal getal.

zaterdag 22 november 2003 15:03

Acties:

Soultaker

Als je een getal wil converteren naar een decimale representatie, dan ziet het standaardalgoritme er ongeveer zo uit:

C++:

deque<char> cijfers;
while(getal)
{
    int cijfer = getal % 10;
    getal /= 10;
    cijfers.push_front('0' + cijfer);
}
string str(cijfers.begin(), cijfers.end());

De 10 is hierbij de cijferbasis die je gebruikt in het decimale stelsel. Ik heb 'getal' niet gedeclareert omdat het eigenlijk niet relevant is wat het type van 'getal' is, zolang je er maar integer deling (/) en rest bij deling (%) op kunt uitvoeren. Als 'getal' een integer is werkt het algoritme al.

Het gebruik van de deque en string is een beetje willekeurig, je kunt ook direct in de lus cijfers printen of een string construeren maar je moet er rekening mee houden dat de cijfers van rechts naar links gegenereerd worden.

Wat je nu zelf moet verzinnen is hoe je de (rest)deling implementeert voor je eigen stringrepresentatie. Als tip kan ik je wel vertellen dat het net zo kan als handmatig staartdelen, alleen met een basis van 2 (aangezien je een binaire representatie hebt).

zaterdag 22 november 2003 17:17

Acties:

Verwijderd

wat ik begrijp van de topicstarter en de daaropvolgende (overigens zeer nuttige) tips van verschillende mensen is dat het XORen an sich niet het probleem is maar het weergeven van een 151 bits getal als decimaal getal.

Daarvoor is het van belang dat je het principe decimaal getal begrijpt, dan komt de rest vanzelf (hoop ik) :

decimaal getal : getal bestaande uit cijfers 0 t/m 9 waarbij iedere positie een verminigvuldiging met 10^(lengte getal - huidige positie) voorstelt.

neem het getal abcdef waarbij a t/m f cijfers uit 0 t/m 9 zijn dan is de waarde van het getal a * 10^5 + b * 10^4 + c * 10^3 etc...

Om een heel groot getal (>64 bits) op het scherm te toveren zal je dus gebruik moeten maken van delingen door 10^x. Omdat je geen normale deling kan doen (er passen geen 151 bits in een 'standaard' getal) moet je hem in meerdere stukjes hakken (vb. 5 van 32 bits) en dan met een truukje alle stukjes apart verwerken.

hint 1 : (x * y) % z = ((x % z) * (y % z)) % z
hint 2 : in een array int[5] moet je int[3] met 2^32 vermenigvuldigen om de 'echte' betekening van dit stukje getal te bepalen (net als in 99 de eerste negen met 10 vermenigvuldigd moet worden)

zaterdag 22 november 2003 17:21

Acties:

Verwijderd

Topicstarter

thnx voor je nuttige reply, ik snap wat je bedoelt, en ik kan verder gaan puzzellen $_/-\o_$

zaterdag 22 november 2003 17:46

Acties:

zaterdag 22 november 2003 23:42

C++ heeft een 152-bits type, dat is veel eenvoudiger: std::bitset<152>, met
een bijbehorende operator^

Man hopes. Genius creates. Ralph Waldo Emerson
Never worry about theory as long as the machinery does what it's supposed to do. R. A. Heinlein

Acties:

Ik heb ff wat met php zitten spelen, dit is m'n binary-string naar decimal-string converter:

PHP:

<?php

    // Binary input
    $binInput = '01110100011010000110010100100000011100000110000101110011011100110111011101101111011100100110010000100000011010010111001100100000011000100110100101101110';

    // Convert to array of binary digits
    $dig2 = Preg_Split('//', $binInput, -1, PREG_SPLIT_NO_EMPTY);

    // Init decimal digits
    // 0.31 is estimate of log(2)/log(10)
    $dig10 = Array_Pad(Array(), Ceil(Count($dig2)*0.31), 0);

    // Calculate decimal digits
    for ($i=0; $i<Count($dig2); $i++) {

        // Multiply by 2
        for ($j=0; $j<Count($dig10); $j++) {
            $dig10[$j] *= 2;
        }

        // Add binary digit
        $dig10[0] += $dig2[$i];

        // Carry
        for ($j=0; $j<Count($dig10)-1; $j++) {
            if ($dig10[$j]>=10) {
                $dig10[$j] -= 10;
                $dig10[$j+1]++;
            }
        }

    }

    // Trim leading zeros
    for ($i=Count($dig10)-1; $i>0; $i--) {
        if ($dig10[$i]==0) {
            UnSet($dig10[$i]);
        } else {
            break;
        }
    }

    // Convert to string
    $decOutput = join('',Array_Reverse($dig10));

    echo "$binInput<br>";
    echo "$decOutput<br>";

?>

zondag 23 november 2003 17:02

Acties:

Verwijderd

Topicstarter

Ik ben effe wat gaan kloten met std::bitset<152> maar dat veroorzaakt weer een ander probleem waar ik niet meer uitkom

Namelijk het volgende, ik declareerd de varaiable als volgt

C++:

using namespace std;

     bitset<152> decimaal;
     bitset<152> sum;

Daarna voer ik de volgende bewerking uit

C++:

1 2	sum = sum + decimaal; //of sum += decimaal maar geen van beide werkt

Ik krijg dan de volgende error van Dev-C++

30 D:\My Documents\C++\XOR.cpp
no match for `std::bitset<152>& +

Ik heb me sufgezocht op msdn maar kan niets vinden

zondag 23 november 2003 17:17

Acties:

MSDN bitset
Bitsets kennen de + operator niet. Oftewel, bitsets kan je niet optellen.

zondag 23 november 2003 17:25

Acties:

Verwijderd

Topicstarter

ow sorry, ik had het kunnen weten $_/-\o_$ ok, ik ga weer verder puzzellen

zondag 23 november 2003 18:18

Acties:

curry684

left part of the evil twins

Verwijderd schreef op 22 november 2003 @ 13:31:
als ik het opsla in een int, dan wordt het opgeslagen als een decimaal getal, ik ben op zoek gegaan naar manieren om het binair op te slaan in een int, maar dat wou niet echt en op een irc channel waar ik altijd zit (hoog niveau) zeiden ze dat het onmogelijk was. Ik weet wel dat je hex met 0x moet prefixxen en octaal met een 0 maar binair.....

Nofi, maar of ze hebben je in de maling genomen of dat IRC channel is van triest laag niveau...

Ik heb zojuist je posts doorgelezen, en je mist niet alleen de basisbeginselen van C/C++ maar eigenlijk van computers en programmeren in het algemeen als je denkt dat de computer bij getalopslag verschil maakt tussen decimaal en binair. Wel eens overwogen om een goed beginnersboek te kopen?

Professionele website nodig?

maandag 24 november 2003 14:53

Acties:

Verwijderd

Topicstarter

kennelijk kom ik niet goed over, ik heb even 2 voorbeelden met wat ik bedoel met een binair getal in een int opslaan.

hier doe ik het op de "foute" manier:

C++:

#include <iostream>
#include <stdlib.h>

using namespace std;



int main(void)
{
    unsigned int edata = 11111;
    unsigned int key  = 10101;
    unsigned int data;

    data = edata ^key;
    cout<<data<<endl;
    system("pause");
}

en hier met dezelfde getallen opgeslagen in een array, wat wel naar behoren werkt

C++:

#include <iostream>
#include <stdlib.h>

using namespace std;

int macht(int);

int main(void)
{
    unsigned int edata[5] = {1,1,1,1,1};
    unsigned int key[5]  = {1,0,1,0,1};
    unsigned int data[5];
    
    for(int i=0;i<5;i++)
    {
        if(edata[i]==key[i])
        data[i]=0;
        else        
        data[i]=1;
        cout<<data[i];
    }
    
    int decimaal=0, sum=0;
    for(int i=4; i>=0; i--)
    {
       decimaal=data[i]*(macht(i));
       sum = sum + decimaal;
    }
    cout<<endl<<sum<<endl;
    system("pause");
}

int macht(int i)
{
    int result=1;
    i = 4 - i;
    for(int j=0;j<i;j++)
    {
        result = result * 2;
    }
    
    return result;
}

Nogmaals wat ik bedoel met een binair getal in ene int opslaan is dat je compiler het als binair ziet, en niet als decimaal. Als je bv declareert int a = 0x16; en int b = 16 dan is a niet gelijk aan b, omdat hij a als hex behandelt en zo rekent, en b als decimaal beschouwt en daarmee rekent. K hoop dat ik nu wel duidelijk ben.

maandag 24 november 2003 15:14

Acties:

curry684

left part of the evil twins

Aha, je zoekt dus gewoon de prefix om een binaire constante aan te geven, net zoals de prefix 0x een hexadecimale constante aangeeft en 0 een octale constante. Nou, dan zijn we snel klaar: die is er niet

Je kunt echter gewoon hex of octaal gebruiken, kwestie van je bitjes per 4 samenvoegen tot 1 hex-digit of per 3 tot 1 oct-digit.

Oftewel 11011 = 0001 1011 = 0x1b hex = 11 011 = 033 octaal

Tabelletje om even uit je kop te leren:

0000	0
0001	1
0010	2
0011	3
0100	4
0101	5
0110	6
0111	7
1000	8
1001	9
1010	A
1011	B
1100	C
1101	D
1110	E
1111	F

Professionele website nodig?

maandag 24 november 2003 15:45

Acties:

Verwijderd

Topicstarter

curry684 schreef op 24 november 2003 @ 15:14:
Aha, je zoekt dus gewoon de prefix om een binaire constante aan te geven, net zoals de prefix 0x een hexadecimale constante aangeeft en 0 een octale constante. Nou, dan zijn we snel klaar: die is er niet

En dat is wat ze op de channel zeiden

irc.enterthegame.com/gametutorials

maandag 24 november 2003 17:45

Acties:

maandag 24 november 2003 18:15

Moderator Devschuur®

Demotivational Speaker

C++:

template <unsigned long long L> struct binary
{
    enum { value = (L & 1) + (binary<L >> 3>::value << 1) };
};

template <> struct binary<0>
{
    enum { value = 0 };
};

#define BIN(x)    (binary<0 ## x ## ULL>::value)

int main ()
{
    int i = BIN (110010101001);
}

nadeel: je kunt maar 21 bits kwijt
(de maximale waarde is 2⁶⁴-1, en dat zijn floor (⁸log (2⁶⁴ - 1)) = 21 digits)

Je zou het evt. nog kunnen opdelen in groepjes van 16:

C++:

#define BIN2(x,y)    ((BIN (x) << 16) | BIN (y))

int main ()
{
    std::cout << BIN2 (10010100101,0010110010001101) << std::endl
}

[ Voor 11% gewijzigd door .oisyn op 24-11-2003 18:34 ]

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties:

GrimaceODespair

eens een tettenman, altijd ...

$_/-\o_$ oisyn. Da's lichtelijk geniaal en iets waar ik al lang naar op zoek was! Heb wel ooit een poging in die richting gedaan, maar ergens in de templates gestrand.

Wij onderbreken deze thread voor reclame:
http://kalders.be

maandag 24 november 2003 18:44

Acties:

maandag 24 november 2003 18:46

Moet dat geen L / 10 ipv L>>3 zijn, nu lijkt het me zo octaal? Met decimaal kom je toch iets verder.
- oeps, je wilt juist niet verder komen; er zitten meer octale cijfers dan decimale cijfers in 1<<64 -

[ Voor 57% gewijzigd door MSalters op 24-11-2003 18:49 . Reden: oeps ]

Man hopes. Genius creates. Ralph Waldo Emerson
Never worry about theory as long as the machinery does what it's supposed to do. R. A. Heinlein

Acties:

maandag 24 november 2003 18:57

Ik blijf overigens zeggen, gebruik bitset<152> dan kun je gewoon zeggen
bitset<152> edata = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001";

Man hopes. Genius creates. Ralph Waldo Emerson
Never worry about theory as long as the machinery does what it's supposed to do. R. A. Heinlein

Acties:

maandag 24 november 2003 18:58

Moderator Devschuur®

Demotivational Speaker

MSalters schreef op 24 november 2003 @ 18:44:
Moet dat geen L / 10 ipv L>>3 zijn, nu lijkt het me zo octaal? Met decimaal kom je toch iets verder.
- oeps, je wilt juist niet verder komen; er zitten meer octale cijfers dan decimale cijfers in 1<<64 -

precies, en bovendien krijg je een probleem met decimaal als iemand er een 0 voor zet

MSalters schreef op 24 november 2003 @ 18:46:
Ik blijf overigens zeggen, gebruik bitset<152> dan kun je gewoon zeggen
bitset<152> edata = "1001100110011...knip...011001";

Maar dat is dan weer geen compile-time constant. Het is natuurlijk idd wel een stuk flexibeler, en je zit niet aan de int-range vast

[ Voor 47% gewijzigd door .oisyn op 24-11-2003 18:59 ]

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties:

maandag 24 november 2003 23:58

Verwijderd schreef op 24 november 2003 @ 14:53:
C++:
1
2
3
4
5
6
7
8
9
10
11
int macht(int i)
{
    int result=1;
    i = 4 - i;
    for(int j=0;j<i;j++)
    {
        result = result * 2;
    }
    
    return result;
}
Dit kan heel veel sneller, en ook korter:
C:
1
return 1 << (4-i).
Tip: Als je je bits vanaf de andere kant nummert hoef je die magische constante 4 ook niet te gebruiken. Dwz de bit met waarde 1 is bit 0, de bit met waarde 1024 is bit 10, etcetera.

Man hopes. Genius creates. Ralph Waldo Emerson
Never worry about theory as long as the machinery does what it's supposed to do. R. A. Heinlein

Acties:

dinsdag 25 november 2003 00:09

MSalters schreef op 24 november 2003 @ 18:46:
Ik blijf overigens zeggen, gebruik bitset<152> dan kun je gewoon zeggen
bitset<152> edata = "100110011001100110011......0110011001100110011001100110011001";

Alleen dan zonder de quotes ?

[ Voor 25% gewijzigd door farlane op 24-11-2003 23:58 ]

Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.

Acties:

curry684

left part of the evil twins

farlane schreef op 24 november 2003 @ 23:58:
[...]
Alleen dan zonder de quotes ?

Uhm nee hoor, string initialization is gewoon een explicit constructor voor:

C++:

template<class Char, class Traits, class Alloc>
explicit
bitset(const basic_string<Char,Traits,Alloc>& s,
       size_t pos = 0,
       size_t n = 
         basic_string<Char,Traits,Alloc>::npos)

Professionele website nodig?

dinsdag 25 november 2003 08:46

Acties:

dinsdag 25 november 2003 13:51

curry684 schreef op 25 november 2003 @ 00:09:
[...]

Uhm nee hoor, string initialization is gewoon een explicit constructor voor:

C++:

template<class Char, class Traits, class Alloc>
explicit
bitset(const basic_string<Char,Traits,Alloc>& s,
       size_t pos = 0,
       size_t n = 
         basic_string<Char,Traits,Alloc>::npos)

Idd, maar bij mij compiled ie niet als je een const char* als argument meegeeft.

[edit]
Wel vreemd want volgens mij is de string( const char * ) constructor niet explicit.

[ Voor 12% gewijzigd door farlane op 25-11-2003 09:08 ]

Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.

Acties:

woensdag 26 november 2003 01:32

Moderator Devschuur®

Demotivational Speaker

Klopt, het is een template constructor. Hij kan dus onmogelijk van een const char [] een basic_string<Char, Traits, Alloc> maken, omdat dat alles kan zijn. Als hij gewoon de standaard std::string had verwacht, dan ziet de compiler dat std::string een constructor heeft voor const char *, en dan werkt het wel.

Wat ik echter wel vreemd vind is dit:

C++:

#include <bitset>

std::bitset<10> a = std::string ("100101");   // werkt niet
std::bitset<10> b (std::string ("100101"));   // werkt wel

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties:

woensdag 26 november 2003 20:09

Eh ja, de vorm T a = eenT; en T a(eenT); zijn wel gelijk, maar T b = converteertNaarT; en T b (converteertNaarT); zijn verschillend. T b = converteertNaarT; is namelijk gelijk aan
T b ( T(converteertNaarT ) ); . Er zit dus een extra ctor in (in theorie, voordat optimalisatie gebeurt). Hier maakt dat uit omdat een van de ctors explicit is.

Man hopes. Genius creates. Ralph Waldo Emerson
Never worry about theory as long as the machinery does what it's supposed to do. R. A. Heinlein

Acties:

Verwijderd

@dr hendre

ik vraag mij toch wel een beetje af waar jij je input-data vandaan haalt... Een 152 bits getal, dat zou dus 2^152 = 5.71 * 10^45 zijn... ben benieuwd wat dat moet voorstellen en wat je er mee doet dan

woensdag 26 november 2003 22:41

Acties:

Verwijderd

Topicstarter

Verwijderd schreef op 26 november 2003 @ 20:09:
@dr hendre

ik vraag mij toch wel een beetje af waar jij je input-data vandaan haalt... Een 152 bits getal, dat zou dus 2^152 = 5.71 * 10^45 zijn... ben benieuwd wat dat moet voorstellen en wat je er mee doet dan

ach jah, je doet soms rare dingen, maar het gaat dus hierom:

http://www.net-force.nl/challenge/level305/index.php

het gaat me eik niet om het antwoord, maar ik doe het gewoon om wat meer inzicht te krijgen in dat soort zaken

Je moet toch wat doen als je je verveelt midden in de n8

woensdag 26 november 2003 23:34

Acties:

RobIII

Admin Devschuur®

^ Romeinse Ⅲ ja!

Verwijderd schreef op 26 november 2003 @ 22:41:
[...]

ach jah, je doet soms rare dingen, maar het gaat dus hierom:

http://www.net-force.nl/challenge/level305/index.php

het gaat me eik niet om het antwoord, maar ik doe het gewoon om wat meer inzicht te krijgen in dat soort zaken Je moet toch wat doen als je je verveelt midden in de n8

Uhm...dat lijkt me (op het eerste gezicht) gewoon een "string". Dus in stukjes van 8 bits kappen, omrekenen naar dec of hex en de ASCII tabel erbij

edit:
Hmmm.... niks gezegd

[ Voor 12% gewijzigd door RobIII op 26-11-2003 23:42 ]

There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.

Je eigen tweaker.me redirect

Over mij

woensdag 26 november 2003 23:57

Acties:

RobIII

Admin Devschuur®

^ Romeinse Ⅲ ja!

RobIII schreef op 26 november 2003 @ 23:34:
[...]

LOL

Ik had toch gelijk

Je moet de bovenste "string" (welke resulteert in de decimale waarden _{147,41,148,134,165,21,167,85,86,149,99,205,58,210,173,40,174,215,90,0}) samen met de onderste string (waarden _{231,65,241,166,213,116,212,38,33,250,17,169,26,187,222,8,204,190,52,0}) met elkaar XOR-en en daar de ascii waarde van pakken...TADAAA!

De oplossing heb ik hier dan ook voor je...
Spoiler:

the password is bin

edit:

Edit <-> Quote <-> Edit....Ik doe het altijd verkeerd..

/edit2/
En voor de geïnteresseerden hier de (let op!) quick'n'dirty VB6 code waarmee ik dit raadsel heb opgelost

Visual Basic 6:

Option Explicit

Private Sub Form_Load()
    Const sBytes1 = "1001001100101001100101001000011010100101" & _
                    "0001010110100111010101010101011010010101" & _
                    "0110001111001101001110101101001010101101" & _
                    "00101000101011101101011101011010"
    Const sBytes2 = "1110011101000001111100011010011011010101" & _
                    "0111010011010100001001100010000111111010" & _
                    "0001000110101001000110101011101111011110" & _
                    "00001000110011001011111000110100"

    Dim T As Integer
    
    For T = 0 To 19
        Debug.Print Chr(Bin2Dec(Mid(sBytes1, (T * 8) + 1, 8)) Xor _
            Bin2Dec(Mid(sBytes2, (T * 8) + 1, 8)));
    Next T
End Sub

Private Function Bin2Dec(sByte As String) As Byte
    Dim T As Integer
    Dim U As Byte
    
    U = 0
    For T = 1 To 8
        U = U + IIf(Mid(sByte, T, 1) = "1", 2 ^ (8 - T), 0)
    Next T
    Bin2Dec = U
End Function

...Nog makkelijker was geweest:

Visual Basic 6:

Option Explicit

Private Sub Form_Load()
    Dim T As Integer
    
    Const sBytes1 = "<<hier de eerste helft van de string uit vorige post>>"
    Const sBytes2 = "<<hier de tweede helft van de string uit vorige post>>"
    
    For T = 1 To 19
        Debug.Print Chr(Asc(Mid(sBytes1, T, 1)) Xor Asc(Mid(sBytes2, T, 1)));
    Next T
End Sub

(de code tags vernueken de string uit mijn vorige post...

)
_{er moet dus staan:

Const sBytes1 = "“)”†¥§UV•cÍ:Ò(®×Z"

Const sBytes2 = "çAñ¦ÕtÔ&!ú©»ÞÌ¾4"}

We hadden immers de string al omgerekend naar ASCII-tekens. In dit voorbeeld XOR je dus gewoon de 2 helften... Sim-pel...

[ Voor 155% gewijzigd door RobIII op 27-11-2003 00:14 ]

There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.

Je eigen tweaker.me redirect

Over mij

donderdag 27 november 2003 01:04

Acties:

donderdag 27 november 2003 02:07

Voor de grap ff wat C++ code.

C++:

#include <bitset>
#include <string>

using std::bitset;
using std::string;

char mk_char( const std::string& s )
{
    /* Figure it out yourself :) */
}

int main ()
{
    bitset<152> blaat1( std::string("100....1010" ) ) ;
    bitset<152> blaat2( std::string("111.....0100" ) );

    blaat1 ^= blaat2;

    char res[ 152 / 8 + 1 ] = { 0 };

    std::string result = blaat1.to_string<char,char_traits<char>, allocator<char> >( );

    for( int k = 0,l = 0; k < result.length(); k+=8, ++l )
    {
        res[ l ] = mk_char( result.substr( k, 8 ) );
    }

    std::cin.get();
    return 0;
}

Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.

Acties:

donderdag 27 november 2003 10:03

Moderator Devschuur®

Demotivational Speaker

[nohtml]farlane: die mk_char functie is natuurlijk een beetje overdreven, aangezien je het meteen kunt converteren door gebruik te maken van een bitset<8> en z'n memberfunctie to_ulong ()

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties:

donderdag 27 november 2003 15:41

.oisyn schreef op 27 november 2003 @ 02:07:
[nohtml]farlane: die mk_char functie is natuurlijk een beetje overdreven, aangezien je het meteen kunt converteren door gebruik te maken van een bitset<8> en z'n memberfunctie to_ulong ()

Die memberfunctie zag ik later ook

, moet eerlijk zeggen dat ik niet zo vaak werk met bitset.

Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.

Acties:

donderdag 27 november 2003 21:45

Moderator Devschuur®

Demotivational Speaker

Oh ik ook niet hoor, ik vind 'm wat minder nuttig eerlijk gezegd, er missen een aantal dingen. Ik zou bitstrings graag willen benaderen als echte bitstrings, een string van bits dus. Dat je bijvoorbeeld een range van bits kunt opvragen, zoals bij string::substr. Of dat je het kunt gebruiken als stream, zoals bij stringstream. Vooral dat laatste is erg handig voor compressie-algoritmen e.d., waar je vaak niet met losse bytes werkt, maar met groepjes van bits waarvan de grootte niet vast staat. Denk bijvoorbeeld aan huffman coding.

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

Acties: