Programming

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct student {
        int             roll_num;
        char            *name;
        struct student  *next;
}       *head,          // Pointer to first element in the linked list.
        *temp;          // When creating the linked list, a pointer to current
                        // element in the linked list; when deleting the linked
                        // list, a pointer to the next element in the list.

        // Note that both head and temp are initialzed to NULL pointers because
        // they are declared globally; not on the stack in main().

        // Note also that no linked list elements have been allocated yet (we
        // have allocated two pointers to structures, but no structures);
        // space for structures will be allocated as needed as lines are read
        // from the input file.

int main(int argc, char *argv[]) {
        char            buffer[120];    // input buffer
        FILE            *fptr;          // input stream pointer
        size_t          len;            // length of name
        char            *p;             // pointer to name in buffer[]

        fptr = fopen("INFILE.txt", "r");
        if(fptr == NULL) {
                fprintf(stderr, "%s: fopen(INFILE.txt) failed.\n", argv[0]);
                exit(1);
        }

        // Read input file into a linked list...
        // Note that fgets() reads no more than one line (up to a given number
        // of bytes)from a file; fread() reads a given number of bytes without
        // regard to line boundaries.
        while(fgets(buffer, sizeof(buffer), fptr)) {
                // XXX Should verify that fgets() returned a complete line.
//yifangt                printf("Read input line: %s", buffer);

                // Allocate space for this element of the linked list.
                // Note that using calloc() instead of malloc() initializes
                // temp->next (in the newly allocated structure) to a NULL
                // pointer.  (It also fills any space between structure
                // elements (if there is any) to null bytes.  This isn't
                // important for this example, but can be important if
                // structures are to be examined in a core dump or compared.)
                if(head == NULL)
                        // Create 1st element in the linked list.
                        temp = head = calloc(1, sizeof(struct student));
                else    // Add new element to the end of the linked list.  Note
                        // that the temp->next in the next statement is in the
                        // previous element in the linked list and then temp is
                        // set to a pointer to the (new) current element.
                        temp = temp->next = calloc(1, sizeof(struct student));
                if(temp == NULL) {
                        fprintf(stderr,
                                "%s: calloc() for linked list element failed.\n",
                                argv[0]);
                        exit(2);
                }
                printf("%d bytes allocated at %p for linked list element\n",
                        (int)sizeof(struct student), temp);

                // Convert numeric string at start of buffer to int.
                temp->roll_num = atoi(buffer);

                // skip over number and 1st space to find start of name.
                // XXX Should check for string overflow for badly formed input.
                for(p = buffer; *p++ != ' ';);

                // Allocate space and copy name.  Note that strlen() will
                // include space for the trailing newline character but not for
                // the terminating null byte.  But, we'll replace the newline
                // with a null byte before we copy the name from buffer[] to
                // the space we allocated for name in this linked list element.
                len = strlen(p);
                if((temp->name = malloc(len)) == NULL) {
                        fprintf(stderr, "%s: malloc(%d) for name failed.\n", argv[0], (int)len);
                        exit(3);
                }
                // Change trailing newline to string terminator.
                *(p + len - 1) = '\0';
                // Copy name into allocated space.  Note that len includes the
                // null byte that termiantes the string.
                strncpy(temp->name, p, len);
        printf("%d bytes allocated at %p for name %s\n\n", (int)len,
                        temp->name, temp->name);
        }

        // To get to here, we either hit EOF or detected an I/O error.
        if(ferror(fptr)) {
                fprintf(stderr, "%s: I/O error reading input.\n", argv[0]);
                exit(4);
        }
        fclose(fptr);
       printf("End-of-file found on input.\n");

        // We have now completed reading the input into a linked list.  Note
        // that temp->next (the pointer to the next element in the last element
        // in the linked list) is a NULL pointer.

        // Writing a linked list to a file doesn't make any sense.  The pointers
        // in the structures have no meaning in a file and won't be valid if
        // read back into another process.

        // For this example, we'll just print the data from the linked list and
        // free the space reserved for the elements after each element is
        // printed.  Obviously, we could reformat the data and save it in a file
        // but for this demo, showing what we have in the linked list seems more
        // important.

        printf("\nPrinting list element located at %p:\n", head);
        while(head) {
                printf("roll_num: %d\tname: %s\n", head->roll_num, head->name);
//yifangt        printf("Freeing name (%p) and list element (%p) space.\n",
        //                head->name, head);
                free(head->name);
                // Note that we can't reference head->next after we free head,
                // so we need to save the pointer to the next element before we
                // free the current element.
                temp = head->next;
                free(head->next);
                head = temp;
                // Note that head now points to the 1st remaining element of
                // the linked list again, if there are any elements left.  It is
                // a NULL pointer if no elements remain in the list.
        }

        // We have now freed all of the space we allocated for the linked list
        // elements and the space we allocated for the names associated with
        // each element in the linked list.
        return(0);
}

