class Client
{
public:
	virtual ~Client();
};

class Player : public Client
{
};

void doSomething(Client **clients, size_t count);

int main()
{
	Player **players = new Player*[20];
	players[0] = new Player();

	//Player** kann nicht in Client** konvertiert werden.
	doSomething(players, 1);

	//ist sowas angebracht?
	doSomething(reinterpret_cast<Client**>(players), 1);

	delete players[0];
	delete[] players;
}

Spricht irgendwas dagegen?

Naja, Player wird ja in der Regel größer sein als Client (wenn die Klassen mal mehr als leere Hüllen sind) und dann wird der Cast ordentlich schiefgehen. Warum benutzt du nicht Polymorphie? Das virtual verwendest du ja schon und genau dafür ist Polymorphie doch gedacht.

Die Zeiger auf beide Typen sind aber gleich groß, sonst wäre der Cast auch gar nicht möglich. Und wie soll ich hier Polymorphie verwenden, denn bei der Sache sind Methoden von Client unerheblich. Ich brauche einfach eine andere Möglichkeit, die Array-Elemente zu übergeben, falls das mit dem reinterpret_cast nicht so das Wahre ist.

Die Zeiger auf beide Typen sind aber gleich groß, sonst wäre der Cast auch gar nicht möglich.

Das ist konfus. Jeder beliebige Objektzeiger kann in einen beliebigen anderen Objektzeiger verwandelt werden (u.U. mit UB).

TyRoXx schrieb:

Spricht irgendwas dagegen?

Warum sollte man so etwas machen wollen? Elemente von Arrays - oder, was das betrifft, jedes beliebigen Standard-Containers - sind nie polymorph.

So etwas

doSomething(reinterpret_cast<const Client* const*>(players), 1);

könnte u.U. gerade noch funktionieren, ist aber unportabel (und formal undefiniert).

void doSomething(Client* client);

welche nur den einen Client bearbeitet.
Für alle clients machst du dann sowas:

std::for_each(clients, clients+size, doSomething);

http://cplusplus.com/reference/algorithm/for_each/

Ansonsten, wenn es denn auch portabel sein soll, kannst du dir ne Funktion schreiben, die ein Array + size entgegen nimmt, und dann alle Elemente einzeln gecastet in ein neues Array packt und zurück gibt.