C Basics¶

Variables¶

C Basic Types¶

Variable declaration and initialization¶

Attention that C variable declarations do not initialize variables to default values. So the program below will cause an error:

#include <stdio.h>
int main(int argc, char *argv[]) {
  int32_t x = 0;
  int32_t y;

  printf("before: x=%d, y=%d\n", x, y);
  x++;
  y += x;

  printf(" after: x=%d, y=%d\n", x, y);
  return 0;
}

The program just declares y as type int; it does not initialize y to any default value.

Recall that any 32-bit value can be interpreted as a two's complement integer. At compilation time, the compiler recognizes that y += x; is a valid operation based on the types of x and y. At runtime, the program simply takes whatever 32 bits are at y and adding the value of x, then updating those 32 bits.

Booleans Type in C¶

After C23, C has a built-in boolean type bool with two values. But before that, we need to #include <stdbool.h> for definitions of true and false.

And notice that, values in C are truthy—meaning, means every value can be interpreted as true or false.

False values:

• 0, i.e., all bits of this value are \(0\)

• NULL, which is also defined as \(0\), but is commonly used for pointers. More later.

• false, if stdbool.h is used

Everything else True values.

C Syntax¶

typedef¶

typedef used to create an additional name (alias) for another data type (a little bit like using in C++).

typedef uint8_t Byte;
Byte b1 = 0x12, b2 = 0x34;

struct¶

基础类型与结构体 - 结构体（struct）

struct is used to declare structured groups of variables. A struct is an abstract data type definition.

Preprocessor Macros¶

#define is a C Preprocessor (CPP) macro. Before compilation, the preprocessor does text replacement based on all #define macros. For example:

#define PI (3.14159)

replaces every PI with (3.14159), so PI behaves like a “constant.”

Macros are also often used to create small “functions,” but they are not real functions—only text substitution:

#define min(X, Y) ((X) < (Y) ? (X) : (Y))
next = min(w, foo(z));

is expanded to:

next = ((w) < (foo(z)) ? (w) : (foo(z)));

Constants and Enums¶

const declares a typed constant: assign once, then the value cannot change during execution.

const float  golden_ratio = 1.618;
const int    days_in_week = 7;
const double the_law      = 2.99792458e8;

An enum groups related integer constants:

enum cardsuit { CLUBS, DIAMONDS, HEARTS, SPADES };
enum color { RED, GREEN, BLUE };

By default, the first name is 0, then 1, 2, and so on. Prefer using the names (RED, GREEN, …) instead of hard-coding their integer values.

Control Flow¶

Control flow in C is similar to Java. A few details worth remembering:

• Curly braces: Bodies of if/else and loops may use braces or a single statement. Prefer braces for clarity.

• while and do-while:

  while (condition) {
    /* ... */
  }
  
  do {
    /* ... */
  } while (condition);
  

  do-while runs the body at least once, then checks the condition.

• switch: Execution falls through into later cases until a break (or the end of the switch):

  switch (x) {
    case 1:
      printf("one\n");
      break;
    case 2:
      printf("two\n");
      break;
    default:
      printf("other\n");
  }
  

Functions¶

Every function must declare its return type and parameter types:

int number_of_people(int class1, int class2) {
  return class1 + class2;
}

float dollars_and_cents(float cost) {
  return cost;
}

void say_hi(void) {
  printf("hi\n");
}

• Return type sits to the left of the function name; use void when nothing is returned.

• Parameters must also be typed.

• Variables and functions must be declared before use. In practice, put prototypes (or implementations) near the top of the file, or share them via header files.