the c language – brief tutorial
DESCRIPTION
The C Language – Brief Tutorial. Prof. Steven A. Demurjian Computer Science & Engineering Department The University of Connecticut 371 Fairfield Road, Box U-2155 Storrs, CT 06269-2155. [email protected] http://www.engr.uconn.edu/~steve (860) 486 – 4818 (860) 486 – 3719 (office). - PowerPoint PPT PresentationTRANSCRIPT
CLang.1
CSE230
The C Language – Brief Tutorial The C Language – Brief Tutorial
Prof. Steven A. DemurjianComputer Science & Engineering Department
The University of Connecticut371 Fairfield Road, Box U-2155
Storrs, CT 06269-2155
www.engr.uconn.edu/~steve
(860) 486 – 4818(860) 486 – 3719
(office)
CLang.2
CSE230
Word Count Program Word Count Program Using argc/argvUsing argc/argv
#include <stdio.h>main(argc,argv)int argc;char *argv[];{ int lines[10], words[10], chars[10]; int i, tot_lines=0, tot_words=0, tot_chars=0; /* Need error checks here */ for (i=0; i<(argc-1); i++) { lines[i] = count_lines(argv[i+1]); words[i] = count_words(argv[i+1]); chars[i] = count_chars(argv[i+1]); }
for (i=0; i<(argc-1); i++) { tot_lines += lines[i]; tot_words += words[i]; tot_chars += chars[i]; } printf(" **********The Results ****************\n"); /* Both Individual and Total results */ for (i=0; i<(argc-1); i++) { printf("%10d%10d%10d%20s\n", lines[i], words[i], chars[i], argv[i+1]); } printf("Totals for the Input are:\n"); printf("Lines: %10d\nWords: %10d\nChars: %10d\n", tot_lines, tot_words, tot_chars); }
CLang.3
CSE230
Word Count Program Word Count Program Associated FunctionsAssociated Functions
int count_lines(f_name) char f_name[];{ FILE *fp; char c; int num_lines=0; fp = fopen(f_name, "r");
while ((c=getc(fp)) != EOF) { while (c != '\n') c = getc(fp); num_lines++; } fclose(fp); return(num_lines);}int count_chars(f_name) char f_name[];{ /* Characters include any character except for the newline at the end of a line and EOF*/}int count_words(f_name) char f_name[];{ /* Words are separated by blanks and newline at the end */}
CLang.4
CSE230
Word Count Program Word Count Program Alternate Function DefinitionAlternate Function Definition
/* Note the use of char *f_name */
int count_lines(char *f_name){ FILE *fp; char c; int num_lines=0; fp = fopen(f_name, "r");
while ((c=getc(fp)) != EOF) { while (c != '\n') c = getc(fp); num_lines++; } fclose(fp); return(num_lines);}
int count_chars(char *f_name){ /* Characters include any character except for the newline at the end of a line and EOF*/}
int count_words(char *f_name){ /* Words are separated by blanks and newline at the end */}
CLang.5
CSE230
Example Using Pointers and Example Using Pointers and DereferencesDereferences
int i=3, j=4;int *k; /* pointer to integer - holds address */
k= &(j); /* holds the address of j */
printf("%d", *k); /* print j's address */
k= &(i); /* holds the address of i */
*k+=j; /* increment k's address by value of j */
printf("%d %d %d\n", i, j, k); /* what prints? */
CLang.6
CSE230
Call by Reference using PointersCall by Reference using Pointers
C Only Allows Pass-by-Value C Only Allows Pass-by-Value Using Pointers Facilitates Pass-by-RefUsing Pointers Facilitates Pass-by-Ref
Can’t change the Pointer Value Change What Pointer References
Consider Swap BelowConsider Swap Below
main(){int x=5, y=10;swap(x,y);}/*Does this Work?*/
swap(x,y)int x;int y;{ int temp; temp = x; x = y; y = temp;}
/* A Better Swap! */main(){int x=5, y=10;swap(&x, &y);}
swap(x,y)int *x;int *y;{ int temp; temp = *x; *x = *y; *y = temp;}
CLang.7
CSE230
Call by Reference using PointersCall by Reference using Pointers
If you want to Swap the Value of the If you want to Swap the Value of the Pointer (addresses) Pointer (addresses) Use Pointers to Pointers Change What Pointer Points To In this Case, an Address
main(){int i=1 j=2;int *r, *s;r = &i; s=&j;printf(“BEFORE: %d %d\n”,r,s);swap_addr(&x, &y);printf(“AFTER: %d %d\n”,r,s);}
swap_addr(x,y)int **x;int **y;{ int *temp; temp = *x; *x = *y; *y = temp;}
1i 4000
2j 4004
4000r 4008
4004s 4012
CLang.8
CSE230
Pointers and Count LinesPointers and Count Lines
Revisit Count_LinesRevisit Count_Lines Change to Return Value in ParameterChange to Return Value in Parameter Function now Returns VoidFunction now Returns Void
void count_lines(f_name, num_lines)char f_name[];int *num_lines;{ FILE *fp; char c; *num_lines = 0; fp = fopen(f_name, "r");
while ((c=getc(fp)) != EOF) { while (c != '\n') c = getc(fp); *num_lines = *num_lines+1; } fclose(fp);}
Function invocation: count_lines(argv[i+1], &lines[i]);
CLang.9
CSE230
Correlating Pointers and ArraysCorrelating Pointers and Arrays
An Array Name is a Fixed AddressAn Array Name is a Fixed Addressint a[100];int *p;
a[0], a[1], a[2], . . . a[99] have Addresses4000, 4004, 4008, . . .
Valid Assignments Include:
p = &(a[1]); p = &(a[i]); p = &a; Equivalent to: p = &(a[0]);
If p = &(a[1]);
What Does p++; Do?
p = &a;
What Does p = p+4 Do?
CLang.10
CSE230
Basic Concepts for StringsBasic Concepts for Strings
String Processing in C is Achieved via String Processing in C is Achieved via Character ArraysCharacter Arrays
Strings Terminate with ‘\0’Strings Terminate with ‘\0’
#include <stdio.h>main(){ char b[]=“hello”; char *c =“goodbye”;
printf(“BEFORE: %s %s\n”, b, c);
/* Using b – putchar works from stdin */ for (i=0; putchar(b[i]) !=‘\0’; i++) ;
/* Using c – putchar works from stdin */ for (i=0; putchar(*(c+i)) !=‘\0’; i++) ; printf(“AFTER: %s %s\n”, b, c);
}
CLang.11
CSE230
Passing Strings as ParametersPassing Strings as Parameters
#include <stdio.h>main(){ char str1[]=“steve”; char str2[]=“”;
printf(“BEFORE: %s %s\n”, str1, str2); copy(str1, str2);
printf(“AFTER: %s %s\n”, str1, str2);}
copy(src, dst)char src[], dst[];{int i=0;
while( (dst[i] = src[i]) != ‘\0’) i++;}
CLang.12
CSE230
Three Other Versions of CopyThree Other Versions of Copy
copy(src, dst)char src[], dst[];{int i;
for( i=0; (dst[i] = src[i]) != ‘\0’; i++) ;}
copy(src, dst)char *src, *dst;{for( ; (*dst = *src) != ‘\0’; dst++, src++) ;}
copy(src, dst)char *src, *dst;{for( ; (*dst++ = *src++) != ‘\0’; ) ;}
CLang.13
CSE230
String Functions in CString Functions in C
Defined in #include <strings.h>Defined in #include <strings.h> Integer Returning Functions:Integer Returning Functions:
Pointer Returning FunctionsPointer Returning Functions
strcmp(s1,s2); 0:equal, s1<s2:neg, s1>s2:posstrncmp(s1,s2,n); compare first n charsstrlen(s1); returns length without \0
strcat(s1,s2); adds s2 to s1strncat(s1,s2,n); add first n chars:s2 to s1strcpy(s1, s2); copy s1 to s2strncpy(s1,s2,n); copy first n chars
char *strcat(s1,s2)register char *s1, *s2;{ register char *p; p = s1; while (*p++ != ‘\0’) ; --p; while( (*p++ = *s2++) != ‘\0’) ; return(s1);}
CLang.14
CSE230
StructuresStructures
Structures in C are the Predecessors of Structures in C are the Predecessors of ClassesClasses Allow Named Groupings Passed as Parameters
What are some Examples?What are some Examples?
struct card { int pips; /* value of 1 to 13 */ char suit; /* s, h, d, c */};
struct card c1, c2;
struct card deck[52];
c1.pips = 12;c1.suit = ‘s’;
deck[i].pips = j;
typedef struct card card;
card c1, c2, c3;
CLang.15
CSE230
Structures – More ExamplesStructures – More Examples
/* The following is in a file “class.h” */ #define CLASS_SIZE 100typedef struct{ char *last_name; int student_id; char grade;} student;
/* The following is in a file “main.c” */
#include “class.h”
main(){student temp, class[CLASS_SIZE];. . .temp.grade = ‘A’;temp.last_name = “smith”;temp.student_id = 999999;. . ./* How Many Failed the class? */printf( “Failed: %d\n”, fail(class));. . . }/* What is fail? */
CLang.16
CSE230
Structures – More ExamplesStructures – More Examples
/* The following is in a file “class.c” */ /* This file contains functions defined *//* on the class structure. We can mimic *//* an ADT/class, even if we can’t have *//* the C language enforce the concepts. */
#include “class.h”
/* This function counts failing grades */
int fail( student class[ ]){ int i, cnt = 0;
for (i=0; i < CLASS_SIZE; i++); cnt += class[i].grade == ‘F’; return cnt;}
CLang.17
CSE230
Structures – A Poker ExampleStructures – A Poker Example
#include <stdio.h>#include <stdlib.h>#include <time.h>
#define NDEALS 3000 /* No. of Deals */#define NPLAYERS 6 /* No. of Players */
typedef enum {clubs, diamonds, hearts, spades} cdhs;
typedef struct{ int pips; /* value of 1 to 13 */ cdhs suit; /* s, h, d, c */} card;
/* Now Define the function prototypes *//* These define names used in code for *//* compile to be successful */
card assign_values(int pips, cdhs suit);void prn_card(card *c_ptr);void play_poker(card deck[52]);void shuffle(card deck[52]);void swap(card *p, card *q);void deal_the__cards(card deck[52], card hand[NPLAYERS][5]);int is_flush(card h[5]);
CLang.18
CSE230
Structures – A Poker ExampleStructures – A Poker Example
main(){ cdhs suit; int i, pips; card deck[52]; for (i=0; i<52; ++i){ pips = i % 13 + 1; if (i < 13) suit = clubs; else if (i < 26) suit = diamonds; else if (i < 39) suit = hearts; else suit = spades; deck[i]=assign_values(pips, suit); } /* Now Print out the hearts */ for (i=26; i<39; ++i) prn_card_values(&deck[i]);
/* Now start the game */ play_poker(deck);}
card assign_values(int pips, cdhs suit){ card c; c.pips = pips; c.suit = suit; return c;}
CLang.19
CSE230
Poker – Other FunctionsPoker – Other Functions
void play_poker(card deck[52]){ int flush_cnt=0, hand_cnt=0; int i, j; card hand[NPLAYERS][5]; /*Two-D Array */
srand(time(NULL)); /*seed random gen */ for(i=0; i < NDEALS; ++i) { shuffle(deck); deal_the_cards(deck, hand) for(j=0; j < NPLAYERS; ++j) { ++hnd_cnt; if (is_flush(hand[j])) { ++flush_cnt; printf(“ LOTS OF STUFF ON THE HAND AND PROBABILITY OF FLUSH”); } } }}
CLang.20
CSE230
Poker – Other FunctionsPoker – Other Functions
void shuffle(card deck[52]){ int j,k; for(j=0, j < 52; ++j) { k = rand() % 52; swap(&deck[j], &deck[k]); }}
void swap(card *p, card *q){ card temp; temp = *P; *p = *q; *q = temp;}
int is_flush (card h[5]){ int i; for(i = 1; i < 5; ++i) if (h[i].suit != h[0].suit) return 0; return 1;}
CLang.21
CSE230
Lists and Memory AllocationLists and Memory Allocation
Structures can be Leveraged to Create Structures can be Leveraged to Create Lists of Self-Referential DataLists of Self-Referential Data Students in a Class Cards in a Poker Hand
Consider a Hand as FollowsConsider a Hand as Follows
As Defined, Hand can have Multiple As Defined, Hand can have Multiple Cards (in fact, one or More)Cards (in fact, one or More) Structure General Poker, Blackjack, Bridge, etc.
typedef struct{ int pips; cdhs suit; cards *next_card; } cards;
CLang.22
CSE230
Lists and Memory AllocationLists and Memory Allocation
typedef struct{ int pips; cdhs suit; cards *next_card; } cards;
/* Using Structures and Pointers */cards hand;cards c1, c2, c3, c4;
/* Four aces */c1.pips = c2.pips = c3.pips = c4.pips = 1;c1.cdhs = clubs; c2.cdhs = diamonds;c3.cdhs = hearts; c4.cdhs = spades;c1.next_card = c2.next_card = NULL;c3.next_card = c4.next_card = NULL;
/* Now, build a hand */hand.pips = 10;hand.suit = hearts;hand.next_card = &c1;c1.next_card = &c2;c2.next_card = &c3;c3.next_card = &c4;c4.next_card = &c5;
CLang.23
CSE230
Lists and Memory AllocationLists and Memory Allocation
#include <stdio.h> #include <string.h> /* String Functions */#include <stdlib.h> /* Malloc Routines */
#define MAX_CHARS 256
typedef struct { char line[MAX_CHARS+1]; int line_no; struct line_list *next_line; struct line_list *prev_line;} line_list;
typedef struct { char f_name[MAX_CHARS+1]; struct line_list *f_lines; struct input_file *next_file;} input_file;
Example as Given is Very LimitedExample as Given is Very Limited Requires Know Ahead of TimeRequires Know Ahead of Time
Number of Elements in List How you Want to Connect Them
We’ll use a Word Count Version as We’ll use a Word Count Version as Example for These ConceptsExample for These Concepts
CLang.24
CSE230
Word Count - ContinuedWord Count - Continued
main(argc,argv)int argc;char *argv[];{input_file *head, *next, *hold;line_list *aline, *bline;
/* Create head to point to input_file */head = (struct input_file *) malloc(sizeof(struct input_file));/* Copy in argv[0] - this is program name */strcpy(head->f_name, argv[0]);head->next_file = NULL;
/* Create next to point to input_file */next = (struct input_file *) malloc(sizeof(struct input_file));/* Copy in argv[1] - this is input file*/strcpy(next->f_name, argv[1]);next->next_file = NULL;
/* Print out both file names */printf("Files: %s %s \n",head->f_name, next->f_name);
/* Link head to next and increment*/hold = head; /* keep head of list */head->next_file = next;head=head->next_file;/* Now, what prints? */printf("%s \n",head->f_name);head = hold; /* restore head of list */
CLang.25
CSE230
Word Count - ContinuedWord Count - Continued
/* Now alloc and initialize two lines */aline = (struct line_list *) malloc(sizeof(struct line_list));strcpy(aline->line, "Hello World");printf("Line A is: %s \n",aline->line);aline->next_line = aline->prev_line = NULL;aline->line_no=1;
bline = (struct line_list *) malloc(sizeof(struct line_list));strcpy(bline->line, "Goodbye World");bline->next_line = bline->prev_line = NULL;bline->line_no=1;
printf("Line B is: %s \n", bline->line);
/* Now, link lines to files */head->f_lines = aline;next->f_lines = bline;
/* Work with references and permuted_index structures in a similar manner! */}
CLang.26
CSE230
All Structures for Project - .h FileAll Structures for Project - .h File
/* The File p1pbhdr.h */
#define MAX_CHARS 256
/* The line_list structure contains, for each line, the line itself (256 characters - max in Unix), a integer line_no, and pointers to the next line (next_line) and previous line (prev_line). */
typedef struct { char line[MAX_CHARS+1]; /* Allow for end of string */ int line_no; struct line_list *next_line; struct line_list *prev_line;} line_list;
/* The input_file structure contains, for each file, the name of the file as read from argv (f_name), a pointer to the list of lines (f_lines), and a pointer to the next file (next_file). */
typedef struct { char f_name[MAX_CHARS+1]; struct line_list *f_lines; struct input_file *next_file;} input_file;
CLang.27
CSE230
All Structures for Project - .h FileAll Structures for Project - .h File
/* The File p1pbhdr.h */
/* The references structure tracks, for each word in the permuted index, the list of (file,line) pairs. It does so by having a link to the input_file entry (file_ptr) and the corresponding line of that file (line_ptr). The structure is self-referential with a next_ref pointer to allow all of the references to the word in all (file, line) pairs to be tracked. */
typedef struct{ struct input_file *file_ptr; struct line_list *line_ptr; struct references *next_ref;} references;
/* The permuted_index structure tracks the list of all words that occur in all files. Each permuted index entry contain the word found (in some line), a list of indexes to that word (the index_list pointer to the references structure), and a pointer to the next word in the permuted index (next_word pointer). The words in this list must be kept in alphabetical order. This list is created by scanning every line of every file, as tracked in the input_file structure.*/
typedef struct{ char word[MAX_CHARS+1]; struct references *index_list; struct permuted_index *next_word;} permuted_index;
CLang.28
CSE230
Code for Project - .c FileCode for Project - .c File
/* The File p1pbcode.c */#include <stdio.h>#include <string.h>#include <stdlib.h>
#include “p1pbhdr.h”
main(argc,argv)int argc;char *argv[];{input_file *head, *next, *hold;line_list *aline, *bline;
/* Create head to point to input_file */head = (struct input_file *) malloc(sizeof(struct input_file));
/* Remainder as before . . . (see prior slide) */
/* Work with references and permuted_index structures in a similar manner! */}
CLang.29
CSE230
Project 1 – Part AProject 1 – Part A
Recall Word Count Program from Recall Word Count Program from Slides 2 and 3… You mustSlides 2 and 3… You must Code Missing Functions Compile on Eclipse C++ Test and Prepare Test Summary
Test Summary Document MustTest Summary Document Must Identify Test Cases and for each
List Purpose of Test List Input (input files) List Output (cntrl-alt-printscreen)
Create MS Word Document that is Professional, Structure, Organized
Code in zip file on Course Web PageCode in zip file on Course Web Page Due on Monday, Jan 23, 8am Due on Monday, Jan 23, 8am
(electronic submission only)(electronic submission only)int count_chars(f_name) char f_name[];{ /* COMPLETE AND TEST! */ }int count_words(f_name) char f_name[];{ /* COMPLETE AND TEST! */ }
CLang.30
CSE230
Project 1 – Part BProject 1 – Part B
Redo and Expand Word Count Prog. to Redo and Expand Word Count Prog. to Explore Dynamic Memory AllocationExplore Dynamic Memory Allocation Step 1: Store All File Names, and
Lines (max 256 char/line) in Linked List Structures input_file and line_list as reviewed
Step 2: Redo Part 1A (line, word, and char counts) using a Traversal of the Linked List Structure input_file and line_list
Step 3: Compute a Permuted Index (see the project description) Using other Linked List Structures references and permuted_index
Code in zip file on Course Web Page Code in zip file on Course Web Page Due on Wednesday, Feb 1, 8am Due on Wednesday, Feb 1, 8am
(electronic submission) and hard copy (electronic submission) and hard copy at start of Lab Sessionat start of Lab Session