c programming l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
C Programming PowerPoint Presentation
Download Presentation
C Programming

Loading in 2 Seconds...

play fullscreen
1 / 135

C Programming - PowerPoint PPT Presentation


  • 224 Views
  • Uploaded on

C Programming. Philip Fees CS320. Introduction . What made C language popular? What is the future of the C language? Why learn the C language? What does ANSI C mean?. Workshop 1 Topics. Comments Expressions Grouping symbols Identifiers Loops Conditional branching File I/O Basics.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'C Programming' - eliot


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
c programming

C Programming

Philip Fees

CS320

CS320 - C Programming

introduction
Introduction
  • What made C language popular?
  • What is the future of the C language?
  • Why learn the C language?
  • What does ANSI C mean?

CS320 - C Programming

workshop 1 topics
Workshop 1 Topics
  • Comments
  • Expressions
  • Grouping symbols
  • Identifiers
  • Loops
  • Conditional branching
  • File I/O Basics

CS320 - C Programming

comments
Comments
  • English(?) description of program logic
  • Describe what program is doing not how
  • /* this is a comment */
  • Example:

/* increment x until it equals 10 */

int x = 0;

while ((x = x + 1) < 10);

CS320 - C Programming

expressions
Expressions
  • Statements that are terminated by a semicolon (;)
  • Evaluation part of loops and conditional branching statements
  • Have a boolean value (0 = false, non-zero = true)

CS320 - C Programming

grouping symbols
Grouping Symbols
  • Way of specifying a set of statements
  • Pascal uses ‘begin’ and ‘end’
  • C uses { and } symbols
  • Example:

if ( x < 10 ) {

printf(“An example of grouping statements\n”);

printf(“x is less than 10\n”);

}

CS320 - C Programming

identifiers
Identifiers
  • Names of variables and functions
  • [A-Za-z_][A-Za-z0-9_]*
  • Examples:

get_next, count, setCount, i

  • Review exercises on page 40

CS320 - C Programming

while loop
While Loop
  • Top testing loop
  • Syntax:

while ( expression )

action

  • Example:

int x = 0;

while ( x < 10 )

x = x + 1;

CS320 - C Programming

do loop
Do Loop
  • Bottom testing loop
  • Syntax:

do action

while ( expression );

  • Example:

int x = 0;

do {

x = x + 1;

} while (x < 10);

CS320 - C Programming

if statement
If Statement
  • Conditional Branch
  • Syntax:

if ( expression )

action

  • Example:

if ( x < 10 ) {

printf(“x is less than 10\n”);

}

CS320 - C Programming

else statement
Else Statement
  • Optional branch of an if statement
  • Syntax:

if ( expression )

action1

else action2

  • Example:

if (x > 10)

printf(“x is greater than 10\n”);

else printf(“x is less than or equal to 10\n”);

CS320 - C Programming

nested if else statements
Nested If Else Statements
  • Not part of language - readability issue
  • Syntax:

if ( expression1 )

action1

else if ( expresion2 )

action2

else if ( expresionN )

actionN

else actionN+1

CS320 - C Programming

file i o basics
File I/O Basics
  • Include stdio.h, open file, read/write, and close
  • Example:

#include <stdio.h>

FILE *fp = fopen(“file”,”r”);

int amount; fscanf(fp,”%d”,&amount);

fclose(fp);

CS320 - C Programming

workshop 2 topics
Workshop 2 Topics
  • data types
  • operators
  • for loop

CS320 - C Programming

data types
Data Types
  • char
  • short int a.k.a. short
  • int
  • long int a.k.a. long
  • signed, unsigned

CS320 - C Programming

data types cont
Data Types (cont.)
  • float
  • double
  • long double

CS320 - C Programming

arithmetic operators
Arithmetic Operators
  • + addition, - subtraction, * multiplication, / division, % modulus
  • -=, *=, /=, %=
  • precedence (left to right): *, /, %, +, -
  • (right to left): %=, +=, -=, *=, /=

CS320 - C Programming

relation logic operators
Relation/Logic Operators
  • == equal, != not equal, > greater than, >= greater than/equal, < less than, <= less than/equal
  • Precedence (left to right): <, <=, >, >=, ==, !=

CS320 - C Programming

for loop
For Loop
  • Top testing loop
  • Syntax:

for ( expression1;expression2;expression3)

action

  • Example:

int x;

for ( x = 0; x < 10; x = x + 1 )

printf(“%d\n”,x);

CS320 - C Programming

unary operators
Unary Operators
  • ++ and -- (both prefix and postfix)
  • Increment (decrement) variable by one unit
  • Example:

int x=1;

printf(“++x = %d, x++ = %d\n”,++x,x++);

CS320 - C Programming

workshop 3 topics
Workshop 3 Topics
  • Debugging techniques
  • Print debugging
  • Debuggers
  • Other tools
    • run time profilers
    • performance profilers

CS320 - C Programming

print debugging
print debugging
  • Probably the least efficient technique
  • Place printf/fprintf at various points in code
  • Can be enabled/disabled at compile/run time
  • Can be useful in production trouble shooting
  • Can affect some types of bugs
  • Can significantly increase code size

