• Keep reading for the quick crash-course to C Programming below

• Learn X in Y(Highly recommended to skim through!)
• C for C++/Java Programmers
• C Tutorial by Brian Kernighan
• c faq
• C Bootcamp
• C/C++ function reference
• gdb (Gnu debugger) tutorial Tip: run gdb with the "-tui" command line argument to get a full-screen version of the debugger.
• Add your favorite resources here

#include <stdio.h>
int main(void) { 
    printf("Hello World\n");
    return 0; 
}

When you write a string literal "ABC" in an expression the string literal evaluates to a char pointer (char *), which points to the first byte/char of the string. This means ptr in the example below will hold the memory address of the first character in the string.

char *ptr = "ABC"

char *str = "ABC";
char str[] = "ABC";
char str[]={'A','B','C','\0'};

char *ptr = "Hello"; // ptr holds the memory location of 'H'
ptr += 2; //ptr now points to the first'l'

char *ptr = "ABCDEFGH";
int *bna = (int *) ptr;
bna +=1; // Would cause iterate by one integer space (i.e 4 bytes on some systems)
ptr = (char *) bna;
printf("%s", ptr);
/* Notice how only 'EFGH' is printed. Why is that? Well as mentioned above, when performing 
'bna
+=1' we are increasing the **integer** pointer by 1, (translates to 4 bytes on most 
systems) which 
is equivalent to 4 characters (each character is only 1 byte)*/
return 0;

Because pointer arithmetic in C is always automatically scaled by the size of the type that is pointed to, you can't perform pointer arithmetic on void pointers.

You can think of pointer arithmetic in C as essentially doing the following

If I want to do

int *ptr1 = ...;
int *offset = ptr1 + 4;

int *ptr1 = ...;
char *temp_ptr1 = (char*) ptr1;
int *offset = (int*)(temp_ptr1 + sizeof(int)*4);

void *give_me_space = malloc(10);
char *string = give_me_space;

gcc and clang are not total ISO-C compliant, meaning that they will let you do arithmetic on a void pointer. They will treat it as a char pointer but do not do this because it may not work with all compilers!

printf calls write. printf includes an internal buffer so, to increase performance printf may not call write everytime you call printf. printf is a C library function. write is a system call and as we know system calls are expensive. On the other hand, printf uses a buffer which suits our needs better at that point

int num1 = 10;
printf("%d", num1); //prints num1

int *ptr = (int *) malloc(sizeof(int));
*ptr = 10;
printf("%p\n", ptr); //prints the address pointed to by the pointer
printf("%p\n", &ptr); /*prints the address of pointer -- extremely useful
when dealing with double pointers*/
printf("%d", *ptr); //prints the integer content of ptr
return 0;

./program > output.txt

#To read the contents of the file,
cat output.txt

char ary[] = "Hello";
char *ptr = "Hello";

Example

The array name points to the first byte of the array. Both ary and ptr can be printed out:

char ary[] = "Hello";
char *ptr = "Hello";
// Print out address and contents
printf("%p : %s\n", ary, ary);
printf("%p : %s\n", ptr, ptr);

In this case, the char pointer ptr points to some read-only memory (where the statically allocated string literal is stored), so we cannot change those contents.

strcpy(ary, "World"); // OK
strcpy(ptr, "World"); // NOT OK - Segmentation fault (crashes)

ptr = "World"; // OK!
ptr = ary; // OK!
ary = (..anything..) ; // WONT COMPILE
// ary is doomed to always refer to the original array.
printf("%p : %s\n", ptr, ptr);
strcpy(ptr, "World"); // OK because now ptr is pointing to mutable memory (the array)

char str1[] = "will be 11";
char* str2 = "will be 8";
sizeof(str1) //11 because it is an array
sizeof(str2) //8 because it is a pointer

int* f1(int *p) {
    *p = 42;
    return p;
} // This code is correct;

char* f2() {
    char p[] = "Hello";
    return p;
} // Incorrect!

char* f3() {
    char *p = "Hello";
    return p;
} // OK

char* f4() {
    static char p[] = "Hello";
    return p;
} // OK

int *space = malloc(sizeof(int) * 10);

void mystrcpy(char*dest, char* src) { 
  // void means no return value   
  while( *src ) { dest = src; src ++; dest++; }  
}

while( *src ) { *dest = *src; src ++; dest++; }
*dest = *src;

while( (*dest++ = *src++ )) {};

// Use strlen+1 to find the zero byte... 
char* mystrdup(char*source) {
   char *p = (char *) malloc ( strlen(source)+1 );
   strcpy(p,source);
   return p;
}

int *n = (int *) malloc(sizeof(int));
*n = 10;
//Do some work
free(n);

int *p = malloc(sizeof(int));
free(p);

*p = 123; // Oops! - Dangling pointer! Writing to memory we don't own anymore

free(p); // Oops! - Double free!

Fix:

p = NULL; // Now you can't use this pointer by mistake

typedef float real; 
real gravity = 10;
// Also typedef gives us an abstraction over the underlying type used. 
// In the future, we only need to change this typedef if we
// wanted our physics library to use doubles instead of floats.

typedef struct link link_t; 
//With structs, include the keyword 'struct' as part of the original types

typedef int (*comparator)(void*,void*);

int greater_than(void* a, void* b){
    return a > b;
}
comparator gt = greater_than;