Volitelne id zlozene z viacerych typov – C / C++ – Fórum – Programujte.com

Mam program kde mam mnozstvo tried ktore su odvodene z bazovej triedy ktora ma atribut ID. Tento atribut moze byt typu std::string alebo int(vzdy ma len jeden typ), casom mozno bude moct mat viecej typov . Zaroven ale moze nastat moznost ze objekt nema ziadne id(porovnanie id-eciek 2 objektov kotre nemaju specifikovane id sa musy vyhodnoti ako false). Rad by som bol aby sa zbytocne nealokovala pamet na heape v std::string ak nie je treba (rychlost programu je dvolezita).

Zatial to riesim tak ze atribut ID je typu Id:

class Id{
		union{
			std::string	name;
			int key;
		};
		enum class type_e{
			String,
			Key,
			Unknown
		};
		type_e type;

	public:
		Id():type(type_e::Unknown){}
		Id(const std::string &name):type(type_e::String){
			new(&this->name) std::string(name);
		}
		Id(int key):type(type_e::Key){
			this->key = key;
		}
		Id(const Id& id){
			switch(id.type){
				case type_e::String:
					new(&this->name) std::string(id.name);
					type = type_e::String;
					break;
				case type_e::Key:
					key = id.key;
					type = type_e::Key;
					break;
				case type_e::Unknown:
					type = type_e::Unknown;
					break;
			}
			return;
		}
		Id(Id&& id){
			switch(id.type){
				case type_e::String:
					name = std::move(id.name);
					type = type_e::String;
					id.type = type_e::Unknown;
					break;
				case type_e::Key:
					key = id.key;
					type = type_e::Key;
					break;
				case type_e::Unknown:
					break;
			}
			return;
		}
		Id& operator=(const Id& id){
			if(id.type != type){
				//treba uplne prerobyt pri zmene type_e
				if(id.type == type_e::String){
					new(&this->name) std::string(id.name);
					type = type_e::String;
				}
				else if(type == type_e::String){
					name.~string();
					key = id.key;
					type = id.type;

				}
			}
			else{
				switch(type){
					case type_e::String:
						name = id.name;
						break;
					case type_e::Key:
						key = id.key;
						break;
					case type_e::Unknown:
						break;
				}
			}
			return *this;
		}
		bool operator==(const Id& id)const{
			if(id.type == type){
				switch(type){
					case type_e::String:
						return (name == id.name);
					case type_e::Key:
						return (key == id.key);
					case type_e::Unknown:
						return false;
				}
			}
			return false;
		}
		bool operator!=(const Id& id)const{
			if(id.type == type){
				switch(type){
					case type_e::String:
						return (name != id.name);
					case type_e::Key:
						return (key != id.key);
					case type_e::Unknown:
						return true;
				}
			}
			return true;
		}

		~Id(){
			if(type == type_e::String)name.~string();
		}
};

Neda sa to riesit dako pomocou stl (pripadne boost... )? Ak nie, je ta trieda co mam dobre? (valgrind mi zatial nic nenasiel) 

Není to dobře. Name se ti vždycky vytvoří a zruší (a key je nepoužitelný). A do toho na něm vytváříš a rušíš další string. Překvapuje mě, že to funguje. Neřve to už při překladu, že máš string v unionu?

V Boost je Variant a Any, ale to je tady asi zbytečné, prostě tam vraz ukazatel.

#2 zlz
prekladam to v rezime c++11, takze mozem mat v unione aj typy s netrivialnym konstruktorom, nevyhoda je ze sa nevolaju ani konstruktory a ani destruktory, cize ich musim volat rucne. 

coz nemeni nic na tom, ze je to prasarna...  pouzij ten boost nebo si udelej vlastni polymorfni tridu na ulozeni tech hodnot

skusim pouzit ten boost::variant, dik.

Nepomohlo by ti skôr, keby si v bázovej triede len definoval operácie == a !=  a potom v odvodených triedach si tam dáš ID akého typu potrebuješ?