Introduction to c

A structure is a collection of one or more variables, possibly of different types, grouped together under a single name for convenient handling. Structures are called records in many languages like COBOL, FoxPro etc. Structures help to organise complicated data, particularly in large programs, because they permit a group of related variables to be treated as a unit instead of as separate variables. for example, a student record’s details like Rollno, name, house, pin, sex etc. or employee details like employee no., name, salary, sex etc.

Structure, which is a data structure whose individual data element can differ in type. A data structure may contain variables of basic data types, arrays, pointers and other data structures except the structure itself. The individual structure elements are called members of the structure.

Defining a Structure

A structure must be defined in terms of its individual members. Structure declaration starts with the keyword struct followed by a name for the structure called structure tag. The various fields ie., members are declared within a block of code enclosed by braces. the member declaration is as the same as that of an ordinary variable declaration. After the closing brace of the block a semicolon must terminate the structure declaration.

struct tag

type member-1;

type member-2;

........................

type member-n;

};

The member names within a structure must be unique through member names can be the same as the variable name defined outside of the structure. The rules of forming a tag name and individual member names are the same as for other variables. the member can not be initialised within a structure declaration. Declaration tells only a model (template) of type struct tag and no space is allocated in the memory. Space is allocated only when a structure variable is declared.

struct emp

int emp_no;

char name[20];

float salary;

char sex;

};

Structure Variable Declaration

syntax: struct tag variable1, variable2;

Where variable1, variable2 are variables of type struct tag.

Where salesman and officer are variables of type struct emp.

It is also possible to combine structure declaration and variable declaration in one statement.

syntax: struct tag

{

type member-1;

type member-2;

........................

type member-n;

} variable1, variable2;

The tag is optional in this case.

struct emp

int emp_no;

char name[20];

float salary;

char sex;

} salesman, officer;

Referencing Fields (members) of Structure

Referencing a field means accessing its contents. A structure field is referred to by writing the name of the structure variable followed by a dot(.), followed by the name of the field(member).

Where dot(.) is called the structure member operator, which connects the structure_variable name and the member_name.

salesman.salary = 2345.23;

officer.sex = ‘M’;

strcpy(officer.name, “Ajith”);

salesman.name[0] = ‘A’;

officer.emp_no++;

officer.name[0] = toupper(officer.name[0]);

ptr = &officer.salary;

The initialisation is done by giving an equal sign after the variable name, followed by a list of values for the members (fields) enclosed in a pair of braces. The closing brace is followed by a semicolon. Initialisation can be done only at the time of structure variable declaration and not at the time of execution.

Although structure is a derived data type, structure variable is a valid operand for the assignment operator. A structure variable can be copied into another variable of the same structure type, by the assignment operator.

For example, if the contents of officer1 were to be copied into officer2,
officer2 = officer1;
To copy the content of one structure variable into another you can also copy individual members of the entire structure.

For example if the contents of officer1 were to be copied into officer2,

Another method would be to use the memcpy()

This function copies n_bytes starting from the address of source to a block of n_bytes starting from the address of destination. The size of the structure, i.e., n_bytes can be obtained by using the sizeof() operator.

To declare an array of structures first define a tructure and then declare an array variable of that typr. For example, to declare a 10 element array of structures of type struct emp that had been defined earlier,

Like all aray variables, array of structures begins subscripting at 0. The arry name followed by its subscript enclosed in square brackets stands for an element of that array.

To print the name of the second element in the array,

printf(“name of second employee : %s”, employee[1].name );

To copy the fifth element of the array to he seventh element,

Each element of the array is initialised as if some structure variable is being initialised. The whole list is then enclosed within braces to indicate that the array is being initialised.

In ‘C’ the components of a structure can be anything but the structure itself. Therefore we can have one structure within another to group the data more meaningfully.

struct sal

float basic;

float hra;

float da;

int emp_no;

char name[20];

struct sal salary;

char sex;

};

struct emp emp1, emp2;

To access the name of emp1,

emp1.name

To access the basic of emp1,

emp1.salary.basic

To initialize, struct emp emp2 = { 1001, “Ajith”, {1000.45, 150, 435.55 }, ‘M’ };

Passing Structures as Arguments to Functions (Call by Value)

A structure variable can be passed as an argument to another function. This is a useful facility because it is used to pass groups of logically related data items together instead of passing them one by one. ‘C’ also supports to pass the members of a structure individually.

# include

struct sal

{

float basic;

float hra;

float da;

struct emp

int emp_no;

char name[20];

float salary;

char sex;

};

float total(struct sal salary);

main()

