前言#

炸炸炸，不想说话！

Pragma Once and Header Guards#

Pragma Once#

If the same header file gets included more than once, you can end up with some nasty errors caused by redefining things like functions or structs.

One simple solution is #pragma once. Adding this line to the top of a header file tells the compiler to include the file only once, even if it’s referenced multiple times across your program.

1
#pragma once
2

3
struct Point {
4
  int x;
5
  int y;
6
  int z;
7
};

Header Guards#

Another common way to avoid multiple inclusions is with include guards, which use preprocessor directives like this:

1
#ifndef MY_HEADER_H
2
#define MY_HEADER_H
3

4
// some cool code
5

6
#endif

Structs#

Define#

1
struct Coordinate {
2
  int x;
3
  int y;
4
  int z;
5
};

Initializers#

Say we have a struct defined like this:

1
struct City {
2
  char *name;
3
  int lon;
4
  int lat;
5
};

There are a few different ways to initialize a struct.

Zero Initializer#

1
struct City c = {0};

Positonal Initializer#

1
struct City c = {"San Francisco", -122, 37};

Designated Initializer#

1
struct City c = {
2
  .name = "San Francisco",
3
  .lon = -122,
4
  .lat = 37
5
};

Accessing Fields#

1
struct City c;
2

3
c.lat = 41;
4

5
printf("Latitude: %d\n", c.lat);

Typedef#

If you give a name to the struct while using typedef, you’d have 2 ways refer to this type:

1
typedef struct Coordinate {
2
  int x;
3
  int y;
4
  int z;
5
} cood_t;
6

7
struct Coordinate way_1;
8
coord_t way_2;

We can optionally skip giving the struct a name:

1
typedef struct {
2
  int x;
3
  int y;
4
  int z;
5
} coord_t;
6

7
coord_t coord;

In this case, you’d only be able to refer the type as coord_t.

Sizeof Struct#

Structs are stored contiguously in memory one field after another. Take this struct:

1
typedef struct {
2
  int x;
3
  int y;
4
  int z;
5
} coord_t;

Assuming int is 4 bytes, the total size of coord_t would be 12 bytes.

1
typedef struct {
2
  char first_initial;
3
  int age;
4
  double height;
5
} human_t;

Assuming char is 1 byte, int is 4 bytes, and double is 8 bytes, the total size of human_t would be 16 bytes.

Each member of a struct must be aligned to its own alignment requirement
The overall size of a struct must be a multiple of the largest alignment requirement among its members
$padding=( alignment-( address\ \%\ alignment)) \ \%\ alignment$

TIP
As a rule of thumb, ordering your fields from largest to smallest will help the compiler minimize padding.

For example:

1
typedef struct {
2
  char a;
3
  double b;
4
  char c;
5
  char d;
6
  long e;
7
  char f;
8
} poorly_aligned_t;
9

10
typedef struct {
11
  double b;
12
  long e;
13
  char a;
14
  char c;
15
  char d;
16
  char f;
17
} better_t;

poorly_aligned_t will insert 20 paddings, total size would be 40 bytes. But better_t only add 4 paddings, its size would be 24 bytes only.

Pointers#

A pointer is declared with an asterisk (*) after the type. For example, int *.

To get the address of a variable so that we can store it in a pointer variable, we can use the address-of operator (&).

1
int age = 28;
2
int *p_int = &age;

Oftentimes we have a pointer, but we want to get access to the data that it points to. Not the address itself, but the value stored at that address.

We can use an asterisk (*) to do it. The * operator dereferences a pointer.

1
int meaning_of_life = 42;
2
int *pointer_to_mol = &meaning_of_life;
3
int value_at_pointer = *pointer_to_mol;
4
// value_at_pointer = 42

It can be a touch confusing, but remember that the asterisk symbol is used for two different things:

Declaring a pointer type: int *pointer_to_thing;
Dereferencing a pointer value: int value = *pointer_to_thing; (retrieving the value) or *pointer_to_thing = 20; (modifying the value)

In C, structs are passed-by-value. Updating a field in the struct does not change the original struct
To get the change to “persist”, we can return the updated struct from the function (a new copy) or just pass struct’s pointer, and dereference the pointer to modify the original struct

As you know, when you have a struct, you can access the fields with the dot (.) operator:

1
coord_t point = {10, 20, 30};
2

3
printf("X: %d\n", point.x);

However, when you’re working with a pointer to a struct, you need to use the arrow (->) operator:

1
coord_t point = {10, 20, 30};
2
coord_t *ptrToPoint = &point;
3

4
printf("X: %d\n", ptrToPoint->x);

It effectively dereferences the pointer and accesses the field in one step. To be fair, you can also use the dereference and dot operator (* and .) to achieve the same result (it’s just more verbose and less common):

1
coord_t point = {10, 20, 30};
2
coord_t *ptrToPoint = &point;
3

