Thread: writing linked structures

I assume you mean a linked list. To write them to the HD, (file format wise) you can use fwrite() (check msdn for info on how to use it). To print the data to the screen, check out this psuedo-code. Well, I guess it's more just code where you get to change the variable names

Code:

node *current=&headnode;

while(current)
{
   cout<<current->data<<endl;
   current=current->next;
}

Edit: If your last node's next isn't NULL, I will keel j00! And this code won't work properly. Initialize your pointers to NULL, boys and girls.

If you've learned about classes, I would suggest making your linked list nodes into a class. Here's what a basic prototype could look like - I'll leave the coding to you.

Code:

class bytes		
{
	public:
		void adddata(unsigned char add);	//this function adds data to the list
		bytes(void);				//constructor
		~bytes(void);				//destructor
		void printlist();			//prints list...quite optional
	private:
		unsigned char data;			//Piece of data
		bytes *next;				//pointer to the next node in the (unsorted) linked list
};

//I'll throw in a basic adddata function for you too, just so you can see it

bytes::adddata(unsigned char add)
{
	//this function is called from the head node, so
	//"this" points there
	bytes *current=this;
	while (current->next)
	{
		current=current->next
	}
	current->next=new *bytes;
	if (current->next)
		current->next->data=add;
}

Haha, forgot that I was on the C board. Oh well. Some of what I said is still valid :P For example, suggesting fwrite(), although I didn't give example code for it.

That is horrible. Do not use it. w00tsoft, do you understand the purpose for a linked list? New nodes should be dynamically allocated - that's why you use a linked list in the first place. All you're doing is creating a really inefficient array with severe limitations - it looks like a linked list, but it's useless for real work. Not to mention the complete lack of descriptive variable names in your "example," which is going to confuse the crap out of anyone who doesn't already know what they are doing with a linked list.

Originally posted by w00tsoft
It works quite well for me, but of course I made the LL_LEAF beginning of the structure so it would save an extra call to malloc in my application. The reason to use a linked list isn't so new nodes will be dynamically allocated; it's because it's a much more efficent method of storage if you do multiple adds or deletes. The code I pasted manages to add and delete without looping through the list at all. You are quick to flame things that are different than the traditional method.

I actually laughed when I read that. Out loud. You obviously don't know what you are talking about at all.

Your code doesn't add a new node unless it is statically declared already and your ll_add() function is passed the address. That's not what you're supposed to do with a linked list. You could allocate the memory dynamically in some other function, of course, turning it into a legitimate linked list, but it would be a lot better idea to allocate it in your ll_add() function. A linked list is made so that you can have a variable number of nodes - for when you can't tell how many you'll need at run time when you are coding it. When you "delete" a node in a linked list, when you do it properly, you're deallocating the memory for it, and when you add a node, you're allocating the memory for it. In both instances, you set the pointers on other nodes accordingly. Gah, go read a linked list tutorial, I'm not going to write one for you.

I'm happy you find humor in my posts. My IRCd code requires that I malloc a structure for my information, and then your "definition" of a linked list requires that I malloc a node. I wrote the code to eliminate this useless extra call to malloc.

You are quick to flame things that are different than the traditional method.

EDIT: Maybe if I made the example malloc, you would see what i'm talking about. It's late, so I decided to just use static variables. Should work either way.

Using fwrite/fread has already been suggested as an option. Please be aware that this solution is inherently not portable. That is, it will work as long so you are using the same OS, compiler, and compile options; beyond that, results may vary.

If you want something portable, also consider using fprintf/fscanf. This suggests you write to and read from a file as text. This can also have the advantage of being "human readable/maintainable". See also Q2.11 and Q20.5.