{

struct emp employee[10];

int i;

for( i=0; i<10; i++)

printf(“Enter Employee Number : “); scanf(“%d”, &employee[i].emp_no);

printf(“Enter Employee Name : “); scanf(“%s”, employee[i].name);

printf(“Enter Basic Salary : “); scanf(“%f”, &employee[i].salary.emp_no);

printf(“Enter HRA : “); scanf(“%f”, &employee[i].salary.hra);

printf(“Enter DA : “); scanf(“%f”, &employee[i].salary.da);

printf(“Enter Sex : “); scanf(“%c”, &employee[i].sex);

}

for( i=0; i<10; i++)

float x;

printf(“%d \t %s \t %f \t %f \t %f \t %f \n”, employee[i].emp_no, employee[i].name, \

employee[i].salary.basic, employee[i].salary.hra, employee[i].salary.da, x);

}

}

float total(struct sal salary)

return(salary.basic + salary.hra + salary.da);

‘C’ allows pointers to structures just as it allows pointers to any other type of variable. Like other pointers we can declare structure pointers by placing an indirection operator in front of pointer variable name.

There are two major uses for structure pointers, to generate a call by reference call to a function and to create linked lists and other dynamic data structures using ‘C’s dynamic memory allocation system.

To find the address of a structure variable, place the & operator before the variable name.

e.g.:- struct emp emp1, emp_ptr;

emp_ptr = &emp1;

In order to access the elements (members) of a structure using a pointer to that structure use the  operator.

is the same as

The  is called the arrow operator, and consists of the minus sign followed by the greater than sign.

The declaration of a pointer allocates space for the pointer and not what it points to. Therefore it is necessary to make the pointer to point to a place in memory containing some legal address of that type.

e.g.:- emp_ptr = &emp1;

Sometimes it is necessary that storage for a variable be allocated at the time of execution as and when needed. This is done using C’s dynamic memory allocation function malloc().

# include

struct sal

{

float basic;

float hra;

float da;

struct emp

int emp_no;

char name[20];

struct sal salary;

char sex;

};

float total(struct sal salary);

main()

{

struct emp employee[10], *emp_ptr, *temp;

int i;

emp_ptr = employee; temp = emp_ptr;

printf(“Enter Employee Number : “); scanf(“%d”, &emp_ptremp_no);

printf(“Enter Employee Name : “); scanf(“%s”, emp_ptrname);

printf(“Enter Basic Salary : “); scanf(“%f”, &emp_ptrsalary.emp_no);

printf(“Enter HRA : “); scanf(“%f”, &emp_ptrsalary.hra);

printf(“Enter DA : “); scanf(“%f”, &emp_ptrsalary.da);

printf(“Enter Sex : “); scanf(“%c”, &emp_ptr.sex);

emp_ptr++;

emp_ptr = temp;

for( i=0; i<10; i++)

{

float x;

printf(“%d \t %s \t %f \t %f \t %f \t %f \n”, emp_ptremp_no, emp_ptr.name, \

emp_ptrsalary.basic, emp_ptrsalary.hra, emp_ptrsalary.da, x);

emp_ptr++;

float total(struct sal salary)

return(salary.basic + salary.hra + salary.da);

Structure pointers can be passed to functions by declaring the formal parameters of the function as a structure pointer and at the time of calling the function, a pointer to the structure or the address of a structure variable is passed to the function. Using this method i.e., Call by Reference the elements of the structure can be modified in the function.

typedef struct

type member-1;

type member-2;

........................

type member-n;

} new_type;

Where new_type is the user-defined structure type and not a structure variable. Structure variables can now be defined in terms of the new data type.

typedef struct

int emp_no;

char name[20];

float salary;

char sex;

} employee;

employee x, y;

Where employee is the new data type and x and y are variables of type employee.

Q) Write a program to accept the details of 10 employees. The program should print a report of all employees’ details and the net salary. [Use dynamic memory allocation, call by reference and pointer to structure]

e.g.:-

# include

typedef struct

{

float basic;

float hra;

float da;

struct emp

int emp_no;

char name[20];

sal salary;

char sex;

};

typedef struct emp empl;

float total(sal *salary);

main()

empl *emp_ptr, *ptr;

int i;

emp_ptr = (empl *) malloc(10 * sizeof(empl) );

if(ptr == NULL)

printf(“ Not enough Memory “);

return;

}

for( i=0; i<10; i++)

printf(“Enter Employee Number : “); scanf(“%d”, &emp_ptremp_no);

printf(“Enter Employee Name : “); scanf(“%s”, emp_ptrname);