CS320 - C Programming

print debug example 1
Print Debug Example 1
  • Compile time option: /D MYDEBUG (-D on UNIX)

#include <stdio.h>

char str[10];

...

#ifdef MYDEBUG

fprintf(stderr,”%d@%s: value of str=[%*.*s]\n”,__LINE__,

__FILE__,sizeof(str),sizeof(str),str);

#endif

CS320 - C Programming

print debug example 2
Print Debug Example 2
  • Compile & Run time

#include <stdio.h>

int debugLevel = 1; /* set via command line option */

char str[10];

...

#ifdef MYDEBUG

if (debugLevel >= 1)

fprintf(stderr,”%d@%s: value of str=[%*.*s]\n”,

__LINE__,__FILE__,sizeof(str),sizeof(str),str);

#endif

CS320 - C Programming

debuggers
Debuggers
  • Lets user interact with executing program
  • Usually part of an integrated development environment or as add-on utility
  • Most debuggers support basic set features
  • Difference is in additional features
  • UNIX adb, sdb, dbx, debugger, etc.
  • Windows part of Visual, Borland, etc.
  • Need to keep symbol table (-g UNIX)

CS320 - C Programming

basic debugger features
Basic Debugger Features
  • Set break point
  • Step through program execution
  • Display/watch variables/address contents
  • Modify variables/address contents
  • Step into, over, out of functions
  • Modify process environment
  • Display stack trace

CS320 - C Programming

adv debugger features
Adv. Debugger Features
  • Attach to running process
  • Command history and aliases
  • Memory profiling
  • Code patching
  • Expression evaluation
  • Handling threaded applications
  • Function execution

CS320 - C Programming

run time profilers
Run Time Profilers
  • Utilities that report information on a process
  • Bounds checking

char str[5]; strcpy(str,”123456789”);

  • Memory leak - dynamically allocate memory that is never released
  • Using initialized variables

char str[5]; printf(“str=%s\n”,str);

  • Memory usage stats.

CS320 - C Programming

performance profilers
Performance Profilers
  • Compile time option
    • UNIX: compile with -p and prof(1)
    • Windows: see profiling option for environment
  • Link time utilities
  • Reports various bits of information
    • # of time function call
    • min., avg., max. times
    • call tree

CS320 - C Programming

workshop 4 topics
Workshop 4 Topics
  • Branch statements
  • Switch
  • goto
  • Casting
  • Character I/O
  • Bit operators
  • formatted printing using printf

CS320 - C Programming

branch statements
Branch Statements
  • break statement - from innermost loop

int strcmp(char str1[], char str2[])

{

int idx; /* local index variable */

for (idx = 0; str1[idx] != 0 && str2[idx] != 0; idx++)

if (str1[idx] != str2[idx])

break;

return str1[idx] - str2[idx];

}

CS320 - C Programming

branch statements cont
Branch Statements (cont.)
  • continue statement - resume execution at loop evaluation

char str[50]; int idx, count = 0; /* fixed length records */

while (scanf(“%50c”,str) != EOF) {

for (idx = 0; idx < 50; idx++) {

if (isspace(str[idx])) {

idx = 49;

continue;

}

else if (str[idx] == ‘A’)

count++;

}

}

CS320 - C Programming

switch statement
Switch Statement
  • Restricted version of if, else if, …, else
  • case values must be constant integer values

switch ( integer expression ) {

case constant integer 1:

statement 1

case constant integer 2:

statement 2

case constant integer n:

statement 3

default: /* optional, but typically a good practice */

default statement

}

CS320 - C Programming

switch example
Switch Example
  • Example: “fall through case” and break

switch ( gender ) {

case ‘M’:

case ‘m’:

printf(“male”);

break;

case ‘F’:

case ‘f’:

printf(“female”);

break;

default:

printf(“Pat”);

break;

}

CS320 - C Programming

goto statement
goto Statement
  • Unconditional transfer to a label
  • Abused and maligned
  • Overuse results in spaghetti code
  • Limited uses include nested loop exit and post processing clean-up
  • Also useful for single exit point from a function
  • best to limit scope to within a function

CS320 - C Programming

goto example
goto Example
  • Typically database access requires post processing clean-up

/* allocate cursors and declare query */

if (error)

return FAILED;

while (!error) {

/* fetch first/next record */

if (error)

goto cleanup;

/* print record */

}

cleanup:

/* deallocate cursor */

CS320 - C Programming

conditional expression
Conditional Expression
  • ternary operator

expression1 ? expression2 : expression3

  • like an if else statement, but has a value (either expression2 or expression3)
  • Example:

int x, y, quotent;

quotent = y == 0 ? 0 : x / y; /* avoid divide by 0

CS320 - C Programming

cast operator
Cast Operator
  • Force value to the given data type
  • Use with caution: prone to errors

long x = 999999;

short y = (short)x; /* what is value of y? */

  • Example:

char str1[10], str2[10];

memcpy((void *)str1,str2,10);

CS320 - C Programming

