#include <stdio.h>

/* Main function: say hello, return signaling no issues */
int main(void)
{
    printf("Hello world!\n");
    return 0; /* this is optional for main() */
}

#include <stdio.h>

/* Main function: show type sizes */
int main(void)
{
    /* can be signed or unsigned */
    char achar;
    short ashort;
    int anint;
    long along;

    /* only signed */
    float afloat;
    double adouble;
    long double alongdouble;

    printf("Size of char: %u bytes\tvalue: %d\n", sizeof(achar), achar);
    printf("Size of short: %u bytes\tvalue: %d\n", sizeof(ashort), ashort);
    printf("Size of int: %u bytes\tvalue: %d\n", sizeof(anint), anint);
    printf("Size of long: %u bytes\tvalue: %ld\n", sizeof(along), along);

    printf("Size of float: %u bytes\tvalue: %f\n", sizeof(afloat), afloat);
    printf("Size of double: %u bytes\tvalue: %lf\n", sizeof(adouble), adouble);
    printf("Size of long double: %u bytes\tvalue: %llf\n", sizeof(alongdouble),
        alongdouble);
}

#include <stdio.h>

/* Main function: show type sizes */
int main(void)
{
    char achar = 'X' ; /* character constant */
    short ashort = 0x0f; /* hexadeciaml constant */
    int anint = 017; /* octal constant */
    long along = -15L; /* decimal constant, long */
    unsigned uiv = 42U; /* decimal constant, unsigned */
    unsigned long ulv = 42UL; /* decimal constant, unsigned long */

    /* floating-point constants */
    float afloat = 12.3e-5f; /* float */
    double adouble = 12.3e-14; /* double */
    long double alongdouble = 12.3e-64L; /* long double */

    printf("Size of char: %u bytes\tvalue: %d\n", sizeof(achar), achar);
    printf("Size of short: %u bytes\tvalue: %d\n", sizeof(ashort), ashort);
    printf("Size of int: %u bytes\tvalue: %d\n", sizeof(anint), anint);
    printf("Size of unsigned int: %u bytes\tvalue: %d\n", sizeof(uiv), uiv);
    printf("Size of long: %u bytes\tvalue: %ld\n", sizeof(along), along);
    printf("Size of unsigned long: %u bytes\tvalue: %ld\n", sizeof(ulv), ulv);

    printf("Size of float: %u bytes\tvalue: %g\n", sizeof(afloat), afloat);
    printf("Size of double: %u bytes\tvalue: %lg\n", sizeof(adouble), adouble);
    printf("Size of long double: %u bytes\tvalue: %llg\n", sizeof(alongdouble),
        alongdouble);
}

#include <stdio.h>

/* Named enumeration */
/* Enumerations start at 0 and the values grow by one */
enum weekday {
    SUN,
    MON,
    TUE,
    WED,
    THU,
    FRI,
    SAT
};

int main(void)
{
    enum weekday today = FRI;

    /* Unnamed enumeration */
    /* A particular value can be forced at any moment */
    enum {
        JAN = 1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC
    } month = MAR;

    printf("The month is: %u\n", month);
    printf("Weekday for today: %u\n", today);

    printf("Is it friday yet? ");
    if (today == FRI)
        printf("Yes!");
    else
        printf("No :(");
    printf("\n");
}

#include <stdio.h>

int main(void)
{
    unsigned int primes[6] = { 2, 3, 5, 7, 11 };
    unsigned int composites[] = { 4, 6, 8, 9 };
    int i;
    unsigned int v[32];
    unsigned int numcomposites = sizeof(composites)/sizeof(composites[0]);

    for (i = 0; i < 32; i++)
        v[i] = 1 << i;

    printf("size of composites: %u, number of elements %u\n",
        sizeof(composites), numcomposites);

    printf("v[#composites]: %u\n",
        v[numcomposites]);
}

#include <stdio.h>

int main(void)
{
    /* A string is a char array, terminated by a NULL byte (value 0) */
    char str[] = "life sentence";
    int i;

    /* Print each character of the string until a NULL byte (is encountered) */
    for (i = 0; str[i] != '\0'; i++)
        printf("%c", str[i]);
    printf("\n");

    /* built-in format: %s prints a string */
    /* how many characters are there in a string? */
    printf("%s [len: %u]\n", str, sizeof(str));
}

/* structures are aggregate types. members can have the same or different types */
struct point {
    int x;
    int y;
};

struct irc_user {
    char nickname[256];
    enum { NONE, VOICE, OP } role;
};

int main(void)
{
    struct irc_user ltworf = { "LtWorf", NONE };
    struct point pt;
    pt.x = 0;
    pt.y = 1;
}

#include <stdio.h>

/* unions are _alternative_ data types: members start at the same
   memory location, and are not independent of each other */
union key {
    int ival;
    float fval;
};

enum key_type {
    INT,
    FLOAT
};

struct entry {
    enum key_type type;
    union key key;
};