printf(“Enter Basic Salary : “); scanf(“%f”, &emp_ptrsalary.emp_no);

printf(“Enter HRA : “); scanf(“%f”, &emp_ptrsalary.hra);

printf(“Enter DA : “); scanf(“%f”, &emp_ptrsalary.da);

fflush(stdin);

printf(“Enter Sex : “); scanf(“%c”, &emp_ptr.sex);

emp_ptr++;

}

emp_ptr = ptr;

for( i=0; i<10; i++)

{

float x;

printf(“%d \t %s \t %f \t %f \t %f \t %f \n”, emp_ptremp_no, emp_ptr.name, \

emp_ptrsalary.basic, emp_ptrsalary.hra, emp_ptrsalary.da, x);

emp_ptr++;

float total(sal *salary)

return(salarybasic + salaryhra + salaryda);

‘C’ allows to include within a structure one member that is a pointer to the parent structure type.

struct tag

type member-1;

type member-2;

........................

type member-n;

struct tag *ptr;

Where ptr refers to the name of a pointer variable. Thus the structure of type tag will contain a member that points to another structure of type tag. Such structures are known as self-referential structures.

Self-referential structures are very useful to create linked data structures like linked lists. Linked lists are used to create arrays of unknown size in memory. i.e., the size of linked list can grow or shrink during the execution of a program, because a linked list is a dynamic data structure. But array’s size is fixed at the time of compilation. Linked lists allow items to be inserted and deleted quickly and easily.

Linked lists can be circularly, singly or doubly linked. A singly linked list contains a link to the next data item. Each data item called node consists of a structure that includes information fields and a link pointer and the last item’s link pointer points to the NULL, to terminate the linked list.

The 'C' file system works with a wide variety of devices including keyboard, monitor, printers, disk drives etc. Even though all these devices are very different from each other. The buffered file system transforms each device into a logical device called stream. All streams act similarly and hence there is no difficulty in handling these different types of devices. The functions used are all common for any device.

The ‘C’ I/O system provides an interface to the 'C' programmer independent of the actual device being accessed. This interface is not actually a file but an abstract representation of the device. This abstract interface is known as a stream and the actual device is called the file. There are two types of streams, the text and binary streams.

A text stream is a sequence of characters. The text streams can be organised into lines terminated by a Newline character. Newline characters are optional in the last line as this line can be terminated using the end-of-file mark. In a text stream, certain characters may undergo translations as required by the host environment (operating system) for example, a Newline (\n) can be converted to a carriage return (‘\r’) and linefeed pair. Therefore, there may not be a one to one relationship between the characters read or written and those on the external device. Also because of translations, the number of characters read or written may not be same as that on the actual device. Under DOS, the character Ctrl-Z (ASCII 26) is used in text streams indicates the end-of-file.

A binary stream is a sequence of bytes with a one-to-one correspondence to those in the external device. There are no character translations as in the text streams. The number of bytes read or written is the same as the number on the actual device. Binary streams are a sequence of bytes, which do not have any flags to indicate the end of file or end of record. End-of-file is determined by the size of the file.

A file pointer is a pointer to information that defines various details about the file, like filename, status, current position of file pointer, etc. i.e., the file pointer identifies a specific disk file and is used by the associated stream to direct the operation of the buffered I/O functions. A file pointer is a pointer variable to the data type FILE. FILE is a derived data type and its structure is defined in stdio.h.

In order to read or write files the program needs to use file pointers.

E.g. :- FILE *fp, *fp1, fp2;

OPENING STREAMS USING fopen()

The fopen() opens a stream for use and links a file with that stream and returns the file pointer associated with that file. If an error occurs when it is trying to open a file then fopen() returns a NULL pointer. The prototype of fopen() is as follows,

where filename is a pointer to string of characters that make up a valid filename and may include a path specification and the mode determines how the file will be opened. The mode can be one of the following,

e.g.:-

FILE *fp;

………

fp=fopen("test","w");

printf('Cannot open the file");

exit(1);

}

………

If a file is opened for read/write operations, it will not be erased if it exists. If it does not exist, it will be created.

Closing a stream frees various system resources and flushes out the associated buffers that prevents loss of data when writing to a disk.

prototype : int fclose(FILE *stream);

Where stream is the file pointer. The function returns an integer value, 0, if successful else returns EOF.

fcloseall()

prototype : int fcloseall(void);

This function closes all open streams and returns the number of streams closed or EOF if any error is detected.

e.g.:-

int fcl;

fcl=fcloseall();

if(fcl= =EOF)

printf("Error closing files");

else

printf("%d file(s) closed",fcl);

prototype : int fgetc(FILE *stream);

The fgetc() returns the next character from the input stream from the current position and increments the file position indicator. The character is read as an unsigned char that is converted to an integer. if the end-of-file is reached, fgetc() returns EOF.

e.g.:-

main()

{

char filename[13];

char ch;

FILE *fp;

printf("Enter Filename : ");

gets(filename);

if((fp=fopen(filename,"r"))==NULL)

{

printf("Cannot open %s",filename);

exit(1);

}

while((ch=fgetc(fp))!=EOF)

{

putchar(ch);

}

fclose(fp);

}

Since EOF is a valid integer value, you must use feof() to check for end-of-file when working with binary file.

feof()

prototype : int feof(FILE *stream);

The feof() checks the file position indicator to determine if the end of file associated with stream has been reached. A non-zero (true) value is returned if the file position indicator is at the end of file. Otherwise, the function returns zero (false).

eg:-

while(!feof(fp))

{

putchar(fgetc(fp));

}

fputc()

prototype : int fputc(int ch, FILE *stream);

The fputc() writes a character to a specified stream at the current file position and then advances the file position indicator . If successful, fputc() returns the value of the character written, otherwise EOF is returned.

e.g.:-

# include

main()

{

char filename[13],ch;

FILE *fp;

printf("Enter filename : ");

gets(filename);

if((fp=fopen(filename, "w"))==NULL)

{

printf("Cannot open %s",filename);

exit(1);

}

while((ch=getch())!='X' )

{

fputc(ch, fp);

}

fclose(fp);

}

getc()

prototype : int getc(FILE *stream);

same as fgetc();

putc()

prototype : int putc(int ch, FILE *stream);

same as fputc();

fgets()

prototype : char *fgets(char *string, int length, FILE *stream);

fgets() reads a string from the specified stream until either a newline(\n) character is read or length-1 characters have been read. If a newline is read, it would be a part of the string, unlike gets(). The resultant string would be NULL terminated. The function returns a pointer to string if successful and a NULL pointer if an error occurs.

fputs()

prototype : int fputs(char *string, FILE *stream);

fputs() writes the string to the specified file stream starting at the current location, unless the stream is opened in append mode in which case it is written at EOF.

Sample program to simulate DOS COPY command

# include

main()

{

FILE *in, *out;

char str[81], file1[13], file2[13];

printf("Enter source file name : ");

gets(file1);

printf("Enter target file name : ");

gets(file2);

if((in=fopen(file1, "r"))==NULL)

{

printf("%s not found"); exit(1);

}

if((out=fopen(file2, "w"))==NULL)

{

printf("Cannot create %s ", file2);

exit(1);

}

while(!feof(in))

{

if(fgets(str, 81, in))

{

fputs(str, out);

}

}

fcloseall();

}

FLUSHING STREAMS

The fclose() and fcloseall() flush the streams before closing the files. But if you want to flush the contents of streams without closing them, use the fflush() and flushall() functions.

The action of flushing depends upon the file type. A file opened for read will have its input buffer cleared, while a file opened for write will have its output buffer written to the file.

fflush()

prototype : int fflush(FILE *stream);

Flush the buffer leaving the file stream open. returns 0 on success and EOF on failure.

flushall()

prototype : int flushall(void);

flush all buffers leaving files open. Returns the number of files flushed.

STANDARD STREAMS

Whenever a 'C' program starts execution under DOS five special file streams are opened automatically by the operating system. They are the standard input (stdin), the standard output(stdout), standard error(stderr), standard printer(stdprn) and the standard auxiliary(stdaux). The stdin is assigned to the keyboard, stdout and stderr are assigned to the monitor, stdprn is assigned to the first parallel printer port and stdaux is assigned to the first serial port. They are defined as fixed pointers of type FILE.

Sample program to print the contents of a file to printer

# include

main()

{

FILE *in;

char buffer[81],filename[13];

printf("Enter file name to print : ");

gets(filename);

if((in=fopen(filename, "r"))==NULL)

{

fputs("File not found", stderr);

exit(1);

}

while(!feof(in))

{

if(fgets(buffer, 81, in))

{

fputs(buffer, stdprn);

}

} fclose(in);

}

CURRENT ACTIVE POINTER

In order to keep track of the position where I/O operations are to take place, a pointer is maintained in the FILE structure. Whenever a character is read from or written to the stream the current active pointer is advanced. Most of the I/O functions refer to current active pointer and update it after the input or output procedures on the stream.

ftell()

prototype : long int ftell(FILE *fp);

The ftell() returns a long int value which gives the position of current active pointer in the specified stream.

e.g.:- printf("Current position = %ld", ftell(fp));

SETTING CURRENT POSITION

Immediately after opening the stream the current active pointer position is set to zero and points to the first byte of the stream. Whenever a character is read from or written to the stream, the current active pointer is automatically advanced, the pointer may be set to any position other than the current pointer, at any time in the program.

rewind()

prototype : void rewind(FILE *fp);

Rewind() takes the current active pointer back to the beginning of the stream from any point on the stream. This function allows to restart the file without closing the file and reopening it.

fseek()

prototype : int fseek(FILE *fp, long int offset, int origin);

fseek() repositions the current active pointer by a specified number of bytes from either the start, the current position or the end of the stream, depending upon the position specified to the fseek(). The offset is the number of bytes beyond the file location given by origin. Origin must be one of the values 0,1 or 2 which represent three symbolic constants defined in stdio.h as follows

SEEK_SET or 0 - Beginning of file

SEEK_CUR or 1 - Current file pointer position

SEEK_END or 2 - End-of-file

A return value of zero means fseek() succeeded and non-zero value means failure.

e.g.:- fseek(fp, 0L, SEEK_SET);

The above example takes the pointer to the beginning of the stream which is equivalent to rewind(fp);

The offset may be positive, meaning move forwards or negative meaning move backwards.

e.g.:-

fseek(fp, 0L, 0); - go to beginning(rewind)

fseek(fp, 0L, 1); - stay at the current position

fseek(fp, 0L, 2); - go to the end-of-file, past the last character of the file

fseek(fp, 10L, 0); - move to 11^th byte in the file

fseek(fp, 10L, 1); - move forward by 10 bytes

fseek(fp, -m, 1); - go backward by m bytes from the current position

fseek(fp, -m, 2); - go backward by m bytes from the end

When the operation is successful, fseek() returns a zero. If the program attempts to move the file pointer beyond the file boundaries an error occurs and fseek returns -1(non-zero).

fprintf() and fscanf()

The functions fprintf and fscanf perform I/O operations that identical to the familiar printf and scanf functions, except that they work on files.

syntax : fprintf(FILE *stream, "control string", arguments);

fprintf sends output to the specified file stream. fprintf returns the number of bytes output. In case of error, it returns EOF.

syntax : fscantf(FILE *stream, "control string", arguments);

fscanf performs a formatted input from the specified stream. Returns the number of input fields successfully scanned, converted and stored, the returned value does not include unstored scanned fields.

e.g.:- fscanf(fp, "%s %d", name, &age);

fprintf(stdout," %s -- %d", name, age);

BLOCK I/O

The block I/O functions are used to read or write continuous blocks of bytes from and to a file. Each block will generally represent a complex data structure, such as a structure or an array. For example, it is easier to read or write an entire block of data rather than reading or writing the individual components (i.e., structure members) within a block separately.

prototypes : size_t fread(void *buffer, size_t num_bytes, size_t count, FILE *stream);

size_t fwrite(void *buffer, size_t num_bytes, size_t count, FILE *stream);

The data type size_t is an ANSI 'C' addition to improve portability. It is predefined as an integer type large enough to hold sizeof() results. Usually it is equivalent to unsigned integer. For fread() buffer is a pointer to the region of memory that will receive the data item from the file. For fwrite(), buffer is a pointer to the information that will be written to the file.

The number of bytes to read or written is specified by num-bytes. The argument count determines how many items(each num-bytes in length) are read or written.

The fread() returns the number of items read. This value be less than count if the end-of-file is reached or an error occurs. The fwrite() returns the number of items written. This value will equal to count unless an error occurs.

As long as the file has been opened for binary operations, fread() and fwrite() can read and write any type of information.

e.g.:-

fread(&buffer, sizeof(buffer), 1, fp);

fwrite(&buffer, sizeof(buffer), 1, fp);

ARRAY OF POINTERS

The way there can be an array of ints or an array of floats, similarly there can be an array of pointers. Since a pointer variable always contains an address, an array of pointers would be nothing but a collection of addresses. The addresses present in the array of pointers can be addresses of different variables or addresses of arrays and array elements.

syntax : data_type *array_name[size of array];

eg:- int *arr[4]; an array of 4 integer pointers

float *price[10]; an array of 10 float pointers

Sample Programs: To show array of pointers can contain the addresses of different data items.

i)