sizeof operator
sizeof Operator
  • Calculates the number of bytes the operand requires.
  • Example:

printf(“sizeof(char)=%d\n”,sizeof(char));

printf(“sizeof(short)=%d\n”,sizeof(short));

printf(“sizeof(int)=%d\n”,sizeof(int));

printf(“sizeof(long)=%d\n”,sizeof(long));

printf(“sizeof(float)=%d\n”,sizeof(float));

printf(“sizeof(double)=%d\n”,sizeof(double));

printf(“sizeof(char *)=%d\n”,sizeof(char *));

char str[15]; printf(“sizeof(str)=%d\n”,sizeof(str));

printf(“sizeof(10)=%d\n”sizeof(10));

CS320 - C Programming

bitwise operators
Bitwise Operators
  • Bit manipulation operators
    • ~x one’s complement x
    • x & y bit and x and y
    • x | y bit or x and y
    • x ^ y bit exclusive x and y
    • x << y shift x left y bits
    • x >> y shift x right y bits
  • Example:

int flags = DEBUG_ON | TRACE_ON;

if (flags & DEBUG_ON) ...

CS320 - C Programming

getchar and putchar
getchar and putchar
  • getchar - get a single character (as an int) from stdin; return EOF at end of input
  • putchar - put a single character (as an int) to stdout; return character or EOF on error
  • Example:

int c; /* why an int ? */

while ((c = getchar()) != EOF) /* hu? */

if (putchar( c ) == EOF)

fprintf(stderr,”putchar(%d) failed\n”,c);

CS320 - C Programming

formatted printing
Formatted Printing
  • #include <stdio.h>
  • printf(const char *format, arg1, … ,argN)
  • fprintf(FILE *, const char *format, arg1,…,argN)
  • All characters are copied to output
  • % sign begins a conversion code

CS320 - C Programming

formatted printing cont
Formatted Printing (cont.)
  • Some basic examples:

1) printf(“Hello World!\n”);

2) printf(“Hello\t\tWorld!\n”);

3) printf(“Hello World!\n”);

printf(“==== ======\n”);

4) printf(“H\b_e\b_l\b_l\b_o\b_ W\b_o\b_r\b_l\b_d\b_!\b_\n”);

CS320 - C Programming

formatted printing cont44
Formatted Printing (cont.)
  • Conversion Codes
    • Begins with % sign
    • Optional flags
    • Optional positive minimum field width
    • Optional period
    • Optional positive precision
    • Argument code

CS320 - C Programming

formatted printing cont45
Formatted Printing (cont.)
  • Most commonly used conversion codes are c (char), d (char, short, int), f (float/double), s (string)
  • %c replaced by a single ASCII character
  • %d replaced by decimal notation string
  • %f replaced by real number - m.nnnnnn
  • %s replaced by contents of string

CS320 - C Programming

formatted printing cont46
Formatted Printing (cont.)
  • Some basic examples:

1) printf(“%s\n”,”Hello World!”);

2) printf(“%s\t\t%s\n”,”Hello”,”World!”);

3) printf(“Hello World %d!\n”,6);

4) int i1 = 5; double d1 = 6.78;

printf(“i1=%d, d1=%lf\n”,i1,d1);

CS320 - C Programming

formatted printing cont47
Formatted Printing (cont.)
  • Some advanced examples:

int i1 = 5; double d1 = 6.78, d2 = 1.2345;

1) printf(“$%.2f $%.2f\n”,d1,d2);

2) printf(“%4.1f\n”,d2);

3) printf(“%*.*f\n”,4,1,d2);

4) printf(“%06d\n”,i1);

5) printf(“%-*d\n”,6,i1);

CS320 - C Programming

formatted printing cont48
Formatted Printing (cont.)
  • Some string examples (from K&R C):

char *str = “Hello, World”; /* 12 bytes long */

1) printf(“[%10s]”,str); /* [Hello, World] */

2) printf(“[%-10s]”,str); /* [Hello, World] */

3) printf(“[%20s]”,str); /* [ Hello, World] */

4) printf(“[%-20s]”,str); /* [Hello, World ] */

5) printf(“[%20.10s]”,str); /* [ Hello, Wor] */

6) printf(“[%-20.10s]”,str); /* [Hello, Wor ] */

7) printf(“[%.10s]”,str); /* [Hello, Wor] */

CS320 - C Programming

workshop 5 topics
Workshop 5 Topics
  • functions
  • scope
  • preprocessor
  • varargs

CS320 - C Programming

functions
Functions
  • A unit of programming logic that should perform a specific task given a set of values and having a resulting value.
  • Terminology
    • is invoked or called
    • passed arguments
    • receives parameters
    • returns a value

CS320 - C Programming

c function definition
C Function Definition
  • function header

<return_type> functionName ( <args> )

  • return_type is the data type return by the functions or void
  • args type and argument pairs passed to the function, void for no arguments
  • function body

{

actions;

return expression_of_type_return_type;

}

CS320 - C Programming

