*“One man’s constant is another man’s variable”
-Alan Perlis, Epigrams on Programming, 1982*

To kick off our C series, I figured we should go over one of the most common pieces of language design there is: variables. Variables initially got their start in Mathematics as many pieces of language design did. At their core, variables are not complicated. They’re essentially giving a name to some kind of value like A = 5, B = “hello” or C = 1/2. However, with programming in general this can become more complex. In time we will get to more abstract usage of variables, but for now we need to cover the basic types in C.

In C, C++, Java, and many other explicit languages the programmer will have to specify what data type for a variable. This means that they must specify if what they’re feeding the variable is a number, a letter, a piece of memory, and more. C has a number of different data types with their own purpose:

Data Type | Explanation | Size |
---|---|---|

int | A number of some kind: …, -50, -1, 0, 1, 50, … | Takes up 2-4 bytes of memory, 16 (2*8) to 32 (4*8) bits.Ranges from -32,768 to 32,767 or −2,147,483,648 to 2,147,483,647 |

char | A character of some kind: ‘a’, ‘b’, ‘A’, ‘B’ | Takes up 1 byte of memory, 8 (1*8) bits.Ranges from 0 to 255. |

float | A decimal number: 1.000000, 2.123456, 3.999999 | Takes up 4 bytes of memory, 32 (4*8) bits.Ranges from 1.2E-38 to 3.4E+38Allows up to 6 decimal places of accuracy. |

double | A decimal number: 1.000000000000000, 2.123456789123456, 3.999999999999999 | Takes up 8 bytes of memory, 64 (8*8) bits.Ranges from 2.3E-308 to 1.7E+308Allows up to 15 decimal places of accuracy. |

void | Typeless data, can refer to memory location in certain circumstance (explained later). | N/A, 1 byte, 8 (1*8) bits with some flags.void does not have an actual size. |

short | A number of some kind: …, -50, -1, 0, 1, 50, … | Takes up 2 bytes of memory, 16 (2*8) bits.Ranges from -32,768 to 32,767. |

long | A number of some kind: …, -50, -1, 0, 1, 50, … | Takes up 4 bytes of memory, 32 (4*8) bits.Ranges from −2,147,483,648 to 2,147,483,647. |

Each of these variables have their own unique uses which we will see through the course of this tutorial. The byte specifics are not important at the moment, but they will be very useful when we begin to cover memory management. However, this is not the end of the variable types. Variable modifiers also exist within C which can cause the above variables to change properties. First, we need a quick crash course in binary before we can move on to the variable modifiers.

### Binary Crash Course

For an integer (int), there are anywhere from 2 to 4 bytes depending on the compiler that the code is compiled with and what system the code is run on. Assuming an integer has 4 bytes, that means we have 32 (4*8) bits.

32 bit integer:

00000000000000000000000000000000

With binary, we count from right to left and we add powers of two as we go. For example:

0000 = 0

0001 = 2^0 = 1.

0010 = 2^1 = 2.

0100 = 2^2 = 4.

1000 = 2^3 = 8.

1111 = 2^3 + 2^2 + 2^1 + 2^0 = 8 + 4 + 2 + 1 = 15.

Not all bits contribute the same way to the final number when it comes to computing. Here we introduced the concept of **signed** and **unsigned** values. To tell if a number is negative the most significant bit (farthest left bit) will be 1 (negative) or 0 (positive). If the most significant bit is 1, then we count all 0s as if they were 1s and vice versa and subtract 1 from the total value. This means if our example above was signed it would be the following:

0000 = 0

0001 = 2^0 = 1.

0010 = 2^1 = 2.

0100 = 2^2 = 4.

1000 = -1 * (2^2 + 2^1 + 2^0) – 1 = -1 * (4 + 2 + 1) – 1 = -8.

1111 = -1 * 0 – 1 = -1.

With this we’re now able to express negative numbers, but we run into a big issue: our range has been cut down from 0 – 15 to -8 – 7. Our original form where our range was from 0 to 15 is referred to as **unsigned** and our new form where the range was from -8 to 7 is referred to as **signed**. In C, integers, shorts, and longs are all signed unless specified otherwise.

Applying these steps to our 4 byte integer, we can show that the maximum value is:

01111111111111111111111111111111 = 2,147,483,647

and the minimum value is:

10000000000000000000000000000000 = −2,147,483,648