int main(void)
{
    struct entry x;
    x.type = INT;
    x.key.ival = 3;
    printf("ival=%d\n", x.key.ival);
    x.type = FLOAT;
    x.key.fval = 2.0;
    printf("fval=%f\n", x.key.fval);

    /* strange result! we read as an int the memory that was written as a float */
    printf("ival=%d\n", x.key.ival);
}

#include <stdio.h>

union key {
    int ival; float fval;
};

enum key_type { INT, FLOAT };

struct entry {
    enum key_type type;
    union key key;
};

void print_entry(struct entry e)
{
    switch(e.type) {
    case FLOAT:
        printf("fval=%f\n", e.key.fval);
        break;
    case INT:
        printf("ival=%f\n", e.key.ival);
        break;
    default:
        printf("this can't happen\n");
    }
}

int main(void)
{
    struct entry x;

    x.type = INT; x.key.ival = 3; print_entry(x);

    x.type = FLOAT; x.key.fval = 2.0; print_entry(x);
}

#include <stdio.h>

void swap(int a, int b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

int main(void)
{
    int x = 1;
    int y = 0;
    swap(x, y);
    /* nothing happened! */
    printf("x=%d,y=%d\n", x, y);
}

#include <stdio.h>

/* visible in the whole file*/
int x = 2;

void foo(void)
{
    int i;
    /* only visible in this function,
      hides the global variable */
    int x = 1;
    printf("\tfoo\t\t%d\n", x);
    for (i = 0; i < 3; i++) {
        /* only visible in the for block,
          hides the x variable defined in the function */
        int x = 3+i;
        printf("\t\tfor\t%d\n", x);
    }
    printf("\tfoo\t\t%d\n", x);
}

int main(void)
{
    printf("main\t\t\t%d\n", x);
    foo();
    printf("main\t\t\t%d\n", x);
}

#include <stdio.h>

/* cvar is visible by all modules linked to this file */
int cvar;

void bar(void)
{
    extern int cvar;
    printf("bar reads %d\n", cvar);
    cvar = 1;
    printf("bar writes %d\n", cvar);
}

void baz(void)
{
    printf("baz reads %d\n", cvar);
    cvar = 3;
    printf("baz writes %d\n", cvar);
}

#include <stdio.h>

extern int cvar;
extern void bar(void);
extern void baz(void);

void foo(void)
{
    printf("foo reads %d\n", cvar);
    cvar = 2;
    printf("foo writes %d\n", cvar);
}

int main(void)
{
    foo();
    bar();
    baz();
    printf("main reads %d\n", cvar);
}

#include <stdio.h>

/* cvar is only visible in this module */
static int cvar;

void bar(void)
{
    extern int cvar;
    printf("bar reads %d\n", cvar);
    cvar = 1;
    printf("bar writes %d\n", cvar);
}

/* baz is only visible in this module */
static void baz(void)
{
    printf("baz reads %d\n", cvar);
    cvar = 3;
    printf("baz writes %d\n", cvar);
}

#include <stdio.h>

extern int cvar; /* fails */
extern void bar(void); /* works */
extern void baz(void); /* fails */

void foo(void)
{
    printf("foo reads %d\n", cvar);
    cvar = 2;
    printf("foo writes %d\n", cvar);
}

int main(void)
{
    foo();
    bar();
    baz();
}

#include <stdio.h>

/* cvar is only visible in this module */
static int cvar;

/* baz is only visible in this module */
static void baz(void)
{
    printf("baz reads %d\n", cvar);
    cvar = 3;
    printf("baz writes %d\n", cvar);
}

void bar(void)
{
    extern int cvar;
    printf("bar reads %d\n", cvar);
    cvar = 1;
    printf("bar writes %d\n", cvar);
    baz();
}

#include <stdio.h>

extern void bar(void); /* works */

int main(void)
{
    bar();
}

#include <stdio.h>

int main(void)
{
    int a = 1;
    /* a POINTER: its value is the address of a memory location */
    /* we set it to the address of a */
    int *ptr = &a;
    printf("%d\n", a);
    /* write the value 2 at the address pointed at by ptr */
    *ptr = 2;
    printf("%d\n", a);
    /* preincrement the address pointed to by ptr */
    ++*ptr;
    /* postincrement the address pointed to by ptr */
    (*ptr)++;
    printf("%d\n", a);
}

#include <stdio.h>

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int main(void)
{
    int x = 1;
    int y = 0;
    swap(&x, &y);
    /* the values are now swapped */
    printf("x=%d,y=%d\n", x, y);
}

#include <stdio.h>

int main(void)
{
    char cv[10];
    short sv[10];
    int iv[10];
    char *cptr;
    short *sptr;
    int *iptr;

    cptr = cv;
    /* add 1 => increment by one byte (sizeof(char)) */
    printf("%p,%p\n", cptr, cptr+1);
    sptr = sv;
    /* add 1 => increment by sizeof(short) */
    printf("%p,%p\n", sptr, sptr+1);
    iptr = iv;
    /* add 1 => increment by sizeof(int) */
    printf("%p,%p\n", iptr, iptr+1);
}

int main(void)
{
    int i;
    unsigned int v[32];
    unsigned int *ptr;

    /* the array v is the address of its first element,
      so v and &v[0] are the same thing, and have type
      unsigned int *
      */
    ptr = &v[0];
    ptr = v;

    /* iterate over an array by moving the pointer */
    for (i = 0; i < 32; i++) {
        *ptr = 1 << i;
        ptr++;
    }

    ptr = &v[0];

    /* iterate over an array using pointer arithmetic*/
    for (i = 0; i < 32; i++) {
        /* equivalent of ptr[i] */
        *(ptr+i) = 1 << i;
    }
}

#include <stdio.h>

struct point { int x; int y; };

void init_point(struct point *pt, int i) {
    /* equivalent to (*pt).x */
    pt->x = i;
    pt->y = 1<<i;
}

void print_point(const struct point *pt) {
    printf("(%d,%d)\n", pt->x, pt->y);
}

int main(void)
{
    struct point v[3];
    int i;

    for (i = 0; i < 3; ++i) {
        init_point(v + i, i);
        print_point(v + i);
    }
}

#include <stdio.h>

int main(void)
{
    int a;
    int *iptr;
    /* void pointers: pointers to data of unspecified type */
    void *vptr;

    iptr = &a;
    /* any pointer can be converted to a void pointer */
    vptr = iptr;

    /* you can't dereference a void pointer: this
      *vptr = 1;
    fails at compile time */

    /* a void pointer can be converted to any other pointer type */
    iptr = vptr;

    /* The null pointer constant is an integer constant with
      value 0 and type integer of void *. As a pointer, it
      reads as a pointer to nothing, and thus an invalid pointer */
    iptr = 0; /* or: iptr = NULL */

    /* dereferencing a null pointer gives a runtime error */
    *iptr = 1;
}

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("Pi is %lf and the cosine of 2*Pi/3 is %lf\n",
        M_PI, cos(2*M_PI/3));
}