c function declaration
C Function Declaration
  • a.k.a. function prototype
  • Used by the compiler to ensure all calls to the function conform function’s “signature”
  • Same as function definition head
  • Argument names are optional
  • Terminate with a semicolon.
  • functions return int by default

CS320 - C Programming

c functions cont
C Functions (cont.)
  • All C programs consist of at least one function - main
  • Function declarations cannot be nested
  • Order of argument evaluation is not guaranteed

CS320 - C Programming

call by value
Call by Value
  • Function receives parameters that are copies of the arguments values
  • Prevents side effects - function can’t modify the passed arguments
  • C supports Call by Reference via pointers - will be covered later

CS320 - C Programming

local variables
Local Variables
  • Scope of parameters and variables defined with a function limited to the function
  • Example:

int idx = 0;

int func( int arg)

{

int idx = 1;

arg = arg + idx;

return arg;

}

CS320 - C Programming

c preprocessor
C Preprocessor
  • Process source file before compiling
  • Principle use is to include header files, macros, and constant definitions

#include <stdio.h>

#define max(a,b) (a > b ? a : b)

#define MAXLENGTH 512

CS320 - C Programming

preprocessor directives
Preprocessor Directives
  • Number sign (#) in first column
  • Most often used directives
    • #include
    • #define
    • #ifdef, #ifndef, #elif, #else, #endif

CS320 - C Programming

including header files
Including Header Files
  • Way to define interface to library functions
  • Example:

#include <stdio.h>

FILE *fp = fopen(“file”,”r”);

int amount; fscanf(fp,”%d”,&amount);

fclose(fp);

CS320 - C Programming

defining constants
Defining Constants
  • Use in place of “hard coding” constant values in the code
  • Example:

int months;

scanf(“%d”,&months);

if (months > 360) /* error */

  • Better. Why?

#define MAX_MONTHS 360

if (months > MAX_MONTHS)

CS320 - C Programming

conditional directives
Conditional Directives
  • Like if, else if, else
  • Example:

#ifdef SUN

#define HOST “SUN Solaris”

#else

#define HOST “Not SUN Solaris”

#endif

  • cc … -D SUN … <== Unix
  • cc … /D SUN … <== Windows

CS320 - C Programming

avoiding multiple include
Avoiding Multiple #include
  • Nesting of #include’s within #includes could be problematic
  • Example:

myheader.h:

#ifndef MYHEADER_H

#define MYHEADER_H

#endif

CS320 - C Programming

macros vs functions
Macros vs. Functions
  • Macros increase program size for the benefit of speed
  • Macro has no type checking

#define mymaco(a) (a = a + 1)

  • Argument side affects can occur

#define mymaco(a) (a = a + 1)

int idx = 1; jdx = mymacro(idx);

  • Note caution on macros - pp178-178

CS320 - C Programming

recursion
Recursion
  • Programming concept - function calls itself either directly or indirectly
  • Useful for solving a specific problem domain - problem solved by combining results of subproblem.
  • Can be solved with looping algorithm

CS320 - C Programming

recursion algorithm
Recursion Algorithm
  • Need a way of end recursion
  • Binary search - find value in sorted list
  • Begin in middle of list
  • If middle of list search value is > middle value, search upper half of list else search bottom half of list.

CS320 - C Programming

recursion algorithm cont
Recursion Algorithm (cont.)

int search(int search_value,int list[], int first, int last) {

int middle = first + ((last - first) / 2 );

if (search_value == list[middle])

return search_value; /* found it! */

else if (middle == first)

return -1; /* not in list */

else { /* keep searching */

if (search_value > list[middle])

search(search_value,list,middle,last);

else search(search_value,list,first,middle);

}

CS320 - C Programming

varargs functions
Varargs Functions
  • Writing function with variable # of args.
  • How to:
    • #include <stdarg.h>
    • function_name(required_args,…);
    • va_list arg_ptr;
    • va_start(arg_ptr,last_required_arg);
    • data_type variable = va_arg(arg_ptr,data_type);
    • va_end(arg_ptr);

CS320 - C Programming

workshop 6 topics
Workshop 6 Topics
  • arrays
  • string library

CS320 - C Programming

arrays
Arrays
  • A set of contiguous data of the same data type
  • C has zero based arrays
  • Example:

int ages[2], temp;

ages[0] = 10;

ages[1] = 47;

ages[2] = 21; /* error */

temp = ages[1];

CS320 - C Programming

arrays cont
Arrays (cont.)
  • Good practice to use a constant to define the array’s size
  • Example:

#define MAX_AGE 2

int ages[MAX_AGE], idx;

for (idx = 0; idx < MAX_AGE; idx++)

printf(“ages[%d]=%d\n”,idx,ages[idx]);

CS320 - C Programming

array initialization
Array Initialization
  • Examples:

#define MAX_AGE 4

example 1) int ages[MAX_AGE] = { 10, 47, 21, 78 };

example 2) int ages[9] = { 10, 47, 21, 78 };

example 3) int ages[] = { 10, 47, 21, 78 };

  • May need to define the array as static
  • Examples:

static int ages[] = { 99, 34, 2, 8, 19, 10 };

