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; abram

 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");

robert
adhi
if (NULL == input)
{
printf("cant open %s\n",filename);
return -1;
}
/* read dwords from the file */
robert
adhi
 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 */

abram
#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__*/

Powered by Notepa
abram