folgendes:

Class A
{
public:
A(int t):type(t){}
virtual ~A();

int type;//Oder welcher Typ auch immer
}

Class B
:public A
{
B()
:A(B_TYPE)
{}
}

//... andere Children von A

int main
{
    A* a = some_A_child_ptr;
    if(a->type == B_TYPE)
    {
       B* b = B::Convert(a); //Hierum gehts
       //...
    }
    else if(a->type == C_TYPE)
    {
       C* c = C::Convert(a); //Hierum gehts
       //...
    }
    //...
    return 0;
}

Es müsste doch möglich sein eine Templatekonvertierungsfunktion (o.ä.) zu bauen, die jedes Child von A erbt und entsprechend ihres eigenen Typs "verwendet".

Irgendwas in der Art (kenne mich in dem Bereich leider noch nicht aus, daher vllt komplett unsinnig):

class A
{
public:
 decltype(TYPE OF THIS) Convert(A* a)
 {
     return static_cast<decltype(TYPE OF THIS)*>(this);
 }
}

Ebenso, dass für jede abgeleitete Klasse entsprechend die Konvertierungsfunktion den Basisklassenzeiger in einen Childzeiger umwandelt.

Vielen Dank für jede Hilfe

Aber Downcasts sind oft ein Zeichen von schlechtem Design.

Zu deinem Lösungsvorschlag:

Das suche ich nicht
Wie man das im speziellen macht ist schon klar, ich würde nur gerne eine verallgemeinerte Methode in die Basisklasse einbauen, welche in den abgeleiteten Klassen automatisch einen Zeiger auf die Basisklasse in einen Zeiger auf die abgeleitete Klasse umwandelt.

...ich würde nur gerne eine verallgemeinerte Methode in die Basisklasse einbauen, welche in den abgeleiteten Klassen automatisch einen Zeiger auf die Basisklasse in einen Zeiger auf die abgeleitete Klasse umwandelt.

Das geht nicht vernünftig. Zielführender ist es zu überlegen wozu du einen Zeiger auf die abgeleitete Klasse brauchst. Wahrscheinlich willst du eine Memberfunktion aufrufen. Diese muss dann halt virtuell in der Basisklasse schon vorhanden sein.
Alternativ einfach einen Container pro abgeleiteter Klasse benutzen und den Zeiger gar nicht erst in einen Basisklassenzeiger umwandeln.

Das suche ich nicht
Wie man das im speziellen macht ist schon klar, ich würde nur gerne eine verallgemeinerte Methode in die Basisklasse einbauen, welche in den abgeleiteten Klassen automatisch einen Zeiger auf die Basisklasse in einen Zeiger auf die abgeleitete Klasse umwandelt.

Das wandelt den Zeiger um.
Wo ist der Unterschied ob du jetzt

B *b = B::convert(a);

oder das schreibst?

Effektiv gibts keinen Unterschied, eben wegen des static_castes in der Wrapperfunktion.
Ich finde es allerdings leserlicher und schöner. Desweiteren interessiert es mich, wie man mit C++-Mitteln in der abgeleiteten Klasse automatisch die passende Funktion generiert.

Da das eine statische Funktion ist, geht das nicht so einfach.
Du musst da schon in jeder Klasse explicit den Code hinschreiben.
Alternativ auch folgender CRTP-Trick:

template <class Derived>
class converter
{
public:
	template <typename Base>
	static decltype(static_cast<Derived*>(ptr)) convert(Base *ptr)
	{
		return static_cast<Derived*>(ptr);
	}

protected:
	~converter() noexcept = default;	
};

Das decltype als Rückgabewert spart mir ein hässliches enable_if<is_base_of<...>>.
Nutzt du dann so:

class B : public A, public converter<B>
{...};

Vielen Dank für deine Hilfe