C Syntax

Basic Program

#include <stdio.h>

/*****************************************************************************
  name: main
  purpose: entry point of the whole program
  args: (in)  argc - num of command line arguments (incl. program exe)
        (in)  argv - an array of strings (char*) of each command line argument
                      with argc members
  returns: 0 for success, -1 on failure
*****************************************************************************/
int main(int argc, char **argv)
{
  /* print out hello world to console */
  printf("hello world\n");
  return 0;
}

Basic Types

/*****************************************************************************
  name: show_types
  purpose: show some basic types and type operations
  args: (out) result - ptr to the result of this func
  returns: nothing
*****************************************************************************/
void show_types(int *result)
{
  /* vars */
  int number = 0;           /* whole signed num register size */
  char letter = 'c';        /* whole signed num 1 byte size */
  char *string = "hello";   /* ptr to null-term char array */
  char buffer[50];          /* ptr to a buffer of 50 bytes */
  int array[3] = {1,2,3};   /* ptr to 3 member array of ints */
  float fraction = 3.14;    /* real num 4 byte size */
  double bigfrac = 1.41;    /* real num 8 byte size */
  unsigned long num = 22;   /* whole unsigned num 4 byte size */
  signed short num2 = -17;  /* whole signed num 2 byte size */
  int multi_arr[5][2];      /* ptr to 5 arrays of 2 ints */
  static int times_called = 0;
  
  /* var operations */
  number = (int)letter + 1; /* number now equals 'd' which is 0x64 */
  number++;                 /* number now equals 'e' which is 0x65 */
  number = number % 2;      /* number now equals 1 (modulus) */
  letter -= 2;              /* letter now equals 'a' which is 0x61 */
  num = num ^ 0x55555555;   /* num is xored with 0x55555555 */
  string[0] = 'j';          /* string now points to "jello", 0 is first pos */
  *(string+4) = 'y';        /* string now points to "jelly" */
  string = &letter;         /* string now points to letter, which is 'a' */
  fraction = 2 * 2.3 / 1.2; /* fraction now equals 3.83333 */
  num = (~0x00) & 0x03 | (1<<2);  /* num now equals 0x07 */
  multi_arr[4][0] = 10;     /* place 10 in the first member of the last arr */
  times_called++;           /* keeps value between calls, actually global */
  *result = 42;             /* place 42 in the result ptr we were given */
}

Conditionals

/*****************************************************************************
  name: show_conds
  purpose: show some basic conditionals
  args: (in)  age - the age of the viewer
  returns: nothing
*****************************************************************************/
void show_conds(int age)
{
  /* vars */
  int score = 0;

  /* if statement */
  if ((0 == age) && (age != 1)) return;   /* just born */

  /* if-else statement */
  if ((age < 18) || !(age <= 80))
  {
    /* not in the right age to be here */
    return;
  }
  else score = 1;  /* give a bonus of 1 for the right age */

  /* switch block, instead of many if-else blocks */
  switch (age)
  {
    case 17:
    case 53:
      score++;              /* give extra bonuses for these ages */
      score = score * 2;
      break;
    default:
      score = 0;            /* for all others start again from zero */
  }

  /* do something with the score */
  handle_score(score);
}

Loops and Iterations

/*****************************************************************************
  name: show_flow
  purpose: show some basic flow blocks
  args: none
  returns: total score
*****************************************************************************/
int show_flow()
{
  /* vars */
  int score = 0;  /* holds num of iterations */
  int i;          /* our mighty iterator */
  char ch;        /* input character */

  /* for statement */
  for (i=0; i<10; i++) score++; /* loop 10 times */

  /* while statement, check condition before */
  i = 3;
  while (i>0)       /* loop 2 times */
  {
    score++;
    i = i - 2;
  }

  /* do-while statement, check condition after */
  do                /* loop 1 time */
  {
    score++;
    i--;
  } while (i>0);

  /* continue and break can help decide locally */
  while (1)         /* loop forever */
  {
    ch = get_input_from_user();
    if (ch == 'q') break;         /* exit the loop */
    if (ch == 's') continue;      /* continue to the next iteration */
    score++;
  }

  return score;
}

