opa6x57

Yes. Open your windows calculator - and switch to 'scientific view'. Then, there are 4 radio buttons in the upper left portion of the calculator's keyboard. You can quickly see how some of these numbers work if you type in a number (say 8), then click the 'bin' radio button - the calculator will convert the 8 into it's binary equivalent - 1000.

This calculator also has some of the logical operators you're trying to understand ... there's an 'AND' and an 'OR' you can play with these in either BINARY mode or in DECIMAL mode. In fact, you can switch between the modes - as you go through some of the steps.

In Decimal, for example ...

The binary equivalent of this would be:


This is really determined by the datatype of the variable used. (I'm most familar with the BASIC forms of this ... so, I should probably let some of the C programmers answer your question about this in C.)

In most forms of BASIC - you would tell by how you dimension the variable.
If I wanted to use the ASCII codes (the '65' in your example) then I'd have to dimension the variable as a byte or integer. If, I wanted to use the variable to hold the letter "A", then I'd have to dimension the variable as a string of some kind.


Yes.
Think about your favorite book. Now, imagine someone gave you a copy of that book which had been translated into Russian. You'd have a very difficult time reading your favorite book - since it's written in a language you don't understand.

Learning a new programming language is probably not as bad as Russian - but, it could be...

(I apologize for posting my example code in VB syntax - I used what I'm most familar with... eeeek.)

__________________
Ken -
New to PFO ... but been dabbling in various versions of BASIC since highschool - circa 1973.

"Shouldn't the 'Air and Space' museum be empty?" - Dennis Miller

lectricpharaoh

I glanced at that link, and it seems correct. However, there's something I'd like to add. C does not have support for expressing numbers (in your source) as binary. You can pick decimal (the default), octal (base 8), and hexadecimal (base 16). Hexadecimal is particularly useful.

First, if you have a four-digit binary number, it can store 2 to the power of 4 (generally written as 2^4 on forums and such, when we can't actually use a superscript for the exponent). This means it can store 16 different values. A hexadecimal digit, by its very nature, can also store one of 16 different values; we can thus represent four binary digits with one hex digit.

I mean, what's easier to type, of these two numbers?Hexadecimal numbers are also preferable to decimal in some cases, especially when expressing powers of two. For example, here is a series of numbers, with each being double the preceding number:Note how they are all four digit numbers. I can represent any number from 0 to 65535 (or -32768 to -32767, if it's signed) with four hexadecimal digits, not counting the 0x prefix; this is less than the number of decimal digits I'd need. Things also line up nicer if I'm declaring constants in hexadecimal:Contrast this with the same code using decimal:Granted, the difference doesn't seem like a lot here, but this is for only eight bits. If you've got a 32-bit value, and each bit is used for a flag, you get code like:instead of:You tell me which is easier to read.
In C, you will express these numbers with the prefix '0x' (that's a zero, not an uppercase 'o'). This is because hexadecimal numbers can have letters in them; the letters A through F are used to represent the values 10 through 15 in a single digit (since decimal doesn't have enough symbols, we needed to adopt some from the alphabet). If you didn't use the prefix, and had a number such as FE75, the compiler would consider this a variable name (since it doesn't start with a number). Make it 0xFE75, and the compiler knows it's a hex number.

For quick reference, just as the digits for decimal go 0, 1, 2, 3, 4, 5, 6, 7, 8, and finally 9, hexadecimal digits go 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, and finally F. Note that although I write them in uppercase, most times it doesn't matter (C compilers don't care). I just find it clearer when the letters are uppercase.
All values stored by your computer are binary numbers; as such, they are a series of one or more bits. A byte is defined as the smallest unit you can directly address (ie, you cannot directly read or write a single bit); on almost all modern systems, a byte is synonymous with an eight-bit value. Don't make the mistake of thinking a byte is always eight bits, though; if you want to be clear, either say 'eight-bit byte', or use the term 'octet' (meaning an eight-bit value).

Now, as for the computer knowing how to interpret a value? Well, that depends what you declared it as, and what functions you use. You will also note that some of the C standard functions that you might think would return a single char actually return an int instead; this is because an int can represent values that a char typically cannot, and these values can be used to signal an error condition. For example, assume that a valid character will be in the range of 0 to 255, and an error is signaled by 0xFFFF (65535 or -1, depending on whether the value is signed or not). Either way, the error return value is outside the range of valid non-error values.

Short answer: they're all numbers to the computer; their significance depends on how you use them.
Yup. It's also a lot harder, in many cases, to read code written by someone else than to write your own. When you're writing your own, all you have to do is figure out how to express a problem to the compiler. When you're reading someone else's code, you not only have to figure out what they are doing, but why they are doing it; this is what makes it difficult. It's also why short and sweet examples that illustrate a language feature without unnecessary extras are valuable (I think many examples on MSDN fall short of this simplicity requirement). However, as you begin to make sense of code written by others, your skills will become that much stronger.

__________________
A man's knowledge is like an expanding sphere, the surface corresponding to the boundary between the known and the unknown. As the sphere grows, so does its surface; the more a man learns, the more he realizes how much he does not know. Hence, the most ignorant man thinks he knows it all. - L. Sprague de Camp

misho

As a few more examples:

There are programs which use something called bitmasks to store certain boolean settings. A boolean uses 1 byte (8 bits) of space of which only 1 bit is really needed (well, in C89 there isn't even a boolean). It's fairly obvious that wasting 7/8 of the space you are using is generally a bad thing (although, on modern computers, it's really not a big deal). What you can do is use a byte (char) to store 8 boolean values. So, let's say that you have the following byte and you want 0 to signify false:


Let's say the boolean value you're interested in is in the 3rd least significant bit (01001 1 10), then you could access its value like so:


And to set the value of a specific bit (the 3rd least significant), you would go:


Another interesting example is a sorting algorithm called radix sort. This one is cool because typical sorting algorithms are or (in case you don't know this notation, it tells you how you can expect your algorithm to perform. in the case, if you double the number of values you're sorting, the algorithm would take about 4 times longer because of the squared relationship). In general, you want the power of n to be as small as possible. Well, if you know something about the numbers you're sorting, you can do better than . With radix sort, we can do it in O(n) time (i.e. double the number of values to be sorted, the time to sort them doubles). Without getting too involved in this, if you know you have numbers between 0 and 999, you can sort numbers by the number in their units place first, then by the number in their tens place, then by the number in their hundreds place, and then they get sorted. In binary (radix is 2), you can do the same thing. So if you know you're sorting ints, then you can sort by each bit, and to get the value of each bit, you would use the method shown above. The only thing is that the negatives would come after the positives if you aren't careful (that's because of something called 2's complement).