2 Reminding C

2.1 Basic C Programming

2.1.1 C Program Structure

• Preprocessor Commands
• Type definitions
• Function prototypes - declare function types and variables passed to function.
• Variables
• Functions

type function_name( parameters)
{
	local variables declaration
	C statements
}

main()
{
	printf( "Hello world!\n");
	exit( 0);
}

• C requires a semicolon at the end of every statement.
• printf is a standard C function - called from main.
• \n signifies newline. Formatted output - more later.
• exit() is also a standard function that causes the program to terminate.
• Strictly speaking it is not needed here as it is the last line of main() and the program will terminate anyway.

2.1.2 Variables

var_type list variables;

int i, j, k;
float x, y, z;

2.1.2.1 Defining Global Variables

short number, sum;
int big_number;
char letter;

main()
{
}

float sum = 0.0;
int big_sum = 0;

a = b = c = 3;

a = 3;
b = 3;
c = 3;

typedef real float;
typedef letter char;

func()
{
	real a;
	letter c;
}

2.1.2.2 Printing Out and Inputting Variables

printf( "%c%d%f", ch, i, x);

scanf( "%c%d%f", &ch, &i, &x);

2.1.3 Arithmetic Operations

i = 5;
ch = 'y';

x ++;

x = x + 1

int x,y,z;
main()
{
	x = (( ++z ) * ( w--)) % 100;
}

int x,y,z;
main()
{
	z++;
	x = (z * w) % 100;
	w--;
}

2.1.4 Comparison Operators

if ( i = j ) ...

2.1.5 Logical Operators

&& for logical AND,
|| for logical OR.

2.1.6 Order of Precedence

(a + b) * c

a + (b * c)

a - b - c

(a - b ) - c

() [] -> .

! ~ -(unary) * & sizeof castings ++ --

* / %

+ -

< <= >= >

== !=

&

^

|

&&

||

?:

= += -= *= /=

,(comma)

a < 10 && 2 * b < c

( a < 10 ) && ( ( 2 * b ) < c )

2.2 Conditionals

==, !=, ||, &&

• The if statement
• The ?: operator
• The switch statement

2.2.1 The if statement

if( condition)
	statements

if( condition)
	statements1
else
	statements2

if( condition1)
	statements1
else if( condition2)
	statements2
else
	statements3

int x, y, z;

main()
{
	x = ...
	if( x > 0)
		y = x;
	else
		z = x;
}

2.2.2 The ?: operator

condition ? expression1 : expression2

if condition then expression1 else expression2

z = ( a > b) ? a: b;

if(  a > b)
	z = a;
else
	z = b;

2.2.3 The switch statement

switch( expression)
{
case item1:
	statements1
break;
case item1:
	statements1
break;
...
default:
	statements1
break;
}

switch(  letter)
{
case ' ':
case '\t':
case '\n':
	num_of_spaces++;
	break;
case 'A':
case 'E':
case 'I':
case 'O':
case 'U':
	num_of_vowels++;
	/* note: no break */
default:
	num_of_letters++;
	break;
}

2.3 Looping and Iteration

2.3.1 The for statement

for( expression1; expression2; expression3)
	statements

main()
{
	int x;
	for( x = 3; x > 0; x--)
		printf( "x=%d\n", x);
}

x=3
x=2
x=1

2.3.2 The while statement

while( expression)
	statements

main()
{
	int x;

	x = 3;
	while( x > 0)
	{
		printf( "x=%d\n", x);
		x -- ;
	}
}

while( (ch = getchar()) != 'q')
	putchar( ch);

2.3.3 The do-while statement

do
	statement
while( expression);

main()
{
	int x = 3;

	do {
		printf( "x=%d\n", x);
		x -- ;
	}
	while( x > 0)
}

2.3.4 break and continue

while( scanf( "%d", &val) == 1)
{
	if( val <= 0)
		break;	/* abandon the loop */
	if( val > 100)
		continue;	/* skip the val */
	/* some actions with the val */
}

2.4 Arrays

2.4.1 Single and Multi-dimensional Arrays

int list_of_numbers[50];

num3 = list_of_numbers[2];
list_of_numbers[5] = 100;

int table_of_numbers[50][50];

a_number = table_of_numbers[2][3];
table_of_numbers[15][5] = 100;

2.4.2 Strings

char name[50];