24 bytes allocated at 0x10a000890 for linked list element
7 bytes allocated at 0x10a0008b0 for name Angola

24 bytes allocated at 0x10a0008c0 for linked list element
10 bytes allocated at 0x10a0008e0 for name Bangalore

24 bytes allocated at 0x10a0008f0 for linked list element
6 bytes allocated at 0x10a000910 for name Cairo

24 bytes allocated at 0x10a000920 for linked list element
7 bytes allocated at 0x10a000940 for name Dallas

24 bytes allocated at 0x10a000950 for linked list element
9 bytes allocated at 0x10a000970 for name Edmonton

24 bytes allocated at 0x10a000980 for linked list element
6 bytes allocated at 0x10a0009a0 for name Fargo

24 bytes allocated at 0x10a0009b0 for linked list element
8 bytes allocated at 0x10a0009d0 for name Georgia

24 bytes allocated at 0x10a0009e0 for linked list element
8 bytes allocated at 0x10a000a00 for name Halifax

24 bytes allocated at 0x10a000a10 for linked list element
13 bytes allocated at 0x10a000a30 for name Indianapolis

24 bytes allocated at 0x10a000a40 for linked list element
8 bytes allocated at 0x10a000a60 for name Jamaica

End-of-file found on input.

Printing list element located at 0x10a000890:
roll_num: 10001	name: Angola
roll_num: 10002	name: Bangalore
roll_num: 10003	name: Cairo
roll_num: 10004	name: Dallas
roll_num: 10005	name: Edmonton
roll_num: 10006	name: Fargo
roll_num: 10007	name: Georgia
roll_num: 10008	name: Halifax
roll_num: 10009	name: Indianapolis
roll_num: 10010	name: Jamaica

yifangt@box $ gcc -o readf -Wall readfile.c  
yifangt@box $ ./readf 

24 bytes allocated at 0x1797250 for linked list element
7 bytes allocated at 0x1797270 for name Angola

24 bytes allocated at 0x1797290 for linked list element
10 bytes allocated at 0x17972b0 for name Bangalore

24 bytes allocated at 0x17972d0 for linked list element
6 bytes allocated at 0x17972f0 for name Cairo

24 bytes allocated at 0x1797310 for linked list element
7 bytes allocated at 0x1797330 for name Dallas

24 bytes allocated at 0x1797350 for linked list element
9 bytes allocated at 0x1797370 for name Edmonton

24 bytes allocated at 0x1797390 for linked list element
6 bytes allocated at 0x17973b0 for name Fargo

24 bytes allocated at 0x17973d0 for linked list element
8 bytes allocated at 0x17973f0 for name Georgia

24 bytes allocated at 0x1797410 for linked list element
8 bytes allocated at 0x1797430 for name Halifax

24 bytes allocated at 0x1797450 for linked list element
13 bytes allocated at 0x1797470 for name Indianapolis

24 bytes allocated at 0x1797490 for linked list element
8 bytes allocated at 0x17974b0 for name Jamaica

End-of-file found on input.

Printing list element located at 0x1797250:
roll_num: 10001    name: Angola
roll_num: 24736352    name: Bangalore
roll_num: 24736416    name: Cairo
roll_num: 24736480    name: Dallas
roll_num: 24736544    name: Edmonton
roll_num: 24736608    name: Fargo
roll_num: 24736672    name: Georgia
roll_num: 24736736    name: Halifax
roll_num: 24736800    name: Indianapolis
roll_num: 24736864    name: Jamaica

                if(head == NULL)
                        // Create 1st element in the linked list.
                        temp = head = calloc(1, sizeof(struct student));
                else    // Add new element to the end of the linked list.  Note
                        // that the temp->next in the next statement is in the
                        // previous element in the linked list and then temp is
                        // set to a pointer to the (new) current element.
                        temp = temp->next = calloc(1, sizeof(struct student));

                if(head == NULL) {
                        // Create 1st element in the linked list.
                        head = calloc(1, sizeof(struct student));
                        temp = head;
                } else {// Add new element to the end of the linked list.  Note
                        // that the temp->next in the next statement is in the
                        // previous element in the linked list and then temp is
                        // set to a pointer to the (new) current element.
                        temp->next = calloc(1, sizeof(struct student));
                        temp = temp->next;
                }