main()

{

int *arr[4];

int a=10, b=20, c=30,d=40,x=0;

arr[0]=&a; arr[1]=&b; arr[2]=&c; arr[3]=&d;

for(x=0;x<4;x++)

{

printf("%u -- %d\n", arr[x], *(arr[x]) );

}

getch();

}

will print, The for loop in the program picks up the addresses present in

6784 - - 10 the elements of arr and prints the addresses present at there 6786 - - 20 and the values present at these addresses.

6788 - - 30 ( the addresses shown in the sample output are imaginary )

6790 - - 40

ii)

main() will print, 6202 - - 5101 - - 0, where

{ 6202 is the base address of the pointer

int arr[]={0,1,2,3,4}, *p[5]; array, p, 5101 is the base address

p[0]=a; p[1]=a+1; p[2]=a+2; p[3]=a+3; p[4]=a+4; of integer array, a stored in the first

printf("%u -- %u --%d",p,*p,*(*p) ); element of p, and 0 is the value stored

} in the first element of array a.

iii)

main() will print,

{ 6202 - - 5101 - - 0

int arr[]={0,1,2,3,4}, *p[5]; 6204 - - 5103 - - 1

p[0]=a; p[1]=a+1; p[2]=a+2; p[3]=a+3; p[4]=a+4; 6206 - - 5105 - - 2

for(i=0;i<5;i++) 6207 - - 5107 - - 3

printf("%u -- %u --%d",&p[i],p[i],*(p[i]) ); 6210 - - 5109 - - 4

}

