Unions are used to minimize memory waste. For example, consider the following database-transaction class used to update a person’s data. The key can be either a unique ID number or a person’s last name, but never both at once:

 class UpdateDetails {	private:	enum keytype{ keystring, keyID} key;	char *name;	long ID;	//...	UpdateDetails(const char *n): key(keystring),						n (new char [strlen)n) +1]	 					{strcpy(name,n);} 	UpdatePersonalDetails(long id) : ID(id), key(keyID) {}};

Clearly, memory is wasted here since only one of the keys can be used in each transaction. An anonymous union (for instance, an embedded union having neither a tag-name nor an instance name) can be used in this case to avoid memory waste:

 class UpdateDetails {	enum keytype{ keystring, keyID} key;	union {  //anonymous union: 1. has no tag name,		char *name;		long ID };    // 2. and no instance name.public:UpdateDetails(const char *n) : key (keystring), 						 n (new char [strlen(n) +1] 						{strcpy(name, n);} 	UpdateDetails(long id) : ID(id), key(keyID) {};	//...};

The advantage over an ordinary union is that in this case, the members of an anonymous union are accessed directly:

 void  UpdateDetails::GetID() const {   if (key == keyID)    return ID;//anonymous union member, accessed like ordinary member  return 0L;  //indicate string key is used }