4
printf("X: %d\n", (*ptrToPoint).x);

Order of Operations#

The . operator has a higher precedence than the * operator, so parentheses are necessary when using * to dereference a pointer before accessing a member… which is another reason why the arrow operator is so much more common.

Void Pointers#

A void * “void pointer” tells the compiler that this pointer could point to anything. This is why void pointers are also known as a “generic pointer”.

Since void pointers do not have a specific data type, they cannot be directly dereferenced or used in pointer arithmetic without casting them to another pointer type first.

1
int number = 42;
2
void *generic_ptr = &number;
3

4
// This doesn't work
5
printf("Value of number: %d\n", *generic_ptr);
6

7
// This works: Cast to appropriate type before dereferencing
8
printf("Value of number: %d\n", *(int *)generic_ptr);

A common pattern is to store generic data in one variable, and the type of that data in another variable. This is useful when you need to pass data around without knowing its type at compile time.

1
typedef enum DATA_TYPE {
2
  INT,
3
  FLOAT
4
} data_type_t;
5

6
void printValue(void *ptr, data_type_t type) {
7
  if (type == INT) {
8
    printf("Value: %d\n", *(int *)ptr);
9
  } else if (type == FLOAT) {
10
    printf("Value: %f\n", *(float *)ptr);
11
  }
12
}
13

14
int number = 42;
15
printValue(&number, INT);
16

17
float decimal = 3.14;
18
printValue(&decimal, FLOAT);

Arrays#

Declaration#

1
int numbers[5] = {1, 2, 3, 4, 5};

Array as Pointer#

1
int *way_1 = numbers;
2
int *way_2 = &numbers[0];

Accessing Elements via Indexing#

1
// Access the third element (index 2)
2
int way_1 = numbers[2];
3
int way_2 = *(numbers + 2);

Array Casting#

1
#include <stdio.h>
2

3
typedef struct {
4
  int x;
5
  int y;
6
  int z;
7
} coord_t;
8

