[Eclipse Reborn]

I don't know if I understand them correctly, but from what I've read so far, they store everything in the same memory location.

Ex:

union test
{
	unsigned long	Count;
	unsigned long	Size;
	char*			Name;
	unsigned short	Len;
};

int main()
{
	test ut;
	
	ut.Count	= 20;
	ui.Size		= 15;
	
	ui.Name		= (char*)malloc(5);
	strcpy_s(ui.Name, 4, "test");
	
	ui.Len		= 15;
	
	free(ui.Name);
	return 0;
}

Now are there all stored in the same memory location?

Ex:

Count       Size        Name           Len
00 00 00 20 00 00 00 15 xx xx xx xx 00 00 15

[OnlineCop]

You're going to have a problem with that pointer in there. The pointer itself will take up 4 (or 8) bytes. But "Count", for example, will have a HUGE value (since the value will be something like 0XF3EA4F8A). And if you increment "Count" by 1, the pointer will no longer point to the first "t" in "test" but point to the "e" in "test". You could not use them interchangeably.

So for your last question, "Count" and "Size" actually start in the exact same place. If you set "Count" to 12, then "Size" will equal 12, the pointer to "Name" will be pointing to address 12 (or 0x0000000C), and "Len" would be 12. Not pretty.

[Eclipse Reborn]

Ah, ok think I'll pass on unions then.

[woppix]

from what i know about unions, they will allow you to access the same information different ways because each method of accessing that information points to the same location in memory.

This post has been edited by woppix: 14 August 2010 - 06:02 PM

[OnlineCop]

One use of unions that I thought was well-done was an IP address converted to an integer. Another is to test whether the platform you were using was big-endian or little-endian:

union endian {
   char bytes[4];
   int integer;
};

int main()
{
   endian end;

   end.integer = 255;

   if (end.bytes[3] == 255) printf("Big Endian\n");
   else if (end.bytes[0] == 255) printf("Little Endian\n");
   else printf("Undetermined. Maybe 64-bit machine?\n")

   return 0;
}

Untested. I may have the big- and little-endian tests backward, but it will essentially fill bytes 0-3 with a value of either "0xFF000000" or "0x000000FF" depending on endianness. 64-bit machines will actually do the same type of thing, but use up 8 bytes instead of 4.