iv)

main() will print,

{ 6202 - - 5101 - - 0

int arr[]={0,1,2,3,4}, *p[5]; 6204 - - 5103 - - 1

p[0]=a; p[1]=a+1; p[2]=a+2; p[3]=a+3; p[4]=a+4; 6206 - - 5105 - - 2

for(i=0;i<5;i++) 6207 - - 5107 - - 3

printf("%u -- %u --%d", p+i,*(p+i),*(*(p+i)) ); 6210 - - 5109 - - 4

}

v)

main()

{

int arr[]={0,1,2,3,4}, *p[5],**ptr; will print,

p[0]=a; p[1]=a+1; p[2]=a+2; p[3]=a+3; p[4]=a+4; 5101 - - 0

ptr=p; 6202 - - 5101 - - 0

printf("%u - - %d \n", a, *a); 6202 - - 5101 - - 0

printf("%u - - %u - - %d \n", p, *p, **p);

printf("%u - - %u - - %d \n", ptr, *ptr, **ptr);

}

vi)

main()

{

int a[3][3]={ 1,2,3,4,5,6,7,8,9 }, *ptr[3]; will print,

ptr[0]=a[0]; ptr[1]=a[1]; ptr[2]=a[2]; 1 - - 4 - - 7

for(i=0;i<3;i++) 1 - - 4 - - 7

printf("%d \t", *ptr[i] );

printf("\n");

for(i=0;i<3;i++)

printf("%d \t", *a[i] );

}