% gcc math-lib-example.c -o math-lib-example -lm
% math-lib-example

#include <stdio.h>

#define N 3
#define M 4

int main(void)
{
    int i, j;
    int A[N][M];
    int *ptr;

    /* A is a vector with N elements of type int[M] */
    for (i = 0; i < N; i++)
        for (j = 0; j < M; j++)
            A[i][j] = i - j;

    ptr = &A[0][0];
    for (i = 0; i < N; i++)
        for (j = 0; j < M; j++) {
            printf("%d,%d", A[i][j], *(ptr+i*M+j));
            if (j == M - 1)
                printf("\n");
            else
                printf("\t");
        }

    printf("\n%u\t%u\t%u\n", sizeof(A), sizeof(A)/sizeof(A[0]),
        sizeof(A)/sizeof(A[0][0]));
}

#include <stdio.h>

int main(void)
{
    char *strv[3] = { "foo", "bar", "baz" };
    int i;

    for (i = 0; i < 3; i++)
        printf("%s\n", strv[i]);
}

#include <stdio.h>

/* argc: number of parameters. argv: array of command-line parameters */
int main(int argc, char **argv)
{
    int i;

    /* argv[0] is (almost) always present, and matches the name with which
      the program was called */

    printf("%d params\n", argc);
    for (i = 0; i < argc; i++)
        printf("%s\n", argv[i]);
}

#include <stdio.h>
#include <stdlib.h> /* for atoi() */

/* argc: number of parameters. argv: array of command-line parameters */
int main(int argc, char **argv)
{
    int param;

    if (argc < 2) {
        fprintf(stderr, "give at least one parameter\n");
        /* since this was an error return non-zero */
        return 1;
    }

    /* skip argv[0] */
    --argc;
    ++argv;

    while (argc) {
        param = atoi(argv[0]);
        --argc;
        ++argv;
        printf("read %d\n", param);
    }
}

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    int *vector;
    int numels;

    if (argc != 2) {
        fprintf(stderr, "please specify a number\n");
        return 1;
    }

    /* we know there is exactly one parameter now */
    numels = atoi(argv[1]);

    printf("allocating %d integers\n", numels);

    /* malloc returns a void* which C promotes to int*
      automatically in this case. In C++ automatic
      promotion doesn't happen, so casting is a good habit */
    vector = (int *)malloc(numels * sizeof(int));

    if (vector == NULL) {
        fprintf(stderr, "allocation failed\n");
        return 1;
    }

    /* malloc returns memory with random contents */
    printf("the first integer is %d\n", vector[0]);

    free(vector); /* always remember to free your memory! */

}

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    int *vector;
    int numels;

    if (argc != 2) {
        fprintf(stderr, "please specify a number\n");
        return 1;
    }

    /* we know there is exactly one parameter now */
    numels = atoi(argv[1]);

    printf("allocating %d integers\n", numels);

    vector = (int *)calloc(numels, sizeof(int));

    if (vector == NULL) {
        fprintf(stderr, "allocation failed\n");
        return 1;
    }

    /* calloc returns memory initialized to 0*/
    printf("the first integer is %d\n", vector[0]);

    free(vector); /* always remember to free your memory! */

}