CS320 - C Programming

arrays and pointers
Arrays and Pointers
  • A pointer is name for an address in memory.
  • C keeps track of all arrays by a pointer to the first element in the array.
  • It is the program’s responsibility to keep track of the length of the array.
  • The & operator gives the address of a variable.

CS320 - C Programming

arrays and pointers cont
Arrays and Pointers (cont.)
  • Example:

#define MAX_AGE 4

int ages[MAX_AGE] = {12, 69, 3, 34 };

int *ptr_to_ages; /* defines an integer pointer */

ptr_to_ages = &ages[0];

ptr_to_ages = ages; /*same as above */

ptr_to_ages = &ages[3];

ages = ptr_to_ages; /* error - ages is a constant pointer */

&ages[1] == ages + 1 /* true */

CS320 - C Programming

sizeof operator73
sizeof Operator
  • sizeof on an array determines the number of bytes in the array

#define MAX_AGE 6

int ages[MAX_AGE];

printf(“sizeof(ages) = %d\n”,sizeof(ages));

  • To get the total memory used by the array use sizeof operator:

printf(“ages size = %d\n”,sizeof(ages));

CS320 - C Programming

strings
Strings
  • C doesn’t directly support a data type of string
  • Strings are null (‘\0’) terminated arrays of characters
  • Example:

char *schoolPtr = “Regis”;

char school[6] ; /* Why six ? */

school[0] = ‘R’; school[1] = ‘e’; school[2] = ‘g’; school[3] = ‘i’;

school[4] = ‘s’; school[5] = ‘\0’; /* end with null char */

CS320 - C Programming

strings and i o
Strings and I/O
  • Must account for null terminator
  • Scanf Example:

char school[6];

scanf(“%s”,school); /* input must be <= 5 chars*/

  • Why didn’t above example have &school?
  • printf Example:

char school[6] = “Regis”;

printf(“%s”,school);

CS320 - C Programming

arrays as function args
Arrays as Function Args
  • Arrays are passed to function by passing address of first element of array
  • Example:

int myfunc1(int array[]);

int myfunc2(int *array);

int ages[5] = { 1, 5, 37, 18, 19 };

myfunc1(ages);

myfunc2(ages);

myfunc2(&ages[0]);

CS320 - C Programming

string library
String Library
  • Set of functions that perform various string manipulations
  • strcat, strncat - concatinate two strings
  • strcmp, strncmp - compare two strings
  • strcpy, strncpy - copy one string to an array
  • strlen - returns length of a string
  • strstr, strchr, strrchr - seach for string or char in a string

CS320 - C Programming

string library strcat
String Library - strcat
  • include <string.h>
  • strcat Example:

char str[20] = “Hello”;

strcat(str,” World!”); /* str == “Hello World!” */

  • strncat Example:

char str[20] = “Hello”;

strncat(str,” World!”,3); /* str == “Hello Wo” */

CS320 - C Programming

string library strcmp
String Library - strcmp
  • strcmp/strncmp returns 0 if strings are identical or +/- lexicographical difference
  • strcmp Example:

int ret = strcmp(“Hello”,”World”); /* ret < 0 */

  • strncmp Example:

int ret = strncmp(“Hello”,”Help”,3); /* ret == 0 */

CS320 - C Programming

string library strcpy
String Library - strcpy
  • strcpy Example:

char str1[20] = “Hello”, str2[20];

strcpy(str2,str1); /* str2 == “Hello” */

  • strncpy Example:

char str1[20] = “Hello”, str2[20];

strncpy(str2,str1,3); /* str2 == “Hel” */

  • strncpy may not null terminate target string

CS320 - C Programming

string library cont
String Library (cont.)
  • strlen returns integer length of string, not including null character
  • strlen Example:

int ret = strlen(“Hello World!”); /* ret == 12 */

  • strstr, strchr, strrchr

CS320 - C Programming

multidimensional array
Multidimensional Array
  • Indicated by additional set of [].
  • C like Pascal is row major
  • Example:

int ages[2][3]; / * 2 rows with 3 columns each */

  • Initialization:

int ages[2][3] = {{ 5, 3, 8}, { 17, 19, 14}};

  • As function argument:

int myfunc(int array[][3]); /* must specify all but first size */

CS320 - C Programming

workshop 7 topics
Workshop 7 Topics
  • pointers
  • pointers and arrays
  • pointer arithmetic
  • command line arguments
  • pointers to functions

CS320 - C Programming

pointers
Pointers
  • A pointer is a variable that contains a memory address
  • Typically, a pointer contains the address of a variable
  • Addressing operator (&) calculates the address a its operand.

&x /* expression value == address of x */

CS320 - C Programming

declaring pointers
Declaring Pointers
  • Declaring a pointer

int *iPtr;

float *fPtr;

    • iptr is a pointer to an integer
    • fptr is a pointer to a float
    • white space between int, *, and pointer name is a matter of style.
  • Watch out for int *ptr1, ptr2; * binds to pointer not data type

CS320 - C Programming

putting it together
Putting it together
  • Declaring and initializing pointers:

