An array is a collection of variables of the same type that can be accessed using a common name. Arrays can be initialized statically at declaration or dynamically at runtime. Elements in an array are accessed using indexes and the size of an array allocates contiguous memory blocks for its elements. Structures group related data types together and allow accessing members using dot and arrow operators. Unions store different data types in the same memory location and the type of the member accessed determines the interpretation. Files provide a way to persist data in programs and functions like fopen(), fclose(), fread(), fwrite() allow opening, closing and reading/writing files. Command line arguments passed to programs can be accessed using argc and argv.

1. 1

2.  An Array is a collection of variables of the
same type that are referred to through a
common name.
 Declaration
type var_name[size]
e.g
2
int A[6];
double d[15];

3. After declaration, array contains some garbage
value.
Static initialization
Run time initialization
3
int month_days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int i;
int A[6];
for(i = 0; i < 6; i++)
A[i] = 6 - i;

4. int A[6];
6 elements of 4 bytes each,
total size = 6 x 4 bytes = 24 bytes
Read an element
Write to an element
{program: array_average.c}
4
A[0] A[1] A[2] A[3] A[4] A[5]
0x1000 0x1004 0x1008 0x1012 0x1016 0x1020
6 5 4 3 2 1
int tmp = A[2];
A[3] = 5;

5.  No “Strings” keyword
 A string is an array of characters.
OR
5
char string[] = “hello world”;
char *string = “hello world”;

6. • Compiler has to know where the string ends
• ‘0’ denotes the end of string
{program: hello.c}
Some more characters (do $man ascii):
‘n’ = new line, ‘t’ = horizontal tab, ‘v’ =
vertical tab, ‘r’ = carriage return
‘A’ = 0x41, ‘a’ = 0x61, ‘0’ = 0x00
6
char string[] = “hello world”;
printf(“%s”, string);

7.  aggregate in that they hold multiple data items at
one time
 named members hold data items of various types
 like the notion of class/field in C or C++
– but without the data hiding features
 scalar in that C treats each structure as a unit
 as opposed to the “array” approach: a pointer to a
collection of members in memory
 entire structures (not just pointers to structures) may be
passed as function arguments, assigned to variables,
etc.
 Interestingly, they cannot be compared using ==
(rationale: too inefficient)
7

8.  Combined variable and type declaration
struct tag {member-list} variable-list;
 Any one of the three portions can be omitted
struct {int a, b; char *p;} x, y; /* omit tag */
 variables x, y declared with members as described:
int members a, b and char pointer p.
 x and y have same type, but differ from all others –
even if there is another declaration:
struct {int a, b; char *p;} z;
/* z has different type from x, y */
8

9. struct S {int a, b; char *p;}; /* omit variables */
 No variables are declared, but there is now a type
struct S that can be referred to later
struct S z; /* omit members */
 Given an earlier declaration of struct S, this declares a
variable of that type
typedef struct {int a, b; char *p;} S;
/* omit both tag and variables */
 This creates a simple type name S
(more convenient than struct S)
9

10.  Direct access operator s.m
 subscript and dot operators have same precedence and
associate left-to-right, so we don’t need parentheses for
sam.pets[0].species
 Indirect access s->m: equivalent to (*s).m
 Dereference a pointer to a structure, then return a
member of that structure
 Dot operator has higher precedence than indirection
operator , so parentheses are needed in (*s).m
(*fido.owner).name or fido.owner->name
10
. evaluated first: access owner member
* evaluated next: dereference pointer to
HUMAN
. and -> have equal precedence
and associate left-to-right

11.  Portability is an issue:
 Do any bit field sizes exceed the machine’s int size?
 Is there any pointer manipulation in your code that
assumes a particular layout?
 Bit fields are “syntactic sugar” for more complex
shifting/masking
 e.g. to get font value, mask off the ch and size bits,
then shift right by 19
 This is what actually happens in the object code –
bit fields just make it look simpler at the source level
11

12.  Structures are scalars, so they can be returned and
passed as arguments – just like ints, chars
struct BIG changestruct(struct BIG s);
 Call by value: temporary copy of structure is created
 Caution: passing large structures is inefficient
– involves a lot of copying
 avoid by passing a pointer to the structure instead:
void changestruct(struct BIG *s);
 What if the struct argument is read-only?
 Safe approach: use const
void changestruct(struct BIG const *s);
12

13.  Like structures, but every member occupies the
same region of memory!
 Structures: members are “and”ed together: “name and
species and owner”
 Unions: members are “xor”ed together
union VALUE {
float f;
int i;
char *s;
};
/* either a float xor an int xor a string */
13

14.  Up to programmer to determine how to interpret a
union (i.e. which member to access)
 Often used in conjunction with a “type” variable
that indicates how to interpret the union value
enum TYPE { INT, FLOAT, STRING };
struct VARIABLE {
enum TYPE type;
union VALUE value;
};
14
Access type to determine
how to interpret value

15.  Storage
 size of union is the size of its largest member
 avoid unions with widely varying member sizes;
for the larger data types, consider using pointers instead
 Initialization
 Union may only be initialized to a value appropriate for
the type of its first member
15

