Computer Programming I

UP ITTC
AY 2009-2010
Command-Line Arguments

Lesson 7
 Introduction
 Command-line arguments
 Command-line Arguments
 In environments that support C,
there is a way to pass command-line
arguments or parameters to a
program when it begins executing.

 When main is called, it is called with

two arguments.
 Command-line Arguments
 The first (conventionally called argc, for
argument count) is the number of
command-line arguments the program
was invoked with.

 The second (argv, for argument vector) is

a pointer to an array of character strings
that contain the arguments, one per
string.
 Command-line arguments
 Example:
/*program echo.c*/
int main( int argc, char* argv[] )
{
int i;
for( i = 1; i < argc; i++ ){
printf(“arg#%d = %s\n”, i, argv[i]);
}
}/*end of main*/
 Command-line arguments
 Calling the progam:
C:\ echo.out hello world

By convention, argv[0] is the name by which

the program was invoked, so argc is at least 1.
 Lesson Review
 You can pass data directly to your program
through the use of command-line arguments.
 The main method has the following
declaration, where argc holds the number of
arguments to the program and argv points to
an array of character strings which holds the
arguments.
int main( int argc, char* argv[] )
 Exercise 11
Write a program that outputs to
screen the number of times the
string “hello” was used as a
command-line argument in the
execution of the program.
Structures

Lesson 8
 Introduction
 Structures
 Declaring structures using typedef
 Pointers to Structures
 Structures
 A structure in C is a collection of one or more
variables, possibly of different types, grouped
together under a single name for convenient
handling. A structure is also called a record. The
syntax for declaring a structure is as follows:

struct <struct_type_name>
{
<data_type_1> <var_name_1>;
<data_type_2> <var_name_2>;
……
<data_type_n> <var_name_n>;
} <struct_name>;
 Structures
 Example:
struct appInfoType
{
char name[50];
char address[50];
int age;
float weight;
char telNo[10];
} appInfo;
 Structures
 Each item in the structure is called a
field. By definition, fields are the
related items that compose a
record.
 The fields of a record is accessed by
using the following syntax:
<structure_name>.<field_name
>
 Structures
 Example:
strcpy(appInfo.name, "John
Smith");
strcpy(appInfo.address, "New
York City");
appInfo.age = 21;
weight = appInfo.weight;
height = appInfo.height;
 Structures
 To define a structure type using
typedef, the following syntax is used:
typedef struct
{
<data_type_1> <var_name_1>;
<data_type_2> <var_name_2>;
……
<data_type_n> <var_name_n>;
} <type_name>;
 Pointers to Structures
 Structure pointers are just like pointers
to ordinary variables. The declaration
struct appInfoType *p;
says that p is a pointer to a structure of
type struct appInfoType. If p points to an
appInfoType structure, then *p is the
structure and (*p).name and (*p).address
are some of the fields.
 Pointers to Structures
 Pointers to structures are so frequently
used that an alternative notation is
provided as a shorthand. If p is a pointer to
a structure, then

p -> <field_name> /* equivalent to

*(p).<field_name> */
 Lesson Review
 A structure in C is a collection of one or more
variables, possibly of different types, grouped
together under a single name for convenient
handling. A structure is also called a record.
 Each item in the structure is called a field. By
definition, fields are the related items that compose a
record.
 Pointers to structures are so frequently used that an
alternative notation is provided as a shorthand. If p is
a pointer to a structure, then
 p -> <field_name> /* equivalent to
*(p).<field_name> */
 Exercise 12
Define a structure to use that encompasses a student
record, as it may be kept at a school registrar. To keep
the structure simple, assume that the record holds the
surname, first name, address and general weighted
average of the student. The surname and first name
are no longer than 15 characters each, the address is no
longer than 80 characters, and the weighted average is
a value between 0 and 100 that is not necessarily an
integer.
Exercise 13
Write a program that asks the user to
input his or her first name, surname,
address and GWA to store it in a
variable of the structure defined in
the previous problem.
Dynamic Memory Allocation

Lesson 9
Introduction
 Allocate space using
calloc

malloc

 Freeing space
 Dynamic Memory
Allocation
 calloc() and malloc() are predefined
functions in C that allows us to
dynamically create space for arrays
and structures.
 At runtime, we can allocate a
particular amount of space using
these functions.
 calloc()
 calloc() stands for contiguous allocation
 SYNTAX:
calloc(<numOfCells>, <bytesPerCell>)

where
 <numOfCells> is an unsigned int and it refers to the
number of cells to be allocated, and
 <bytesPerCell> is an unsigned int that refers to the
number of bytes allocated for each cell.
 malloc()
 malloc() stands for memory
allocation
 Syntax:
malloc(<totalBytes>)
 where
 <totalBytes> is an unsigned int that refers
to the total number of bytes to be allocated
for an array.
 Freeing space
 Space dynamically allocated (i.e., at
runtime) with calloc() or malloc() does not
get returned to the system upon function
exit. Programmer must use free() to
explicitly return space.
 Syntax:
free(<ptr>);
where
 <ptr> is a pointer dynamically allocated array.
 Lesson Review
 calloc() and malloc() are predefined functions
in C that allows us to dynamically create
space for arrays and structures.
 calloc() stands for contiguous allocation.
 malloc() stands for memory allocation.
 Space dynamically allocated (i.e., at runtime)
with calloc() or malloc() does not get returned
to the system upon function exit. Programmer
must use free() to explicitly return space.
 Exercise 14

Write a program that asks the user

how long his or her name is in
characters, dynamically allocates
enough space for a string, and asks
the user to input his or her name,
and stores it in the dynamically
allocated string.
File Handling

Lesson 10
 Introduction
 Files
 Basic Types: text, binary
 Reading a file
 Writing a file

 Flushing streams
 Files
 A File is a collection of data stored in secondary
memory.
 Basic File Types
 Text files
 Collection of data organized into lines stored as

characters using some coding scheme (ASCII).

 Example: c files

 Binary files

Collection of data stored as is using the internal
representation scheme (binary).

Example: executable files
 Streams
 C implements files using streams. A stream is an
abstraction of a file or a device. We need not worry
about the technical details of the underlying file or
device. Our only concern is about the basic
operations like writing and reading.
 Kinds of Streams:
 Text stream
 Sequence of lines. Each line has zero or more

characters and is terminated by '\n'.

 Binary stream
 Sequence of bytes
 How to read/write from a
file?
 Basic Steps:
 Create a stream variable.
 Associate the variable with a file.

 Read or write to the file using the

stream variable.
 Close the file.
 Declaring a Stream
 To declare a stream, we write:
FILE *<streamName>;
The FILE object contains all the necessary
information to manipulate a file or a physical
device. You don't need to know these information;
all you need to know are the valid operations or
functions you can use to manipulate files.
 Example:
FILE *myFile;
 Opening a Stream
 To associate the stream with a file,
we do that by opening a stream.
FILE *fopen(const char
*filename, const char *
mode)
 Opens the filename in the mode
specified and returns a pointer to
the stream associated with the file.
 Opening a Stream
 Example:

myFile = fopen("hello.c",
"rt");
if (myFile == NULL)
printf("Error. File
doesn't exist.");
 Opening a Stream
 For binary files, append “b” at the end
of the mode. For Example:
myFile = fopen("hello.exe",
"rb");
if (myFile == NULL)
printf("Error. File doesn't
exist.");
 Writing to a Text file
 To write to a file, use the function,
int fprintf(FILE *stream,
const char *
formattedOutput, ...);
This sends formattedOutput to a
stream and returns the number of
characters written, negative if an error
has occurred.
 Valid mode parameters for
fopen
r Open an existing TEXT device/file for reading

w Truncate an existing TEXT device/file or, if not present, create it and

then open for writing.

a Open an existing TEXT device/file for appending at the end or create it

if it does not exist.

r+ Open an existing TEXT device/file for reading and writing.

w+ Truncate an existing TEXT device/file or, if not present, create it and

then open for reading and writing.

a+ Open an existing TEXT device/file for appending in both read and write
mode, or create if it does not exist.
 Valid mode parameters for
fopen
rb Open an existing BINARY device/file for reading

wb Truncate an existing BINARY device/file or, if not present, create it

and then open for writing.

ab Open an existing BINARY device/file for appending at the end or

create it if it does not exist.

rb+ Open an existing BINARY device/file for reading and writing.

wb+ Truncate an existing BINARY device/file or, if not present, create it

and then open for reading and writing.

ab+ Open an existing BINARY device/file for appending in both read and
write mode, or create if it does not exist.
 Writing to a Text file
 Example:

char string[] = "stream";

fprintf(myFile, "I am writing to a %s",

string);
 Reading from a Text file
 To read from a text file, we use the
function,
int fscanf(FILE *stream,
const char *
formattedOutput, ...);
This performs formattedOutput from a
stream and returns the number of input
items converted and assigned, EOF if
end-of-file occurs before conversion.
 Reading from a Text file
 Example:

char string[], ch;

fscanf(myFile, "%s",
string);
fscanf(myFile, "%c",
&ch);
 Reading from a Binary File
 To read from a binary file, we use the function,
size_t fread(void *container, size_t
numOfBytes, size_t numOfObj, FILE
*stream);
This reads numOfObj items of size numOfBytes each and
stores the read values into container. It then returns
number of objects (not number of bytes) read which may be
less than the number requested (numOfObj) when the end-
of-file has been reached.
 Reading from a Binary File
 Example:
int age;
if (fread(&age, sizeof(int), 1, myFile)!
=1)
printf("Cannot read age. Error or
EOF.")
else
printf("Age: %d", age);
 Writing to a Binary file
 To write to a binary file, we use the
function,
size_t fwrite(void *arg,
size_t numOfBytes, size_t
numOfObj, FILE *stream);
This writes numOfObj items of size
numOfBytes each to the stream and
returns number of objects (not number
of bytes) written; may be less than the
number requested (numOfObj) on error.
 Writing to a Binary file
 Example:

int age;
if (fwrite(&age,sizeof(int),1,myFile)!= 1)
printf("Error: Cannot write age.");
else
printf("Successful write!");
 Checking for end-of-file
status
 To check for end-of-file, we use the function,
int feof(FILE *stream)
This
returns non-zero if end-of-file indicator has
been reached.
 Example:

while(!feof(myFile)) {
char line[8];
fscanf(myFile, "%[^\n]\n", line);
printf("%s\n", line);
}
 Flushing the stream
 We use the function fflush in order
to flush a stream; write all unwritten
data and/or discards all unread data.
 Returns EOF if an error occurred,
zero otherwise.
 Flushing the stream
 To disassociate a file from a stream,
we use the function fclose; in
addition, it flushes the stream
 Example:

fflush(stdin);
fclose(fp);
Function prototypes for I/O
functions
 FILE * fopen(const *name, const char *mode);
 int fprintf( FILE *stream, const char *format, … );
 int fscanf( FILE *stream, const char *format, … );
 int fclose( FILE *stream );
 int fflush( FILE *stream );
 char *fgets( char *buff, int num, FILE *stream );
 int fputs(const *array, FILE *stream);
 int fgetc( FILE *stream );
 int fputc( int c, FILE *stream );
 Lesson Review
A File is a collection of data stored in
secondary memory. Its basic types
are text files and binary files.
 A stream is an abstraction of a file or
a device. Kinds of streams are text
streams and binary streams.
 Lesson Review
 The basic steps to follow to read/write from/to
a file are:
 Create a stream variable.

 Associate the variable with a file.

 Read or write to the file using the stream

variable.
 Close the file.
 Exercise 15
Write a program that reads the
contents of a text file specified by
the user and outputs it to screen,
line per line. No line in the file is
expected to be longer than 256
characters.
End