int idx = 100;

int *ptr = &idx;

OR

ptr = &idx;

  • Derefferencing - accessing memory pointed to by a pointer (*)

*ptr == 100 /* is true */

*ptr = 99; /* assigns 99 to int pointed to by ptr */

CS320 - C Programming

miscellaneous
Miscellaneous
  • void * is a known as a void pointer
  • useful when data type of memory is not important: Example memcpy() pg 776-777
  • Can’t take address of constants and expressions
  • Review example 6.1.5 on pg 312
  • Review exercises on pg 315 # 1-14

CS320 - C Programming

pointer to pointer
Pointer to Pointer
  • Pointers can refer to other pointers

int x = 100;

int *iPtr, **pPtr;

iPtr = &x;

pPtr = &iPtr;

  • Typically only use up to double pointers
  • Necessary for functions that manipulate what a pointer points at.
  • Exercises on pg 320 # 1-11

CS320 - C Programming

pointers and arrays
Pointers and Arrays
  • C refers to arrays as constant pointers
  • Consider:

char str1[10];

char *ptr = &str1[0];

str1 = ptr; /* illegal because str1 is a const */

ptr = str1; /* ok - same as ptr = &str1[0] */

char str2[] = “Hello World!”; /* str2 is an array */

ptr = “Hello World!”; /* ptr is a pointer */

CS320 - C Programming

pointer initialization
Pointer Initialization
  • Pointers refer to a valid address, null, or garbage

char *ptr; /* globals and statics initialized to null */

main()

{

int x = 98;

int *iPtr1; /* uninitialized locals contain garbage */

int *iPtr2 = &x;

}

CS320 - C Programming

pointer initialization cont
Pointer Initialization (cont.)
  • Pointers must point to valid address before using.

char *ptr; /* ptr is a local variable */

scanf(“%s”,ptr); /* BIG PROBLEM */

TO FIX

char array[20];

char *ptr = array;

scanf(“%s”,ptr); /* or scanf(“%s”,array); */

  • WARNING: pg 324 - taking array address

CS320 - C Programming

pointer arithmetic
Pointer Arithmetic
  • Manipulate pointer through arithmetic operations
  • Example:

char array[] = “Hello World!”, *ptr = array;

ptr++; /* move pointer to address of ‘e’ */

ptr--; /* move pointer to address of ‘H’ */

*ptr++ = getchar(); /* puts input char over ‘H’, moves ptr to ‘e’ */

  • Exercises on pg 337 # 1 - 19

CS320 - C Programming

pointer arguments to functions
Pointer Arguments to Functions
  • Used to simulate call by reference
  • Example 1:

int month = 2;

func(&month);

void func(int *m) {

int x = 10;

*m = 4;

m = &x;

}

CS320 - C Programming

pointer arguments to functions cont
Pointer Arguments to Functions (cont.)
  • Example 2:

int month1 = 2;

int month2 = 14;

int *mPtr = &month1;

func(&mPtr);

void func(int **m) {

*m = &month2;

}

  • Exercises on pg 349 # 1-10

CS320 - C Programming

command line arguments
Command Line Arguments
  • How a C program receives run time command line arguments.
  • Syntax:

main (int argc, char *argv[])

  • How to parse command line arguments
    • See getopt()

CS320 - C Programming

pointers to functions
Pointers to Functions
  • C treats function names as a constant pointer
  • function pointer must include functions return type and argument type(s)
  • To declare a function pointer

int (*pFunc)(int, char, char *);

/* pFunc is a pointer to a function that returns an int and has an int, char, and char pointer as arguments */

CS320 - C Programming

pointers to functions cont
Pointers to Functions (cont.)
  • Examples:

int *pFunc(int, char, char *);

/* with out parenthesis pFunc is a function that returns

a pointer to an int … */

  • To call the function:

#include <string.h>

int (*pFunc)(const char *, const char *);

pFunc = strcmp;

int ret = (*pFunc)(“Hello”,”Help”);

/* OR */ ret = pFunc(“Hello”,”Help”);

  • See qsort for an example

CS320 - C Programming

workshop 8 topics
Workshop 8 Topics
  • Storage classes
  • Type qualifiers

CS320 - C Programming

storage classes
Storage Classes
  • Determines where the memory is allocated and how long it remains in existance
  • location: data or stack segment
  • existance: process, containing block
  • containing block code bounded by braces {}
  • storage classes: auto, extern, static

CS320 - C Programming

auto storage class
auto Storage Class
  • Default storage class for variables declared in the body of a function
  • Memory automatically release on exit from control block
  • Example:

main() {

int age;

auto int idx;

}

CS320 - C Programming

extern storage class
extern Storage Class
  • Default storage class for variables defined outside a function body.
  • Memory allocated for the life of process
  • Initialized to zero or initial value.
  • Visable to functions that follow definition
  • Example:

int age;

main() {...}

CS320 - C Programming

static storage class
static Storage Class
  • Memory allocated for the life of the process
  • Initialized to zero or initial value.
  • Visable to containing block
  • Maintains value over invocations
  • Example:

