Sprawdzanie rodzaju figury w szachach

Hey.
Które rozwiązanie jest lepsze?

class Figura
{
public:
    virtual bool toPionek() { return false; }
    virtual bool toWieza()  { return false; }
    virtual bool toKun()     { return false; }
    //itd.
}

class Wieza : Figura
{
    bool toWieza() { return true; }
}

czy
class Figura
{
virtual string rodzaj() const {}
}

class Wieza : Figura
{
string rodzaj() const { return "wieza"; } //i potem jakies porownanie
}

?

#include <iostream>
#include <string>
#include <vector>
#include <memory>

enum class RodzajFigury : int
{
	Pionek,

	Hetman
};

class Figura
{
public:
	Figura(RodzajFigury const& rodzaj) : rodzaj_(rodzaj) {}

	RodzajFigury rodzaj() const { return rodzaj_; }

protected:
	RodzajFigury rodzaj_;
};

class Pionek : public Figura
{
public:
	Pionek() : Figura(RodzajFigury::Pionek) {}
};

class Hetman : public Figura
{
public:
	Hetman() : Figura(RodzajFigury::Hetman) {}
};

int main()
{
	std::vector<std::unique_ptr<Figura> > figury;
	figury.emplace_back(new Pionek);
	figury.emplace_back(new Hetman);

	for(auto const& figura : figury) {
		std::cout << static_cast<int>(figura->rodzaj()) << std::endl;
	}

	return 0;
}

pole nazwa_ możesz swobodnie używac bez getowania w klasach pochodnych (Hetman, Pionek)

edit:
podmiana stringa na enum w snippecie

Żadne z nich. Nie powinieneś nigdzie potrzebować tego sprawdzać. To powinien za ciebie załatwiać polimorfizm. Jeśli potrzebujesz sprawdzić z jaką figurą masz do czynienia to znaczy że projekt jest do wyrzucenia i musisz to zaprojetkować od nowa.