Array of pointers mainly used for storing several strings in memory.

e.g.:- char *name[]={ "joy", "srinivas", "jayaprakash", "antony", "hussain", "abijith"};

In the above example names[] is an array of 6 pointers. It contains addresses of given names. i.e., base address of "joy" is stored in names[0], base address of "antony" is stored in names[3] and so on.

If we used a two-dimensional array to store these names, where each row will be of equal lengths, it will take roughly 72 bytes in memory.

But by using the memory of pointers is strings will take only 41 bytes. Thus one reason to store to make more efficient use of available memory.

Another advantage is that easy manipulation of strings. e.g.:- exchange of positions of strings like in sorting of string arrays.

e.g.1:- string exchanging:

main()

{

char *names[]={"joy", "srinivas", "jayaprakash", "antony", "hussain", "abijith"};

char *temp;

printf("Before exchanging : ");

printf("%s - - %s", names[2], names[3] );

temp = names[2];

names[2] = names[3];

names[3] = temp;

printf("\n After exchanging : ");

printf("%s - - %s", names[2], names[3] );

getch();

}

will print,

Before exchanging : jayaprakash - - antony

After exchanging : antony - - jayaprakash

e.g. 2: sorting strings

main()

{

char *names[]={"joy", "srinivas", "jayaprakash", "antony", "hussain", "abijith"};

sort(names);

for(i=0; i<6; i++)

printf("%s \n", arr[i] );

getch();

}

sort( char *names[])

{

int i, j;

char *temp;

for(i=0; i<5; i++)

{

for(j=5; j>i; j--)

{

if(strcmp(names[j], names[j-1]) < 0)

{

temp=names[j];

names[j]=names[j-1];

names[j-1]=temp;

}

}

}

}

e.g.3 :- sorting strings

main()