myfunc() {

static int age;

}

CS320 - C Programming

register storage class
register Storage Class
  • Compiler recommendation use CPU register
  • otherwise set to auto
  • can only be part of control block
  • cannot determine address of variable
  • Example:

myfunc() {

register int age;

}

CS320 - C Programming

storage class multiple source files
Storage Class - Multiple Source Files
  • use extern and static to control visability as forward reference and across files
  • Example:

---------- main.c ------------

main() {

extern int count;

}

int count;

CS320 - C Programming

storage class multiple source files cont
Storage Class - Multiple Source Files (cont.)
  • Example (cont.):

----------- myfunc.c --------

extern int count;

myfunc() {

count++;

}

CS320 - C Programming

storage classes for functions
Storage Classes for Functions
  • Must be extern or static
  • Default for function is extern
  • static limits visability of function to those functions in the same file that follow definition

CS320 - C Programming

type qualifiers
Type Qualifiers
  • Arrays are passed to function by passing address of first element of array
  • const - cannot be lvalue of an assignment
  • volatile - can be modifed by another process
  • volatile const - can only be modified by another process
  • const-ness can be casted away

CS320 - C Programming

const and pointers
const and pointers
  • const char *ptr - what ptr points at cannot be changed

*ptr = ‘z’; /* compile error */

ptr = “hello”; /* ok */

  • char * const ptr - what ptr cannot be changed

*ptr = ‘z’; /* ok */

ptr = “hello”; /* compile error */

  • Explain arguments to strcmp, strcpy, strlen

CS320 - C Programming

workshop 9 topics
Workshop 9 Topics
  • structures
  • typedef
  • unions
  • bit fields
  • enumerated types
  • dynamic memory

CS320 - C Programming

structures
Structures
  • An aggregate, user defined data type used to represent non-simple, abstract data
  • Example:

struct person {

char name[50];

char dob[11]; /* mm/dd/yyyy */

int height; /* in inches */

int weight; /* in lbs. */

};

struct person aPerson;

CS320 - C Programming

structures cont
Structures (cont.)
  • Array of structures

struct person team[20];

  • Use the ‘.’ operator to reference a structures member

printf(“aPerson name = %s\n”,aPerson.name);

printf(“aPerson height = %d\n”,aPerson.height);

strcpy(aPerson.name,”Skippy”);

aPerson.height = 70;

strcpy(team[0].name,”Bozo the Clown”);

CS320 - C Programming

structures cont112
Structures (cont.)
  • Tag is not required, but must include definition

struct {

char name[50];

char dob[11];

} aPerson;

  • member name is unique within structure
  • sizeof structure includes sizeof members + boundary alignment

CS320 - C Programming

initializing structures
Initializing Structures
  • Initialization similar to arrays:

struct person aPerson = {“Bozo the Clown”, “11/31/1955”,

170, 72};

struct person team[] = {{“Tom”, “1/3/1985”, 70, 48},

{“Sally”, “12/15/1984”, 65, 49},

…};

  • Assignment operator (=) and deep vs. shallow copy:

struct person anotherPerson;

anotherPerson = aPerson;

CS320 - C Programming

pointers to structures
Pointers to Structures
  • Declaring and initializing a pointer to a structure

struct person aPerson;

struct person *personPtr = & aPerson;

(*personPtr).height = 72; /* ok */

personPtr->height = 72; /* typical / preferred */

  • Points to the address of the first byte of the structure (1st byte of the 1st member)

CS320 - C Programming

nested structures
Nested Structures
  • Example:

struct address {

char street[100];

char city[30];

char state[3];

char zip[10];

};

struct person {

char name[50];

...

struct address pAddress;

} aPerson;

printf(“Person street: %s\n”,aPerson.pAddress.street);

CS320 - C Programming

self referencing structures
Self-referencing Structures
  • Can only include a pointer to itself, tag is required.

struct person {

char name[50];

...

struct person *heir;

} aPerson, theHeir;

aPerson.heir = &theHeir;

printf(“Person name = %s\n”,aPerson.name);

printf(“Person\’s heir\’s name = %s\n”,aPerson.heir->name);

CS320 - C Programming

structures as arguments
Structures as Arguments
  • Entire structure is copied:

int func(struct person aPerson);

struct person bob;

int ret = func(bob);

  • Typically passed by pointer:

int func(struct person *aPerson);

struct person bob;

int ret = func(&bob);

CS320 - C Programming

const structures
const Structures
  • All members are constant
  • Example:

const struct person aPerson = { … };

aPerson.name[0] = ‘A’; /* Error */

aPerson.height = 68; /* Error */

  • What about pointer data members?

struct person newHeir;

aPerson.heir = &newHeir;

aPerson.heir->name[0] = ‘A’;

aPerson.heir->height = 72;

CS320 - C Programming

typedef
typedef
  • User defined datatypes, based on existing data type
  • Examples:

typedef int Years;

Years age = 57;

typedef struct person Person;

Person bob = {“Bob”, “12/05/1974”, 72, 210};

CS320 - C Programming