16.  File – place on disc where group of related
data is stored
 E.g. your C programs, executables
 High-level programming languages support
file operations
 Naming
 Opening
 Reading
 Writing
 Closing

17.  fp
 contains all information about file
 Communication link between system and program
 Mode can be
 r open file for reading only
 w open file for writing only
 a open file for appending (adding) data
FILE *fp; /*variable fp is pointer to type FILE*/
fp = fopen(“filename”, “mode”);
/*opens file with name filename , assigns identifier to fp */

18.  Writing mode
 if file already exists then contents are deleted,
 else new file with specified name created
 Appending mode
 if file already exists then file opened with contents safe
 else new file created
 Reading mode
 if file already exists then opened with contents safe
 else error occurs.
FILE *p1, *p2;
p1 = fopen(“data”,”r”);
p2= fopen(“results”, w”);

19.  r+ open to beginning for both
reading/writing
 w+ same as w except both for reading and
writing
 a+ same as ‘a’ except both for reading and
writing

20.  File must be closed as soon as all operations on it completed
 Ensures
 All outstanding information associated with file flushed out from
buffers
 All links to file broken
 Accidental misuse of file prevented
 If want to change mode of file, then first close and open
again
Syntax: fclose(file_pointer);
Example:
FILE *p1, *p2;
p1 = fopen(“INPUT.txt”, “r”);
p2 =fopen(“OUTPUT.txt”, “w”);
……..
……..
fclose(p1);
fclose(p2);

21.  C provides several different functions for
reading/writing
 getc() – read a character
 putc() – write a character
 fprintf() – write set of data values
 fscanf() – read set of data values
 getw() – read integer
 putw() – write integer

22.  handle one character at a time like getchar() and
putchar()
 syntax: putc(c,fp1);
 c : a character variable
 fp1 : pointer to file opened with mode w
 syntax: c = getc(fp2);
 c : a character variable
 fp2 : pointer to file opened with mode r
 file pointer moves by one character position after every
getc() and putc()
 getc() returns end-of-file marker EOF when file end
reached

23. #include <stdio.h>
main()
{ FILE *fp1;
char c;
f1= fopen(“INPUT”, “w”); /* open file for writing */
while((c=getchar()) != EOF) /*get char from keyboard
until CTL-Z*/
putc(c,f1); /*write a
character to INPUT */
fclose(f1); /* close INPUT
*/
f1=fopen(“INPUT”, “r”); /* reopen file */
while((c=getc(f1))!=EOF) /*read character from file INPUT*/
printf(“%c”, c); /* print character to
screen */
fclose(f1);
} /*end main */

24. • similar to scanf() and printf()
• in addition provide file-pointer
• given the following
– file-pointer f1 (points to file opened in write mode)
– file-pointer f2 (points to file opened in read mode)
– integer variable i
– float variable f
• Example:
fprintf(f1, “%d %fn”, i, f);
fprintf(stdout, “%f n”, f); /*note: stdout refers to
screen */
fscanf(f2, “%d %f”, &i, &f);
• fscanf returns EOF when end-of-file reached

25.  handle one integer at a time
 syntax: putw(i,fp1);
 i : an integer variable
 fp1 : pointer to file ipened with mode w
 syntax: i = getw(fp2);
 i : an integer variable
 fp2 : pointer to file opened with mode r
 file pointer moves by one integer position, data
stored in binary format native to local system
 getw() returns end-of-file marker EOF when file end
reached

26.  Typical errors that occur
 trying to read beyond end-of-file
 trying to use a file that has not been opened
 perform operation on file not permitted by
‘fopen’ mode
 open file with invalid filename
 write to write-protected file

27.  given file-pointer, check if EOF reached, errors
while handling file, problems opening file etc.
 check if EOF reached: feof()
 feof() takes file-pointer as input, returns nonzero if
all data read and zero otherwise
if(feof(fp))
printf(“End of datan”);
 ferror() takes file-pointer as input, returns nonzero
integer if error detected else returns zero
if(ferror(fp) !=0)
printf(“An error has occurredn”);

28.  if file cannot be opened then fopen returns a
NULL pointer
 Good practice to check if pointer is NULL
before proceeding
fp = fopen(“input.dat”, “r”);
if (fp == NULL)
printf(“File could not be opened n ”);

29.  how to jump to a given position (byte number) in a
file without reading all the previous data?
 fseek (file-pointer, offset, position);
 position: 0 (beginning), 1 (current), 2 (end)
 offset: number of locations to move from position
Example: fseek(fp,-m, 1); /* move back by m bytes from
current
position */
fseek(fp,m,0); /* move to (m+1)th byte in file
*/
fseek(fp, -10, 2); /* what is this? */
 ftell(fp) returns current byte position in file
 rewind(fp) resets position to start of file

30.  can give input to C program from command line
E.g. > prog.c 10
name1 name2 ….
 how to use these arguments?
main ( int argc, char *argv[] )
 argc – gives a count of number of arguments
(including program name)
 char *argv[] defines an array of pointers to
character (or array of strings)
 argv[0] – program name
 argv[1] to argv[argc -1] give the other arguments
as strings