Data Types, Operators, and Control Flow: C vs. Scripting Languages

The Landscape of C Data Types

In JavaScript, you're used to a few flexible data types like Number, String, and Boolean. C, by contrast, provides a more granular and rigid set of types, which gives you precise control over memory usage.

Let's start with a high-level overview.

The primary, or basic, data types can be summarized as follows:

These basic types can be modified with qualifiers like short, long, signed, and unsigned to fine-tune their size and range. For example, unsigned int can only store non-negative numbers, but its maximum value is twice that of a signed int.

How Data is Really Stored: A Low-Level Look

Your goal is to understand how C translates to machine instructions. A crucial part of that is grasping how these data types are represented in memory as bits and bytes.

The following video provides an excellent deep dive into this topic. It starts with some thought-provoking questions and then breaks down the "magic" behind the answers. This directly addresses your interest in memory representation, signed vs. unsigned numbers, and potential pitfalls like overflow.

Key Takeaways from the Video:

• Signed vs. Unsigned: For a signed type (like int or signed char), the most significant bit (MSB) is the sign bit. If it's 1, the number is negative. For an unsigned type, the MSB is just part of the number, allowing for a larger positive range.
• Two's Complement: This is the standard method for representing negative integers in binary. To find the two's complement of a negative number (e.g., -7), you:
  1. Take the binary representation of its positive counterpart (7 is 00000111).
  2. Invert all the bits (one's complement): 11111000.
  3. Add 1: 11111001. This is how -7 is stored.
• Overflow: When you assign a value that's too large for a variable's type (e.g., char c = 256;), the value "wraps around." This is undefined behavior for signed types but well-defined for unsigned types. The compiler often warns you about this.

Comparison with JavaScript and PHP

Your experience with JS and PHP provides a useful contrast. Let's frame C's typing system against what you know.

To explore these differences further, this article written specifically for JavaScript developers moving to C is a great read.

Operators in C

Most operators in C will look very familiar to you. The syntax for arithmetic, comparison, and logical operators in C was the direct inspiration for their implementation in JavaScript and PHP.

Here is a cheat sheet for JavaScript operators, which you can use as a reference point.

Here's a quick comparison:

A Deeper Look at Bitwise Operators

Since you're interested in systems programming, mastering bitwise operators is non-negotiable. They allow you to manipulate individual bits within an integer.

• & (AND): 1010 & 1100 -> 1000 (sets a bit if it's set in both operands)
• | (OR): 1010 | 1100 -> 1110 (sets a bit if it's set in either operand)
• ^ (XOR): 1010 ^ 1100 -> 0110 (sets a bit if it's set in one, but not both, operands)
• ~ (NOT): ~1010 -> ...0101 (flips all bits)
• << (Left Shift): 0001 << 2 -> 0100 (shifts bits to the left, equivalent to multiplying by 2^n)
• >> (Right Shift): 1000 >> 2 -> 0010 (shifts bits to the right, equivalent to dividing by 2^n)

Control Flow

The good news is that C's control flow syntax is the direct ancestor of what's used in JavaScript and PHP. The concepts of if, else, while, and for will be immediately familiar.

This short video provides a great visual refresher on the logic of conditional statements.

Here's a quick syntactic comparison based on the Wikipedia resource.

The switch Statement's "Fall-Through" Behavior

The most important difference to be aware of is that in C, switch cases fall through by default. If you omit the break statement, execution will continue into the next case.

int num = 2;
switch (num) {
    case 1:
        printf("One\n"); // Skipped
    case 2:
        printf("Two\n"); // Executed
    case 3:
        printf("Three\n"); // Also executed because there's no break!
    default:
        printf("Default\n"); // Also executed!
}
// Output:
// Two
// Three
// Default

This is a classic source of bugs for newcomers. You must explicitly break out of a case if you don't want this behavior.

Conclusion

In this lesson, we laid the groundwork for writing C programs by covering the essential building blocks. You now have a low-level appreciation for how data is stored and manipulated.

Key Takeaways:

• C is statically typed; you must declare the type of every variable. This allows the compiler to perform compile-time memory allocation.
• The signed and unsigned modifiers are crucial, as they change how the most significant bit is interpreted and affect the range of values a variable can hold.
• Negative numbers are stored using two's complement.
• Most C operators are syntactically identical to their JS/PHP counterparts, but bitwise operators are especially important for low-level programming.
• Control flow structures like if, while, and for are very familiar, but you must be mindful of the fall-through behavior in C's switch statement.

In our next lesson, we will move on to another fundamental concept: functions. We will learn how to define and call them, and we will explore C's pass-by-value mechanism for function arguments, which has important implications for how data is handled.

Practice Exercises

Time to put theory into practice! Create a new directory and work through these problems. They are designed to be solved with the concepts from this lesson.

1. Type Inspector: Write a program that declares one variable of each of these types: char, unsigned char, int, unsigned int, float, and double. Use the sizeof() operator to print the size (in bytes) of each type. For example: printf("Size of int: %zu bytes\n", sizeof(int));. The %zu format specifier is used for sizeof's return type.

2. Fahrenheit to Celsius Converter: Write a program that converts a temperature from Fahrenheit to Celsius. Define a float variable for the Fahrenheit temperature and assign it a value (e.g., 68.0). Calculate the Celsius temperature using the formula C = (F - 32) * 5.0 / 9.0 and print the result with one decimal place (e.g., %.1f).

3. Simple Bitwise Flag Checker: Write a program that uses bitwise operators.

   • Declare an unsigned char called status and initialize it to 0.
   • Set the 1st, 3rd, and 7th bits to 1 using the | (OR) operator and bit shifts (1 << n).
   • Print the status as a number.
   • Use an if statement and the & (AND) operator to check if the 3rd bit is set and print a message if it is.
   • Turn off the 7th bit using the & and ~ (NOT) operators. Print the new status.

4. Grade Calculator with switch: Write a program that converts a numerical grade into a letter grade. Declare an int variable score (e.g., 85). Divide the score by 10. Use a switch statement on the result of the division.

   • case 10: and case 9: should print "Grade: A".
   • case 8: should print "Grade: B".
   • ...and so on for C, D, and F.
   • Remember to use break and a default case for invalid scores.

5. FizzBuzz: Implement the classic FizzBuzz problem. Write a for loop that iterates from 1 to 100.

   • For multiples of three, print "Fizz".
   • For multiples of five, print "Buzz".
   • For numbers which are multiples of both three and five, print "FizzBuzz".
   • Otherwise, print the number.
   • (Hint: The modulo operator % is your best friend here).