typedef cont
typedef (cont.)
  • Short hand notation for structure definition:

typedef struct {

char name[50];

char dob[11]; /* mm/dd/yyyy */

int height; /* in inches */

int weight; /* in lbs. */

} Person;

Person bob = { … };

CS320 - C Programming

union
Union
  • Holds a single members data to the exclusion of other members

typedef struct { int x, y; int diam; } Circle;

typedef struct { int x1, y1, x2, y2; } Line;

union shape { Circle c; Line l; };

typedef struct {

int type; /* 0 - circle, 1 - line, etc. */

union shape s;

} Shape;

Shape myshape;

myshape.type = 0;

myshape.s.x = 0; myshape.s.y = 0; myshape.s.diam = 10;

CS320 - C Programming

bit fields
Bit Fields
  • Alternative to bitwise operators
  • Cannot take address of field (member) cannot reference field via pointer
  • Example:

typedef struct {

unsigned int debug : 1;

unsigned int options : 4;

unsigned int field3 : 3;

} Flags;

Flags f;

f.debug = 1;

CS320 - C Programming

enumerated types
Enumerated Types
  • Data type with user specified values.

enum shape_kind { Circle, Line, Square, Triangle };

typedef struct {

shape_kind type;

union shape s;

} Shape;

Shape myshape;

myshape.type = Circle;

  • Optional - specify enum value (default is 0).

typedef enum { January = 1, February, ... } Month;

CS320 - C Programming

dynamic memory
Dynamic Memory
  • All variables, const, etc. are allocated by compile, link, load time environment.
  • Dynamic memory is run-time allocated memory
  • Allocated from the heap
  • malloc(), calloc(), and free() in stdlib.h

CS320 - C Programming

malloc
malloc
  • Returns a (void *) to address of allocated memory
  • null is return on failure
  • Request amount of memory in bytes
  • Like auto, memory is not initialized
  • Examples:

int *ptr = malloc(sizeof(int));

*ptr = 10;

char *string = malloc(sizeof(char) * 50);

strcpy(string,”Hello World!”);

CS320 - C Programming

calloc
calloc
  • Typically used to allocate arrays
  • memory is initialized to 0
  • Example:

char *string = calloc(50,sizeof(char));

strcpy(string,”Hello World!”);

CS320 - C Programming

slide127
free
  • Program’s responsibility to keep track of first byte of allocated memory
  • Program’s responsibility to release dynamic memory when memory is no longer needed
  • Example:

char *string = malloc(sizeof(char), 50);

free(string);

CS320 - C Programming

linked lists
Linked Lists
  • Putting it together: structures and dynamic memory allocation
  • Example pg 579:

typedef struct elephant {

char name[20];

struct elephant *next;

} Elephant;

CS320 - C Programming

workshop 10 topics
Workshop 10 Topics
  • I/O

CS320 - C Programming

opening closing files
Opening & Closing Files
  • #include <stdio.h>
  • FILE *fp
  • fp = fopen(“file_name”,mode), null on error
  • modes (“r”, “r+”, etc.)
  • fclose(fp)
  • already open, stdin, stdout, stderr

CS320 - C Programming

character i o
Character I/O
  • Fgetc(FILE *), getc(FILE *), getchar()
  • Fputc(char, FILE *), putc(char, FILE *), putchar(int)
  • Example:

FILE *fp = fopen(“myfile.txt”,”w+”);

int c;

if (fp == NULL) return; /* error opening */

while ((c = getchar()) != EOF)

fputc(c,fp);

fclose(fp);

CS320 - C Programming

string i o
String I/O
  • Fgets(char *, int, FILE*), gets(char *)
  • Fputs(char *,FILE *), puts(char *)
  • gets and puts remove or add newline char
  • Example:

FILE *fp = fopen(“myfile.txt”,”w+”);

char buf[512];

if (fp == NULL) return; /* error opening */

while (fgets(buf,sizeof(buf),stdin) != NULL)

fputs(buf,fp);

fclose(fp);

CS320 - C Programming

character conversions
Character Conversions
  • #include <ctype.h>
  • toupper(char), tolower(char), isalpha(char), isdigit(char), isalnum(char), ...

CS320 - C Programming

binary i o
Binary I/O
  • Fread(void *, size_t size, size_t count, FILE*), fwrite(const void *, ...
  • read(int fd, char *buf, int size) and write(int fd, char *buf, int size) system calls
  • No formatting of data occurs, data written as is in memory
  • Example:

fwrite((void *)stdout, sizeof(FILE), 1, stdout);

write(1,(char *)stdout,sizeof(FILE));

CS320 - C Programming

positioning in a file
Positioning in a File
  • Int fseek(FILE *,long offset,int base), long ftell(FILE *), void rewind(FILE *)
  • base one of (SEEK_SET, SEEK_CUR, SEEK_END)
  • Example:

/* read bob record from fp, bob is 10th person in file */

struct person bob;

fseek(fp, sizeof(struct person) * 9, SEEK_SET);

fread((void *)&bob, sizeof(bob), 1, fp);

CS320 - C Programming