char name[50];
name = "john";

char name[50];
strcpy( name, "john");

printf("%s", name);

2.5 Exercise 1

2.6 Functions

return_type function_name( parameters)
{
	local_variables

	statements
}

float average( float a, float b)
{
	float av;
	av = ( a + b) /2.0;
	return( av);
}

main()
{
	float x = 5, y = 10, z;
	z = average( x, y);
	printf( "average = %f\n", z);
}

2.6.1 void functions

void print_first_10()
{
	int i;
	for( i = 1; i <= 10; i ++)
		printf( "%d\n", i);
}

main()
{
	print_first_10();
}

2.6.2 Functions and Arrays

float find_max( float list[], int size)
{
	int n;
	float max = list[0];
	for( n = 1;  n < size; n++)
		if( max < list[n])
			max = list[n];
	return( max);
}

void print_table( int x_size, int y_size, float table[][5])
{
	int x, y;
	for( x = 0; x < x_size; x ++)
	{
		for( y = 0; y < y_size; y ++)
			printf( "\t%d", table[x][y]);
		printf( "\n");
	}
}

2.6.3 Function Prototyping

• It makes for more structured and therefore easier to read code.
• It allows the C compiler to check the syntax of function calls.

int strlen(char []);

2.7 Further Data Types

2.7.1 Structures

struct gun
{
	char name[50];
	int magazine_size;
	float calibre;
};

struct gun arnies;

struct gun
{
	char name[50];
	int magazine_size;
	float calibre;
} arnies;

struct gun arnies = { "Kalashnikov", 25, 7.62};

arnies.magazineSize=100;

2.7.2 Defining New Data Types

typedef struct gun
{
	char name[50];
	int magazine_size;
	float calibre;
} agun;

agun arnies = { "Kalashnikov", 25, 7.62};

agun arniesguns[1000];

arniesguns[51].calibre = 5.45;

itscalibre = arniesguns[0].calibre;

2.7.3 Unions

union number
{
	short shortnumber;
	long longnumber;
	float floatnumber;
} anumber;

printf( "%d\n", anumber.longnumber);

2.7.4 Coercion or Type-Casting

int int_val;
float float_val = 9.87;

int_val = (int)float_val;

int int_val = 10;
float float_val;

float_val = (float)int_val;

int int_val1 = 10;
int int_val2 = 4;
float float_val;

float_val = (float)int_val1 / (float)int_val2;

2.7.5 Enumerated Types

enum days {mon, tues, ..., sun}week;

enum days week1, week2;

enum spec_chars { new_line = '\n', tab = '\t', backspace = '\b'};

enum months {jan= 1, feb, mar, ......, dec};

2.7.6 Static Variables

void stat_test()
{
	int local_var = 0;
	static int static_var = 0;

	printf( "local = %d, static = %d\n", local_var, static_var);
	local_var ++ ;
	static_var ++ ;
}

main()
{
	int n;

	for( n = 0; n < 3; n++)
		stat_test();
}

local = 0, static = 0
local = 0, static = 1
local = 0, static = 2

2.8 Common Mistakes in C

2.8.1 Assignment (=) versus Comparison (==)

if (a = b) ...

a = b;
if( b) ...

2.8.2 Missing () of a function

2.8.3 Array indices

2.8.4 C is Case Sensitive

2.8.5 Semicolons end every statement

2.9 Pointers

• It is the only way to express some computations.
• It produces compact and efficient code.
• It provides a very powerful tool.

• Arrays,
• Structures,
• Functions.

2.9.1 What is a Pointer?

int *pointer;

int x = 1, y = 2;
int* ip;

ip = &x;
y = *ip;
*ip = 3;

int* ip;
*ip = 100;

int* ip;
int x;

ip = &x;	/* assign to ip some REAL memory address */
*ip = 100;

int *ip;
...
ip += 10;
++ip;

float* fp;
float arr[100];

fp = arr;	/* fp points to the beginning of arr, i.e. to arr[0] */
fp += 2;	/* fp points to arr[2] */

2.9.2 Pointer and Functions

swap( a, b);	/* WON'T WORK */

swap( &a, &b);

void swap( int* px, int* py)
{
	int temp;

	temp = *px;
	*px = *py;
	*py = temp;
}

2.9.3 Pointers and Arrays

int a[10], x;
int* pa;

