Placeholders for values. Restrictions on names:

• Names can't start with numbers.
• Same for two underscores.
• Same for single underscore and capital A-Z.

printf: Well, prints stuff. Look up manpage for more info.

sizeof: returns the size of anything. It's return type is an unsigned int called size_t. NOTE: It's a compile time operator, not a function

NOTE: It is compile time to use sizeof

Always remember braces!

If the parentheses in a C function are empty, it means it can take in any number of arguments. To specify no arguments, use void.

Arguments are copied. To modify the original thing pass a pointer.

A prototype is the signature that tells the compiler what the function takes in and spits out. Ends with a semicolon.

Hold memory locations. Really, that's all there is to it.

#include <stdio.h>

int main(void)
{
    int i = 10;
   
    printf("The value of i is %d\n", i);
    printf("And its address is %p\n", (void *)&i);
   
    // %p expects the argument to be a pointer to void
    // so we cast it to make the compiler happy.
}

The address of anything can be obtained with & in front of it. To get the value from the address, use * in front of it.

Note on pointer declaration: int *p, q; over here only p is a pointer, q is a regular int.

No surprises here either. You cannot have arrays with variable length, (you technically can), and you need to store the value of the length separately.

If you declared an array in the same scope you can check its size using sizeof(arr)/size(arr[0]).

Stuff like this also works:

int a[10] = {0, 11, 22, [5]=55, 66, 77};

Intermediate values and others are set to be 0. We can leave the size to be blank if we specify all values in the constructor initializer.

Arrays also act as pointers.

int main() {
  int a[10] = {0};
  int *p = a;
  p = &a[0];
}

Always pass the size of the array as a separate variable.

For multidimensional arrays, you have to pass all the dimensions except for the first one.

Ordered data-type containing various kinds of data fields.

struct car {
    char *name;
    float price;
    int speed;
};

// Now with an initializer! Same field order as in the struct declaration:
struct car saturn = {"Saturn SL/2", 16000.99, 175};

printf("Name:      %s\n", saturn.name);
printf("Price:     %f\n", saturn.price);
printf("Top Speed: %d km\n", saturn.speed);

struct car saturn = {.speed=175, .name"Saturn SL/2"};= something like this can also be done.

Whatever isn't initialized explicitly is initialised to 0 in memory.

Dot to access fields, arrow to access if it is a pointer to a struct.

Note: Do NOT compare structs directly.

The structs are laid out in memory in the same way as they are initialized, barring the fact that there might be struct padding in between them.

FILE * is a pointer to a file in C. fprintf and fscanf take the first arguments as the file pointer and the rest is the same as printf and scanf.

To open a file, use fopen("file_path", "mode"). Mode can be r or w (for read or write).

Note: fgetc returns an int. This is because EOF doesn't fit in char.

fscanf and fprintf take the file pointer as the first argument. fputc, fputs, fgetc and fgets take them as the last argument.

Basically creates an alias for an existing type. Scoped. Useful for structs and arrays and pointers.

//  Anonymous struct! It has no name!
//         |
//         v
//      |----|
typedef struct {
    char *name;
    int leg_count, speed;
} animal;                         // <-- new name

//struct animal y;  // ERROR: this no longer works--no such struct!
animal z;           // This works because "animal" is an alias

typedef int *intptr;

int a = 10;
intptr x = &a, y = &a;  // "intptr" is type "int*"

// Make type five_ints an array of 5 ints
typedef int five_ints[5];

five_ints x = {11, 22, 33, 44, 55};

Allocate on heap manually, free manually.

va_arg is a macro.

#include <stdio.h>
#include <stdarg.h>

int add(int count, ...)
{
    int total = 0;
    va_list va;
   
    va_start(va, count);   // Start with arguments after "count"
   
    for (int i = 0; i < count; i++) {
        int n = va_arg(va, int);   // Get the next int
     
        total += n;
    }
   
    va_end(va);  // All done
   
    return total;
}

int main(void)
{
    printf("%d\n", add(4, 6, 2, -4, 17));  // 6 + 2 - 4 + 17 = 21
    printf("%d\n", add(2, 22, 44));        // 22 + 44 = 66
}

// in file 1
int arr[10];

// in file 2
extern int *arr;

This is semantically incorrect and leads to an access violation. It thinks that arr holds the contents to the pointer. Making a reference to arr[i] is equivalent to saying that start at wherever arr points, move over i places using the contents of arr[0..8] as the pointer value.

Instead just declare it with extern int arr[].

They need to have the names libname.so where name is what you link with -lname. LD_LIBRARY_PATH and LD_RUN_PATH are used for

Unlike with references in C++, you can have top level cv qualifiers for a pointer. That is to say,

void f(int * const p);

is valid. However, the above example is meaningless as the pointer is copied into the function. It makes sense for int const * p as that implies that the underlying data is constant.

Volatile is for raw hardware and basically means a value should be looked up from

Used for function optimization. If a pointer is an argument to a function, then the function is not aliased at all, atleast never written into. Mostly used as a hint to the compiler. However, it better not be used unless you're sure what you're doing.

Just like structs, if the composing members of the union all have the same type, say int, then the pointer to the union is also a pointer to the int, no matter which one of the variants was set last.

Some ancient feature you shouldn't be bothered about. Basically ??! getting converted to pipe symbol and other shenanigans.