{

char *names[]={"joy", "srinivas", "jayaprakash", "antony", "hussain", "abijith"};

sort(names);

for(i=0; i<6; i++)

printf("%s \n", arr[i] );

getch();

}

sort( char *names[])

{

int i,j;

char *temp;

for(i=0; i<5; i++)

{

for(j=5; j>i; j--)

{

if(strcmp(names[j], names[j-1]) < 0)

{

swap(&names[j], &names[j-1] );

}

}

}

}

swap(char *s1, char *s2)

{

char *temp;

temp = *s1;

*s1= *s2;

*s2= temp;

}

LIMITATION OF ARRAY OF POINTERS TO STRING

When we are using a two dimension array of characters we can either initialise the strings where we are declaring the array or receive(accept) the string using scanf(). However, when we are using an array of pointers to strings we can initialise the strings at the place where we are declaring the array, we cannot accept the strings from keyboard using scanf().

i.e., code like,

…………..

…………..

char *names[3];

printf("Enter a name : ");

scanf("%s", name[i] );

…………

…………

Doesn't work because when we are declaring the array it is containing garbage values, and it is wrong to send these garbage values to scanf() as the addresses where it should keep the strings received from the keyboard.

Write a function month_name(int n);, which returns a pointer to a character string containing the name of the n^th month.

char *month_name(int n)

{

static char *name[]={ "Illegal Month Number", "January", "February", "March", "April", "May",\

"June", "July", "August", "September", "October", "November", "December"

};

return( (n<1 || n>12) ? name[0] : name[n]) ;

}

COMMAND LINE ARGUMENTS

Command line arguments are the information made available to the program by writing it after the program name on the command line of the operating system. The command line arguments are used to pass information into the main() when program begins executing.

main() can take two arguments usually called argc and argv and the information contained in the command line is passed on to the main() through these arguments, when main() is called up by the system.

The variable argc is an argument counter, which holds the number of arguments including the program name on the command line, and is an integer. The argv is an argument vector and represents an array of character pointers that point to the command line arguments. Any type of argument in the command line is treated as a string. The size of this array will be equal to the value of argc. You can access the individual arguments by indexing (subscripting) argv.

The first parameter in the command line is always the program name and therfore argv[0] always represents the program name, argv[1] points to the first argument and so on. The argc^th element points to NULL.

syntax : main( int argc, char *argv[])

{

.......

......

}

for example, if we want to execute a program to copy the contents of a file named file1 to another file named file2, then the command line like,

C:\>DUP file1 file2

Where DUP is the executable program file name. Here argc is 3 and argv is as shown below,

Q). Write a program to simulate the ECHO command available under DOS

# include

main(int argc, char *argv[])