pa = &a[0];		/* pa points to address of a[0] */
x = *pa;		/* the same: x = a[0] */

pa + i  <------>  a[i]

pa = a;

pa = &a[0];

a[i]

as *(a + i)

pa[i]  <------->  *(pa + i)

• A pointer is a variable. We can do pa = a and pa++.
• An array is NOT a variable. a = pa and a++ ARE ILLEGAL.

strlen(s)  <------->  strlen(&s[0])

int strlen( char s[]);

int strlen(char *s);

int strlen( char* s)
{
	int i;
	for( i = 0; s[i] != '\0'; i++)
		;
	return( i);
}

void strcpy( char* d, char* s)
{
	whle( ( *d++ = *s++) != '\0')
		;	/* NOTE: Uses of empty statements */
}

2.9.4 Arrays of Pointers

• Store lines end-to-end in one big char array. '\0' will delimit lines.
• Store pointers in a different array where each pointer points to 1st char of each new line.
• Compare two lines using strcmp() standard library function.
• If 2 lines are out of order - swap pointer in pointer array (not text).

• complicated storage management.
• high overheads of moving lines.

2.9.5 Multidimensional arrays and pointers

f(int a[][35]) {.....}

char* ptr_name[10];
char arr_names[10][20];

• arr_name is a true 200 element 2D char array; access elements via row + col + base_address in memory.
• ptr_name has 10 pointer elements.

2.9.6 Static Initialization of Pointer Arrays

void some_func()
{
	static char* months[] =
	{
		"jan",
		"feb",
		...
	};
}

2.9.7 Pointers and Structures

struct COORD
{
	float x, y, z;
};
struct COORD pt;
struct COORD* pt_ptr;

pt_ptr = &pt;

pt_ptr->x = 1.0;
pt_ptr->y = pt_ptr->y - 3.0;

typedef struct element_struct
{
	int			val;
	struct element_struct*	next;
} NODE;

NODE n1, n2, n3;
n1.next = &n2;
n2.next = &n3;
...

2.9.8 Common Pointer Pitfalls

2.9.8.1 Not assigning a pointer to memory address before using it

int* x;
*x = 100;

int y;
int* x;
x = &y;
*x = 100;

2.9.8.2 Illegal indirection

int y;
int* x;
x = &y;
x = 100;

2.10 Dynamic Memory Allocation

• dynamic arrays
• dynamic data structure, e.g. linked lists

2.10.1 Malloc

void* malloc( unsigned int number_of_bytes);

char* cp;
cp = (char*) malloc( 100);	/* to get 100 bytes and assign the */
/* start address to cp */

int* ip;
ip = (int*)malloc( 100 * sizeof( int));

int i;
struct COORD { float x, y, z; };
typedef struct COORD PT;
PT pt;
PT* pt_ptr;

sizeof( int)
sizeof( i)
sizeof( struct COORD)
sizeof( PT)
sizeof( pt)
sizeof( pt_ptr)

int* ip;
ip = (int*)malloc( 100 * sizeof( int));
for( i = 0; i < 100; i++)
scanf( "%d", ip[i]);

void free( void* ptr);

2.10.2 Linked Lists

typedef struct element_struct
{
	int			val;
	struct element_struct*	next;
} NODE;

void print_list( NODE* list)
{
	NODE* node;
	for( node = list; node != NULL; node = node->next)
		printf("%d\n", node->val);
}

new_node = (NODE*) malloc( sizeof( NODE));

int main()
{
	NODE* first;
	NODE* node;
	NODE* new_node;

	first = NULL;

	while( something)
	{
		new_node = (NODE*) malloc( sizeof( NODE));
		new_node->val = some_value;
		new_node->next = NULL;
		/* if our list is empty - that's all */
		if( first == NULL)
		{
			first = new_node;
			continue;
		}
		/* let's find the last element of the list */
		for( node = first; node->next != NULL; node = node->next)
			;
		node->next = new_node;
	}
	/* Now we can use the newly built list, e.g. to print it
	   using the procedure written above */
	print_list( first);
}

2.11 Input and Output (I/O)

#include <stdio.h>

2.11.1 Streams

1. to declare a variable or pointer of this type in our programs (we do not need to know any more specifics about this definition),
2. to open a stream before doing any I/O,
3. then access it,
4. and then close it.

2.11.1.1 Predefined Streams

• stdin (standard input stream)
• stdout (standard output stream)
• stderr (standard output stream for error/warning/etc. messages)

2.11.1.2 Redirection

out > file1

in < file2

prog1 | prog2

prog | fmt

2.11.2 Basic I/O

int ch;
ch = getchar();
putchar( ch);

int getc(FILE *stream)
int putc(int ch,FILE *stream)

2.11.3 Formatted I/O

2.11.3.1 printf

• ordinary characters - these are copied to output.
• conversion specifications - denoted by % and listed in the table:

Format spec (%)

Type

Result

c

char

single character

i, d

int

decimal number

o

int

octal number

x, X

int

hexadecimal number

u

int

unsigned int

s

char*

print string terminated by '\0'

f

double, float

format: m.ddd...

e,E

double, float

scientific format: -5.46e003

g, G

double, float

the most compact of f or e formats

%

-

print % character

printf( "%-6.3f", 15.9826)

15.983

printf( "my part is 15.5%%\n");

my part is 15.5%

2.11.3.2 scanf

scanf("%d'', &i);

char line[80];
scanf( "%s", line);

2.11.4 Files

FILE *fopen(char *name, char *mode)

FILE* fp;
fp = fopen( "myfile.dat", "r");

FILE* fp;
if( ( fp = fopen( "myfile.dat", "r")) == NULL)
{
	printf( "Can't open file myfile.dat\n");
	return( some_err_code);
}
... read the file ...

2.11.4.1 Reading and writing FILES

int fprintf( FILE* stream, char* format, args...);
int fscanf( FILE* stream, char* format, args...);

FILE* fp;
char line[80];
if( ( fp = fopen( "myfile.dat", "r")) == NULL)
{
	printf( "Can't open file myfile.dat\n");
	return( some_err_code);
}
fscanf( fp, "%s", line);

int getc(FILE *stream);
int fgetc(FILE *stream);
int putc(char ch, FILE *s);
int fputc(char ch, FILE *s);

fprintf(stderr,´´Cannot Compute!!n'');
fscanf(stdin,´´%s'',string);

2.11.5 sprintf and sscanf

int sprintf(char *string, char *format, args..);
int sscanf(char *string, char *format, args..);

float Pi=3.141.59;
char line_for_output[80];
sprintf( line_for_output, "PI=%f", Pi);

2.11.6 Command line input

main(int argc, char **argv)

• argc is the number of arguments typed - including the program name.
• argv is an array of strings holding each command line argument - including the program name in the first array element.

main( int argc, char* argv[])
{
	int i;
	for( i = 0; i < argc; i++ )
		printf( "%d = %s\n", i, argv[i]);
}

argv abc def xyz

0 = argv
1 = abc
2 = def
3 = xyz

2.12 Low Level Operators

2.12.1 Bitwise Operators

&

AND

|

OR

^

XOR (exclusive OR)

~ (unary)

One's Complement (0->1; 1->0)

<<

Left shift

>>

Right shift

2.12.2 Bit Fields

• Packing several objects into a machine word. e.g. 1 bit flags can be compacted - Symbol tables in compilers.
• Reading external file formats - non-standard file formats could be read in. E.g. 9 bit integers.

struct packed_struct
{
	unsigned int flag1:1;
	unsigned int flag2:1;
	unsigned int flag3:1;
	...
};

• Bit fields are always converted to integer type for computation.
• The unsigned definition is important - ensures that no bits are used as a flag.

2.13 The C Preprocessor

• programs easier to develop,
• easier to read,
• easier to modify,
• C code more transportable between different machine architectures.

2.13.1 #define

#define macro replacement

#define PI	3.14159

#define max(A,B)	((A)>(B)?(A):(B))

int x = 8;
int y;
y = max(x, 10);

int x = 8;
int y;
y = ((x)>10?x:10);

x = max( q + r, s + t);

x = ( ( q + r) > ( s + t) ? ( q + r) : ( s + t));

x = max( a++, b++);

#define percents( x, y)	((x)*100./(y))

2.13.2 #undef

2.13.3 #include

#include <file>

#include "file"

2.13.4 #if - Conditional inclusion

#ifdef _MSC_VER
typedef __int64	BIG_INT;
#else
typedef long	BIG_INT;
#endif

BIG_INT	my_big_integer;

2.14 ANSI C Library

2.15 Exercise 2