Now that we know this, we can move on to variable modifiers.

### Back to modifiers

In C there are 4 type modifiers: unsigned, signed, long, and short. While long and short can be used as their own data types shown above, they can also be used to be explicit about the format of some data (long long, short short) or they can modify another data type (long int, short int). Note that not all combinations of these modifiers and the above data types exist such as long/short void.

Modifier | Effect |
---|---|

unsigned X | Do not allow negative numbers, use full binary range. |

signed X | Allow negative numbers, cut down binary range. |

long X | Extend to 64 bits (8 bytes) |

short X | Shrink to 16 bits (2 bytes) |

These are all of the major data types and type modifiers, but with these types a programmer can create more abstract types such as structs, unions, and classes (C++) which we will discuss later. For now, let’s take a look at an example of some of these variables in action. Shown below is an example written in C to demonstrate assigning values to variables of these datatypes and measuring the size of them in bytes. We’ll talk more about the printf function and its syntax in the next part.

We get the values that we assigned like a = 5, b = ‘b’, and so on. Also, since we printed the size of each variable, we were able to figure out the size in bytes according to GCC. Variables are a key tool in any programming language and they will only get more complex from here. In future parts we will discuss operators on variables like * and & which can drastically change how variables act. For now we’ll move on to operators and demonstrate the different major operators.

### Operators

C has a large amount of operators that are usually divided into few categories: Arithmetic, Bitwise, Logical, Memory, Comparison, Assignment, and Incremental.

Operator | Category | Effect |
---|---|---|

+ | Arithmetic | Adds two values |

– | Arithmetic | Subtracts two values |

* | Arithmetic | Multiplies two values |

/ | Arithmetic | Divides two values |

% | Arithmetic | Gets the remainder of two values |

^ | Bitwise | XORs two values For every bit in each value, the new value will have a 1 if one of the bits is 1, but not both (exclusive OR). A = 1011, B = 1110, A ^ B = 0101 |

& | Bitwise | ANDs two values For every bit in each value, the new value will have a 1 if both bits are a 1. |

| | Bitwise | ORs two values For every bit in each value, the new value will have a 1 if one of the bits is 1. |

~ | Bitwise | NOTs a value For every bit in the value, flip the bit to 0 if it is 1 and vice versa. |

>> | Bitwise | Right shifts a value For every bit in the value, shift it right that many places. A = 1000, A >> 2 = 0010. |

<< | Bitwise | Left shifts a value For every bit in the value, shift it left that many places. A = 0001, A << 2 = 0100. |

! | Logical | Negation operator Inverses a particular value such as a 0 –> 1 or 1 –> 0. |

&& | Logical | Logical AND Evaluates if two variables are both 1 (true). |

|| | Logical | Logical OR Evaluates if one variable is 1 (true). |

& | Memory | Reference operator Get the address of a variable. |

* | Memory | Star / Pointer operator Point to a location in memory. |

> | Comparison | Greater than |

< | Comparison | Less than |

>= | Comparison | Greater than or equal |

< | Comparison | Less than or equal |

!= | Comparison | Not equal |

== | Comparison | Equal |

? | Comparison | Conditional / Ternary operator If a condition is met, assign one of two values. A = (B>C ? B : C) A = B if B>C is true and A = C is B>C is false. |

= | Assignment | Assign a value |

+= | Assignment | Add and assign a value A = 1, B = 2, A += B, A == 3 |

-= | Assignment | Substract and assign a value A = 2, B = 1, A -= B, A == 1 |

*= | Assignment | Multiply and assign a value A = 1, B = 2, A *= B, A == 2 |

/= | Assignment | Divide and assign a value A = 4, B = 2, A /= B, A == 2 |

|= | Assignment | OR and assign a value A = 4, B = 2, A |= B, A == 6 |

&= | Assignment | AND and assign a value A = 4, B = 2, A &= B, A == 0 |

^= | Assignment | XOR and assign a value A = 4, B = 2, A ^= B, A == 6 |

%= | Assignment | Modulo and assign a value A = 4, B = 2, A %= B, A == 0 |

++ | Incremental | Increments a value. A = 5, A = A++, A == 6 |

−− | Incremental | Decrements a value. A = 5, A = A–, A == 4. |

We’ll be able to see all of these in use later over some of the example projects. Although, just because C offers this vast amount of operators, it is not uncommon to find C programmers who have not used every one of these operators.