9
int main() {
10
  coord_t arr[3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
11

12
  for (int i = 0; i < 3; i++) {
13
    for (int j = 0; j < 3; j++) {
14
      printf("%d\n", *(int *)&arr[i] + j);
15
    }
16
  }
17

18
  return 0;
19
}

Because arrays are basically just pointers, and we know that structs are contiguous in memory, we can cast the array of structs to an array of integers:

1
#include <stdio.h>
2

3
typedef struct {
4
  int x;
5
  int y;
6
  int z;
7
} coord_t;
8

9
int main() {
10
  coord_t arr[3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
11
  int *ptr = (int *)arr;
12

13
  for (int i = 0; i < 9; i++) {
14
    printf("%d\n", ptr[i]);
15
    // printf("%d\n", *(int *)&arr + i);
16
  }
17

18
  return 0;
19
}

Array Decay to Pointers#

So we know that arrays are like pointers, but they’re not exactly the same. Arrays allocate memory for all their elements, whereas pointers just hold the address of a memory location. In many contexts, arrays decay to pointers, meaning the array name becomes “just” a pointer to the first element of the array.

When Arrays Decay#

Arrays decay when used in expressions containing pointers:

1
int arr[5];
2
int *ptr = arr;          // 'arr' decays to 'int *'
3
int value = *(arr + 2);  // 'arr' decays to 'int *'

And also when they’re passed to functions… so they actually decay quite often in practice. That’s why you can’t pass an array to a function by value like you do with a struct; instead, the array name decays to a pointer.

When Arrays Don’t Decay#

sizeof Operator: Returns the size of the entire array (e.g., sizeof(arr)), not just the size of a pointer
& Operator: Taking the address of an array with &arr gives you a pointer to the whole array, not just the first element. The type of &arr is a pointer to the array type, e.g., int (*)[5] for an int array with 5 elements
Initialization: When an array is declared and initialized, it is fully allocated in memory and does not decay to a pointer

Enumerations#

You can define a new enum type like this:

1
typedef enum DaysOfWeek {
2
  MONDAY,
3
  TUESDAY,
4
  WEDNESDAY,
5
  THURSDAY,
6
  FRIDAY,
7
  SATURDAY,
8
  SUNDAY,
9
} days_of_week_t;

The typedef and its alias days_of_week_t are optional, but like with structs, they make the enum easier to use.

In the example above, days_of_week_t is a new type that can only have one of the values defined in the enum:

MONDAY, which is 0
TUESDAY, which is 1
WEDNESDAY, which is 2
THURSDAY, which is 3
FRIDAY, which is 4
SATURDAY, which is 5
SUNDAY, which is 6

An enum is not a collection type like a struct or an array. It’s just a list of integers constrained to a new type, where each is given an explicit name.

You can use the enum type like this:

1
typedef struct Event {
2
  char *title;
3
  days_of_week_t day;
4
} event_t;
5

6
typedef struct Event {
7
  char *title;
8
  enum DaysOfWeek day;
9
} event_t;

Non-Default Values#

Sometimes, you want to set those enumerations to specific values. For example, you might want to define a program’s exit status codes:

1
typedef enum {
2
  EXIT_SUCCESS = 0,
3
  EXIT_FAILURE = 1,
4
  EXIT_COMMAND_NOT_FOUND = 127,
5
} ExitStatus;

Alternatively, you can define the first value and let the compiler fill in the rest (incrementing by 1):

1
typedef enum {
2
  LANE_WPM = 200,
3
  PRIME_WPM, // 201
4
  CUBEY_WPM,  // 202
5
} WordsPerMinute;

Switch Case#

One of the best features of enums is that it can be used in switch statements.

Avoid “magic numbers”
Use descriptive names
With modern tooling, will give you an error/warning that you haven’t handled all the cases in your switch

1
switch (logLevel) {
2
case LOG_DEBUG:
3
  printf("Debug logging enabled\n");
4
  break;
5
case LOG_INFO:
6
  printf("Info logging enabled\n");
7
  break;
8
case LOG_WARN:
9
  printf("Warning logging enabled\n");
10
  break;
11
case LOG_ERROR:
12
  printf("Error logging enabled\n");
13
  break;
14
default:
15
  printf("Unknown log level: %d\n", logLevel);
16
  break;
17
}

You’ll notice that we have a break after each case. If you do not have a break (or return), the next case will still execute: it “falls through” to the next case.

In some rare cases, you might want the fallthrough:

1
switch (errorCode) {
2
case 1:
3
case 2:
4
case 3:
5
  printf("Minor error occurred. Please try again.\n");
6
  break;
7
case 4:
8
case 5:
9
  printf("Major error occurred. Restart required.\n");
10
  break;
11
default:
12
  printf("Unknown error.\n");
13
  break;
14
}

Sizeof Enum#

Generally, enums in C are the same size as an int. However, if an enum value exceeds the range of an int, the C compiler will use a larger integer type to accommodate the value, such as an unsigned int or a long.

Union#

union is just a combination of the two concepts with struct and enum.

1
typedef union AgeOrName {
2
  int age;
3
  char *name;
4
} age_or_name_t;

The age_or_name_t type can hold either an int or a char *, but not both at the same time (that would be a struct). We provide the list of possible types so that the C compiler knows the maximum potential memory requirement, and can account for that. This is how the union is used:

1
age_or_name_t lane = { .age = 29 };
2
printf("age: %d\n", lane.age);
3
// age: 29

Here’s where it gets interesting. What happens if we try to access the name field (even though we set the age field)?

1
printf("name: %s\n", lane.name);

A union only reserves enough space to hold the largest type in the union and then all of the fields use the same memory.

Then if we try to access .name, we read from the same block of memory but try to interpret the bytes as a char *, which is undefined behavior. Put simply, setting the value of .age overwrites the value of .name and vice versa, and you should only access the field that you set.

Memory Layout#

Unions store their value in the same memory location, no matter which field or type is actively being used. That means that accessing any field apart from the one you set is generally a bad idea.

Union Size#

A downside of unions is that the size of the union is the size of the largest field in the union. Take this example:

1
typedef union IntOrErrMessage {
2
  int data;
3
  char err[256];
4
} int_or_err_message_t;

The int_or_err_message_t union will take 256 bytes whether it use err or not.

Helper Fields#

One interesting (albeit not commonly used) trick is to use unions to create “helpers” for accessing different parts of a piece of memory. Consider the following:

1
typedef union Color {
2
  struct {
3
    uint8_t r;
4
    uint8_t g;
5
    uint8_t b;
6
    uint8_t a;
7
  } components;
8
  uint32_t rgba;
9
} color_t;

Only 4 bytes are used. And, unlike in 99% of scenarios, it makes sense to both set and get values from this union through both the components and rgba fields! Both fields in the union are exactly 32 bits in size, which means that we can “safely” (?) access the entire set of colors through the .rgba field, or get a single color component through the .components field.

The convenience of additional fields, with the efficiency of a single memory location!

前言#

Pragma Once and Header Guards#

Pragma Once#

Header Guards#

Structs#

Define#

Initializers#

Zero Initializer#

Positonal Initializer#

Designated Initializer#

Accessing Fields#

Typedef#

Sizeof Struct#

Pointers#

Important things related to structs#

Order of Operations#

Void Pointers#

Arrays#

Declaration#

Array as Pointer#

Accessing Elements via Indexing#

Array Casting#

Array Decay to Pointers#

When Arrays Decay#

When Arrays Don’t Decay#

Enumerations#

Non-Default Values#

Switch Case#

Sizeof Enum#

Union#

Memory Layout#

Union Size#

Helper Fields#