{

int i;

for(i=1; i
{

printf("%s\t",argv[i] );

}

}

OR

# include

main(int argc, char *argv[])

{

int i=1;

while(argv[i]!=NULL)

{

printf("%s\t",argv[i++] );

}

}

OR

# include

main(int argc, char *argv[])

{

int i=1;

while(i
{

printf("%s\t",*argv );

argv++;

}

}

if any numeric value contained in the command line arguments will also passed to the main() as a string. Therefore you must convert it to numeric before processing using library functions like atoi(), atol(), atof() etc.

Q. Write a program to print the specified no. of dots(.) .

/* dots.c */

# include

void main(int argc, char *argv[])

{

int i;

if(argc < 2)

{

printf("You must specify a number");

printf(" with the program name \n");

printf("Try again");

exit(1);

}

for(i=1; i<=atoi(argv[1]); i++)

putchar('.');
printf("%s completed", argv[0]);

putchar(7); /* to create a beep sound */

}

An example program execution, C:\> dots 20

 A program with command line arguments should issue instructions, if the user attempts to run the program without proper information. The command line arguments give the program a professional appearance. It is not necessary that you should always use the variable names argc and argv. In place of them any other valid variable name can be used.

Q1. Write a program tail, which prints the last 'n' lines of the specified file. By default, n is 10. But it can be changed by an optional command line argument. ie., tail file1 should print the last 10 lines of file1, and tail file2 15 should print the last 15 lines of file2.

Q2. Write a program head, which prints the first n lines of the specified.(use command line arguments)

Q3. Write a program to simulate the DOS external command FILD which prints the lines of the given file that contains the given word. There are options that changes the default meaning.

n - line numbers before each line

c - only total no. of lines

i - ignore case difference

x - will print each line that doesn’t match the given word

FUNCTIONS RETURNING POINTERS

The way functions return an int, a float, a double or any other data type, it can also return a ointer(address). To make a function return a pointer it has to be mentioned in the calling function as well as in the function declaration (prototype).

Syntax: datatype *function-name (arguments);

eg: (1)

# include

main()

{

int *p;

int *function();

p=function;

printf("%u -- %d",p,*p);

}

s

int *function()

{

int i=20;

return(&i);

}

eg: (2)

# include

float *function(float *r);

main()

{

float p=45.67, q=28.94, *x;

c=&p;

printf("Before calling *x = %f\n",*x);

x=function(&p);

printf("After calling *x = %f\n",*x);

getch();

}

float *function(float *r)

{

r=r+1;

return(r);

}

eg: (3)

# include

char *addstring(char *s1, char *s2);

main()

{

char s1[30],s2[10], *ptr;

printf("Enter first string : "); gets(s1);

printf("Enter second string : "); gets(s2);

ptr=addstring(s1,s2);

printf("\nAfter addition S1 = %s",ptr);

getch();

}

char *addstring(char *s1, char *s2)

{

int i,j;

for(i=0; s1[i]!=NULL; i++); Version 1

for(j=0; s2[j]!=NULL; s1[i]=s2[j],i++,j++);

return s1;

}

char *addstring(char *s1, char *s2)

{

int i,j;

for(i=0; s1[i]!=NULL; i++); Version 2

for(j=0; (s1[i]=s2[j])!=NULL;i++,j++);

return s1;

}

char *addstring(char *s1, char *s2)

{

char *ptr=s1;

for(;*s1!=NULL;s1++);s1--; Version 3

for(;(*s1=*s2)!=NULL;s1++,s2++);

return ptr;

}

char *addstring(char *s1, char *s2)

{

char *ptr=s1;

for(;*s1++!=NULL;);s1--; Version 4

for(;(*s1++=*s2++)!=NULL;);

return ptr;

}

char *addstring(char *s1, char *s2)

{

char *ptr=s1;

for(;*s1++;); s1--; Version 5

for(;*s1++ = *s2++;);

return ptr;

}

POINTERS TO FUNCTIONS

Even though a function is not a variable it has a physical location in memory that can be assigned to a pointer. A function’s address is the entry point of the function. Because of this, a function pointer can be used to call a function.

In ‘C’, as each function is compiled, source code is transformed into object code and an entry point is established. When a call is made to a function while your program is running, a machine language call is made to this point. Therefore, if a pointer contains the address of a function’s entry point, it can be used to call that function.

To obtain the address of a function, use the function’s name without any parentheses and arguments.

syntax: datatype (*ptr)();

The above declaration tells that ptr is a pointer to a function which returns the specified datatype.

eg: int (*ptr)();

ptr = strcmp;

To invoke the function using function pointer use the syntax, (*ptr)();

eg: to invoke the strcmp function,

(*ptr)(string1,string2);

Sample Program (1) To show functions also have address

# include

main()

{

int show();

printf(“Address of function show = %u “,show);

show();

}

show()

{

printf(“This is a sample program”);

}

Sample Program (2) Using pointer to function

# include

int show();

main()

{

int (*ptr)();

ptr=show;

printf(“Address of function show = %u “,ptr);

(*ptr)(); /* to invoke the function show using the pointer to function */

}

show()

{

printf(“This is the second sample program”);

}

Sample Program (3) Comparing two strings for equality

# include

# include

void check( char *a, char *b, int (*cmp)() );

main()

{

char s1[80],s2[80];

int (*ptr)();

ptr=strcmp;

printf(“Enter first string : “); gets(s1);

printf(“Enter second string : “); gets(s2);

check(s1,s2,ptr);

}

void check(char *a, char *b, int (*cmp)() )

{

if( !(*cmp)(a,b) )

printf(“Equal”);

else

printf(“Not equal”);

}

UNIONS

A union is a memory location that is shared by two or more different variables, generally of different types, at different times. Defining a union is similar to defining a structure, using the keyword union.

syntax :

Directory: downloads
downloads -> Northern England’s set-jetting locations
downloads -> Dynatest 3031 lwd light Weight Deflectometer
downloads -> Forth coming competitive exams
downloads -> Brush High School Morning Announcements Friday, September 05, 2014 all school
downloads -> Year 9 The Arts — Music
downloads -> Years 7 and 8 standard elaborations — Australian Curriculum: Music draft
downloads -> Chris Young sets 2016 “I’m Comin’ Over” Tour headlining dates
downloads -> Slavery and Abolition: the Plymouth Connection Introduction
downloads -> Summer Assignment

Download 0.91 Mb.

Share with your friends: