Question: I'm trying to figure out how it is that two variable types that have the same byte size?

If i have a variable, that is one byte in size.. how is it that the computer is able to tell that it is a character instead of a Boolean type variable? Or even a character or half of a short integer?

Answer: 
The computer is not able to do that. The compiler is. You use the char or bool keyword to declare a variable and the compiler produces code that makes the computer treat the memory occupied by that variable in a way that makes sense for that particular type.

A 32-bit integer for example, takes up 4 bytes in memory. To increment it, the CPU has an instruction that says "increment a 32-bit integer at this address". That's what the compiler produces and the CPU blindly executes it. It doesn't care if the address is correct or what binary data is located there.

The size of the instruction for incrementing the variable is another matter. It may very well be another 4 or so bytes, but instructions (code) are stored separately from data. There may be many instructions generated for a program that deal with the same location in memory. It is not possible to formally specify the size of the instructions beforehand because of optimizations that may change the number of instructions used for a given operation. The only way to tell is to compile your program and look at the generated assembly code (the instructions).

Also, take a look at unions in C. They let you use the same memory location for different data types. The compiler lets you do that and produces code for it but you have to know what you're doing.
The computer only sees 1 and 0. You are in command of what the variable contains. 

you can cast that data also into what ever you want. 

```
char foo = 'a'; 
if ( (bool)(foo)  ) // true
{
    int sumA = (byte)(foo) + (byte)(foo);
    // sumA == (97 + 97)
}

```

Also look into [data casting](http://www.cplusplus.com/doc/tutorial/typecasting/) to look at the memory location as different data types. This can be as small as a char or entire structs.