Thread: Characters to binary... hexadecimal to binary

calling pow() for each bit! hmmmm very efficient!
Ever heard of bitwise operators?
bitwise & can be used to test bits. Read about it in your text books. check previous threads with search facility. Read about stringstreams and how they can help you. Try to write some code and we'll fix it up for you as long as you do your own donkey work.
Oh yeah btw your bit string will be backwards also.

Hello. I haven't really been following, but i think i may have an answer. When i did an encryption where i did bit switching, i made three things to help me. I can only remember exactly how i did two of them. I had a struct(?) that had eight single-bit fields, and i had a union between that and a char. The third thing was the function that sent the char to union.ch, and then did the switches on union.bitz.b1, etc. THen again, this may have been JAVA. I blend the two sometimes...

Hope this is of help.

~Inquirer

Your request seemed like an interesting challenge, so I took it a little further than I normally would

Code:

#include <cmath>
#include <iostream>

struct bitstring
{
	unsigned char bits[8];
};

bitstring get_binary(const char code)
{
	bitstring returnstring;
	memset(reinterpret_cast<void *>(&returnstring), '\0', sizeof(returnstring));

	int count = 0;
	for (int bit = 128; bit >= 1; bit >>= 1)
	{
		returnstring.bits[count] = (code & bit) ? '1' : '0';
		count++;
	}
	return returnstring;
};


char get_character(const bitstring instring)
{
	char cReturn = '\0';

	int count = 0;
	for (int bit = 128; bit >= 1; bit >>= 1)
	{
			if (instring.bits[count] == '1')
			{
				cReturn |= bit;
			}
			count++;
	}
	return cReturn;
};

int main(int argc, char* argv[])
{
	using namespace std;

	bitstring output = get_binary('1');
	char input = get_character(output);
	cout << input;

	return 0;
}

Oh, and Stoned_Coder, i've dropped the pow... as you suggested.

Eibro, could you explain how this works? Especially the part that says ...<void *>... ?

And, i had to tweak it as follows so it would display correctly.

Code:

#include <cmath>
#include <iostream>

struct bitstring
{
	unsigned char bits[9]; // I made this to leave room for '\0'
};

bitstring get_binary(const char code)
{
	bitstring returnstring;
	memset(reinterpret_cast<void *>(&returnstring), '\0', sizeof(returnstring));

	int count = 0;
	for (int bit = 128; bit >= 1; bit >>= 1)
	{
		returnstring.bits[count] = (code & bit) ? '1' : '0';
		count++;
	}
   returnstring.bits[8]='\0'; // I added this
	return returnstring;
};


char get_character(const bitstring instring)
{
	char cReturn = '\0';

	int count = 0;
	for (int bit = 128; bit >= 1; bit >>= 1)
	{
			if (instring.bits[count] == '1')
			{
				cReturn |= bit;
			}
			count++;
	}
	return cReturn;
};

void binary()
{
	using namespace std;

	bitstring output = get_binary((char)getche());
	char input = get_character(output);
	cout << "\"" << input << "\"" << endl;
   cout << output.bits << endl;
   if (getche());

	return;
}

Uhh... yeah What's the advantage of using c++-casting instead of C casting?

ummm... yes...

1) why exactly would you WANT to cast something into a void pointer?

2) About the bits[9], if you output it to the screen, it also outputs he next few variables because when you say bits[8] you are setting aside memory for bits[0] to bits[7], not bits[0] to bits[8].
the null terminator gets put in the last one later, and all 8 bits are outputted to the screen.

3) What does memset do? I haven't done much memory stuff...

4) What is the memset prototype?

5) I don't exactly see how the loop(s) work to translate them to and from the binary... I get how you are stepping down the 128...1 ladder, but how do you use that to calculate whether the bit was on or off??? ::
[EDIT]
I have figured out #5... except for the following:

Code:

returnstring.bits[count] = (code & bit) ? '1' : '0';

I can see that this would only leave the bit in question set, but i don't see how this would test true. Does null evaluate to false? That must be it...


Thanks for the example! I learned a lot!
[/EDIT]

Thanks...
~Inquirer

Anyone who knows JAVA should help on this one...

Is it java or c++ (or both) that have unions?
Is it java or c++ (or both) that have single-bit data members?
[DELETED][/DELETED]

~Inquirer

Both might have unions (I haven't touched java for a while), but I'm pretty sure only c++ has single-bit data members.

And about casting to a void pointer, that's 'cuz memset takes a void pointer (well, I'm guessing that), and some compilers won't do the typecast automatically. But I still don't see why he didn't just use (void*)...

memset(sometype *pointerToDataStructureOrVariableButProbablyDataSt ructure, char valueToSetTo, int howManyBytesToSet)

-sometype is probably either void or char - i'm guessing void, 'cuz otherwise eibros wouldn't have typecasted the thing to void.
-valueToSetTo might be int or unsigned char.
-howManyBytesToSet may be a long or something.
-valueToSetTo is usually set to 0.
-howManyBytesToSet is usually filled in with sizeof(the datastructure).
-memset is usually used to clear out a datastructure.
-another way to clear out a datastructure would be to use ZeroMemory(), which is either a macro or inline function or something that uses memset() and just fills in valueToSetTo with 0.

Well i'm stumped...
Well, I was stumped. (Those two lines were written a half hour apart)

I'm wondering why output's bits weren't retaining the value returned from the function...
Something to do with it going out of scope? Shouldn't the object be copied?

Oh well, I came up with this:

Code:

// ****msvc.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <cmath>
#include <iostream>
#include <assert.h>

class bitstring
{
public:

	bitstring();
	bitstring(const bitstring &bs);
	~bitstring();

	unsigned char *getbits();
	void setbit(int bitnum, int val);
	unsigned char getbit(int bitnum);	

	void setbitstring(const char code);
	char getcharacter();

private:
	unsigned char *bits;
};

bitstring::bitstring()
{
	bits = new unsigned char[8];
	memset(reinterpret_cast<void *>(bits), 8, sizeof(bits));
}


bitstring::~bitstring()
{
	delete[] bits;
}

bitstring::bitstring(const bitstring &bs)
{
	bits = new unsigned char[8];

	for (int i = 0; i < 8; i++)
	{
		bits[i] = bs.bits[i];
	}
	bits[8] = '\0';
}


unsigned char *bitstring::getbits()
{
	return bits;
}

void bitstring::setbit(int bitnum, int val)
{
	assert(bitnum < 8);
	bits[bitnum] = val;
}

unsigned char bitstring::getbit(int bitnum)
{
	assert(bitnum < 8);
	return bits[bitnum];
}

char bitstring::getcharacter()
{
	char cReturn = '\0';

	int count = 0;
	for (int bit = 128; bit >= 1; bit >>= 1)
	{
			if (getbit(count) == '1')
			{
				cReturn |= bit;
			}
			count++;
	}
	return cReturn;
};

void bitstring::setbitstring(const char code)
{
	int count = 0;
	for (int bit = 128; bit >= 1; bit >>= 1)
	{
		setbit(count, (code & bit) ? '1' : '0');
		count++;
	}
	bits[8] = '\0';
};

int main(int argc, char* argv[])
{
	using namespace std;

	bitstring output;
	output.setbitstring('a');

	cout << output.getbits() << endl;

	cin.get();
	return 0;
};

Looks like I went a little overboard...