Structures and Enums

/*****************************************************************************
  name: show_moredata
  purpose: show some more data types
  args: none
  returns: nothing
*****************************************************************************/
void show_moredata()
{
  /* types */
  struct gun {
    char name[50];
    int magazine_size;
    float calibre; };                           /* structure */
  typedef struct gun gun_type;                  /* simplify the type */
  enum days {sun = 1,mon,tue,wed,thr,fri,sat};  /* int values with names */
  
  /* vars */
  struct gun glock = {"Glock",17,0.9};  /* init by members */
  gun_type m16 = {0};                   /* init all to zero */
  gun_type *gun_ptr = &m16;             /* ptr to the m16 gun */
  enum days today = wed;
  
  glock.magazine_size++;
  gun_ptr->magazine_size = glock.magazine_size + 13;
  today++;                              /* today is actually int */
}

Dynamic Memory

#include <stdlib.h>
#define NULL (0)

/*****************************************************************************
  name: show_dynamic_mem
  purpose: show usage of dynamic memory allocation
  args: (in)  size - size of buffer to use (in bytes)
        (in)  elements - num of elements to hold
  returns: 0 on success, -1 on failure
*****************************************************************************/
int show_dynamic_mem(int size, int elements)
{
  /* vars */
  char *buffer = NULL;
  int *dyn_int_array = NULL;

  /* allocate buffer of size bytes */
  buffer = malloc(size);
  if (NULL == buffer) return -1;

  /* allocate dynamic array of elements ints */
  dyn_int_array = malloc(elements * sizeof(int));
  if (NULL == dyn_int_array)
  {
    free(buffer);
    return -1;
  }
  
  do_something(buffer, dyn_int_array);

  /* cleanup */
  free(buffer);
  free(dyn_int_array);
  return 0;
}

Standard IO

#include <stdio.h>
#define NULL (0)

/*****************************************************************************
  name: show_stdio
  purpose: show usage of standard input / output
  args: (in)  filename - name of file to work with
  returns: 0 on success, -1 on failure
*****************************************************************************/
int show_stdio(char *filename)
{
  /* vars */
  FILE *input = NULL;
  unsigned long dword = 0;
  int items_read = 0;

  /* open the file in binary mode for read only */
  input = fopen(filename, "rb");
  if (NULL == input)
  {
    printf("cant open %s\n",filename);
    return -1;
  }
  /* read dwords from the file */
  while (!feof(input))
  {
    items_read = fread(&dword, sizeof(dword), 1, input);
    if (1 == items_read) printf("read from %s the dword %08x\n",filename,dword);
    else break;
  }
  /* cleanup */
  fclose(input);
  return 0;
}

Preprocessor and H Files

/*****************************************************************************
  name: h_file_example
  purpose: demonstrate usage of an h file and the preprocessor
*****************************************************************************/
#ifndef __H_FILE_EXAMPLE__
#define __H_FILE_EXAMPLE__

#include "another_h_file.h"

/* defines */
#define NULL  (0)
#define TRUE  (1)
#define FALSE (0)
#define GREETING "hello world"

/* macros */
#define max(A,B) ((A)>(B)?(A):(B))

extern int global_in_c;   /* declare a global defined in matching c file */

/*****************************************************************************
  name: show_types
  purpose: show some basic types and type operations
  args: (out) result - ptr to the result of this func
  returns: nothing
*****************************************************************************/
void show_types(int *result);

/*****************************************************************************
  name: show_flow
  purpose: show some basic flow blocks
  args: none
  returns: total score
*****************************************************************************/
int show_flow();

#endif /*__H_FILE_EXAMPLE__*/