Kopiowanie klasy pochodnej przekazanej przez wskaźnik

Cześć, mam pytanie: mam klasę bazową (abstrakcyjną) po której dziedziczę.
Chciałem się dowiedzieć czy jest jakiś sposób, by w innej, niezależnej klasie przechowywać kopię (nie oryginał) dowolnego obiektu dziedziczonego po klasie bazowej?
Przykładowo miałbym funkcję set_object(KlasaBazowa* object); i teraz pytanie jak z takiego obiektu przekazanego przez wskaźnik utworzyć jego kopię?

class KlasaBazowa
	{
	//...
	virtual void jakas_funkcja() = 0;
	//...
	};

class KlasaPochodna1 : public KlasaBazowa
	{
	//...
	};
class KlasaPochodna2 : public KlasaBazowa
	{
	//...
	};
class InnaKlasaPrzechowującaKopieObiektow
	{
	void set_object(KlasaBazowa* object);	//...
	KlasaBazowa* kopia;	//jak tutaj zapisać kopie (nie oryginał) przekazywanych obiektów?

	//chciałbym w tej klasie operować na kopii przekazanego obiektu a nie na oryginale...
	};

Innymi słowy: czy da się zrobić kopię obiektu klasy pochodnej przekazanego przez wskaźnik do klasy bazowej?

Nie ma takiej możliwości, trzeba to obejść w jeden ze sposobów:

1. tworzysz w klasie bazowej virtual KlasaBazowa *clone(); i nadpisujesz ją w każdej z klas
2. tworzysz template<class T> KlasaBazowa *copy(KlasaBazowa *) { return new T(*(T*)KlasaBazowa); } oraz map<type_info,KlasaBazowa *(*copy)()> wypełniasz ją i korzystasz.
   Są oczywiście inne sposoby

Dzięki, tego się obawiałem...
pozdrawiam.

#include <iostream>
#include <memory>

class Base
{
public:
	Base() {}

	virtual ~Base() {}
};

class A : public Base
{
public:
	A() {}
};

class B : public Base
{
public:
	B() {}
};

class Copies
{
public:
	Copies() : a_{ false, A() }, b_{ false, B() } {}

	void setCopy(Base* base)
	{
		if(A* a = dynamic_cast<A*>(base))
			a_ = std::make_pair(true, *a);
		else if(B* b = dynamic_cast<B*>(base))
			b_ = std::make_pair(true, *b);
		else
			std::cout << "Unknown object";
	}

	void printCurrentState()
	{
		std::cout << "A: " << a_.first << std::endl;
		std::cout << "B: " << b_.first << std::endl;
	}

private:
	std::pair<bool, A> a_;

	std::pair<bool, B> b_;
};

int main()
{
	std::unique_ptr<Base> p1(new A());
	std::unique_ptr<Base> p2(new B());

	Copies c;
	c.setCopy(p1.get());
	c.setCopy(p2.get());

	c.printCurrentState();

	return 0;
}

http://ideone.com/uibqZW

Twoj problem nazywa sie tak: http://en.wikipedia.org/wiki/Object_slicing
A tu jest calkiem dobry opis rozwiazania w c++ (dokladnie 1 rozwiazanie od @_13th_Dragon) http://nerdland.net/2009/06/covariant-templatized-virtual-copy-constructors/