Thanks Don!
Two things I was trying to catch:
1) Read the file into linked list, each line for a node which is a structure with two members: roll_num (int) and name (char array or char *); This is similar to my old post when I tried to parse file as 4-line record, i.e. every four line is a record.
2) Save the linked list to a new file.
For point 1), the problem with my code is the first and last record (i.e. nodes) of the linked list were always wrong---printed incorrectly.
No! It printed exactly what you stored in those locations. Using fread() to copy ASCII characters from a file into an object of type int in your structure doesn't automatically convert from a string to an integer.
You need to use something like atoi() to convert from a string into an integer. Perhaps the following will show what you were doing (using a union instead of your structure to show what happens when you interpret characters from a string as an integer. Store the following program in a file named string_vs_int.c:
Then note that the 1st five characters in your input file are "10001". Your use of fread() reads characters into the int at the start of your structure, just like the sample program above does using the union. Note that the number in red from your quote matches the numbers in red from my sample program!
Note that the above was run on a Intel x86 family CPU with int being an integer type occupying 4 bytes. With a different sized int, you will get different results. With a different CPU you might get different results. (The byte order of least significant byte to most significant byte in an int varies from CPU architecture to CPU architecture.)
Quote:
Originally Posted by yifangt
For Point 2) my code was just not working at all, so that the corresponding part Line 30 ~ Line 40 were commented out.
For point 1) an extra question in my mind is using char pointer instead of char array, how to accomplish the same job? as pointer is still a big challenge for me, especially when dynamic memory allocation is related.
I am trying to understand the FILE stream and memory allocation with malloc() for file manipulation. (The next step is to do some manipulation of each node, say change each roll_num, modify the name, or add another member for each node, etc. But I am not able to do it at this moment.)
Since the size of your current structure is about 132 bytes long (4 byte int, 120 byte char array, and 8 byte pointer), you are reading the 1st 132 bytes from your input file into the first element of your linked list,
Yes, that's what I was trying. I had thought of wrong mem allocation, so that I was thinking to use char pointer for name instead of char array for dynamic memory allocation. I know I am too far from this point.
Yes, it is clear that you still don't understand pointers. Hopefully the sample program at the end of this post will provide an understandable template. And, it appears that you thought fread() reads lines from a file. But, fread() doesn't care about line boundaries; it just copies the specified number of bytes from your input file into the supplied buffer.
Quote:
Originally Posted by yifangt
So, lines 30 to 40 are just a single comment to the C compiler and no code is being executed in this comment.
Yes, I did that on purpose because it did not work.
If you verify that what I listed above is what you're trying to do,
Yes, that's what I was trying to do!
I'll try to come up with an example that shows how to do that in the next couple of days.
Great! Thank you very much for your time.
If you save, build, and run the following C program:
Code:
#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.
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.
while(head) {
printf("\nPrinting list element located at %p:\n", head);
printf("\troll_num: %d\tname: %s\n", head->roll_num,
head->name);
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);
}
and you run it in the directory that contains the input file you specified in the 1st post in this thread, you'll get output similar to the following:
Code:
Read input line: 10001 Angola
24 bytes allocated at 0x105800890 for linked list element
7 bytes allocated at 0x1058008b0 for name Angola
Read input line: 10002 Bangalore
24 bytes allocated at 0x1058008c0 for linked list element
10 bytes allocated at 0x1058008e0 for name Bangalore
Read input line: 10003 Cairo
24 bytes allocated at 0x1058008f0 for linked list element
6 bytes allocated at 0x105800910 for name Cairo
Read input line: 10004 Dallas
24 bytes allocated at 0x105800920 for linked list element
7 bytes allocated at 0x105800940 for name Dallas
Read input line: 10005 Edmonton
24 bytes allocated at 0x105800950 for linked list element
9 bytes allocated at 0x105800970 for name Edmonton
Read input line: 10006 Fargo
24 bytes allocated at 0x105800980 for linked list element
6 bytes allocated at 0x1058009a0 for name Fargo
Read input line: 10007 Georgia
24 bytes allocated at 0x1058009b0 for linked list element
8 bytes allocated at 0x1058009d0 for name Georgia
Read input line: 10008 Halifax
24 bytes allocated at 0x1058009e0 for linked list element
8 bytes allocated at 0x105800a00 for name Halifax
Read input line: 10009 Indianapolis
24 bytes allocated at 0x105800a10 for linked list element
13 bytes allocated at 0x105800a30 for name Indianapolis
Read input line: 10010 Jamaica
24 bytes allocated at 0x105800a40 for linked list element
8 bytes allocated at 0x105800a60 for name Jamaica
End-of-file found on input.
Printing list element located at 0x105800890:
roll_num: 10001 name: Angola
Freeing name (0x1058008b0) and list element (0x105800890) space.
Printing list element located at 0x1058008c0:
roll_num: 10002 name: Bangalore
Freeing name (0x1058008e0) and list element (0x1058008c0) space.
Printing list element located at 0x1058008f0:
roll_num: 10003 name: Cairo
Freeing name (0x105800910) and list element (0x1058008f0) space.
Printing list element located at 0x105800920:
roll_num: 10004 name: Dallas
Freeing name (0x105800940) and list element (0x105800920) space.
Printing list element located at 0x105800950:
roll_num: 10005 name: Edmonton
Freeing name (0x105800970) and list element (0x105800950) space.
Printing list element located at 0x105800980:
roll_num: 10006 name: Fargo
Freeing name (0x1058009a0) and list element (0x105800980) space.
Printing list element located at 0x1058009b0:
roll_num: 10007 name: Georgia
Freeing name (0x1058009d0) and list element (0x1058009b0) space.
Printing list element located at 0x1058009e0:
roll_num: 10008 name: Halifax
Freeing name (0x105800a00) and list element (0x1058009e0) space.
Printing list element located at 0x105800a10:
roll_num: 10009 name: Indianapolis
Freeing name (0x105800a30) and list element (0x105800a10) space.
Printing list element located at 0x105800a40:
roll_num: 10010 name: Jamaica
Freeing name (0x105800a60) and list element (0x105800a40) space.
Obviously, the pointers malloc() and calloc() return to you will vary from OS to OS (and are even highly likely to change even if you run the same program with the same data on the same machine twice).
Hopefully, there are enough comments in the code to demonstrate how to build a linked list, load data into the structures in the linked list, walk through the linked list to get data out of the list, and to deallocate the data after it is no longer needed.
Note that I use fgets() to read lines (rather than fread() to read buffers) from the input file. Note that since your input file has data that has to be converted from strings to integers and has variable length names, each line is read into an input buffer and then a linked list element structure is allocated for each line read and space to hold the name found on that input line is allocated for that list element's name field. Then data is copied into those allocated spaces. That allocated space CANNOT be freed until it is no longer going to be used.
Always determine how much space you need, allocate that much space (or more), and then copy your data into that space -- in that order. If you copy data into an uninitialized pointer or copy more data into an allocated space than was allocated, hard-to-track-down strange things may happen when copying the data, in the statement after you copied the data, or hundreds of statements after you copied the data. Check, double-check, and triple-check that you have allocated the space you need, have copied the correct data into your allocated space, and don't use any allocated space after it has been freed. Know when you have arrays of characters that don't (always) have a null byte terminator and either make sure you add a null terminator or never treat that array as a string. (Did you notice that u.c[] in the 1st program in this posting is printed using the format string %.4s instead of %s? That was done because that array will not have a null byte string terminator for any command line argument that contains for or more characters!)
Note that a couple of comments in this code start with XXX. They are reminders for code that should be added, but is not included in this sample. Filling in those missing data verification checks is left as an exercise for the reader.
This User Gave Thanks to Don Cragun For This Post:
Hello,
I am having a problem setting a range of numbers for the "case" structure.
I can use with no problems, but
when I use it doesn't work???
Does the case struture allow numeric ranges?
eg:
echo -e "enter number between 0 and 60: \c"
read $answer
case $answer in
) echo... (2 Replies)
Hi,
I want to read the task_struct structure in Linux in order to get the names & pids of all processes.
How can this be done??
Thanks in adv,
molu (4 Replies)
Hi folks,
Need your help.
I am writing a KSH script to read a few commands from a file & execute.
I am using the following code to read the file line by line & excute each command. When I am printing each line I see it is printing properly but while excuting, the particular "ps" command... (5 Replies)
Hi All,
These are the two ways i tried to read file but i getting work with second one not with the first.
char buf; // Defining space for buf
ctrlfnum = fopen(filename_arr.control_fname,"r");
1) n = fread(buf,sizeof(buf),1,ctrlfnum); ============== (not works)
2) n =... (4 Replies)
Hi
When im listing (ls -al ) its listing directories without / at the end of directories
dir1 dir2 dir3
and i need to list directories with
dir1/ dir2/ dir3/ and this should not be made by command ls -F
/ should be embedded at the last
since one of the scripts reads directories... (1 Reply)
Hi,
I have a following problem in C.
I have a function A in which I used to call another function (function B) and pass an array of values through array variable by using below:-
foo=functionB(array);
In functionB, i used to just return some "values" (e.g return num;) in order to pass... (1 Reply)
hi
One of our SCO 5.0.6 server is crashing every second or third time during rebooting with kernel panic.
According to this SCO manual:
http://wdb1.sco.com/kb/showta?taid=106181&qid=1689366546&sid=504668569&pgnum=1
I've saved dump image into a floppy and I've done the following steps:
#... (0 Replies)
How can I use malloc with copying/creating files?
Is this the correct way?
I'm a bit confused...
int in_fd;
int *out_fd;
char buffer;
in_fd = open(av, O_RDONLY);
out_fd = malloc(strlen(av)+strlen(av)+2);
sprintf"(buffer,%s/%s", av,av); (5 Replies)
I am using Solaris 10u11 on x86 machine, i am root, i want to use a gcc compiled code to use read10/write10 function of USCSI solaris library to access data from a normal USB mass storage device.
I am able to open a device prior to sending USCSI command via IOCTL.
IOCTL command works ok as... (0 Replies)
