Welcher der beiden Varianten würdet ihr nehmen?

//1. Variante
void* Array = new char[10];
unsigned char DrittesByte = reinterpret_cast<unsigned char*>(Array)[2];

//2. Variante
void* Array = new char[10];
unsigned char DrittesByte = *(reinterpret_cast<unsigned char*>(Array) + 2);

MfG, EOutOfResources

EDIT: Klammer gefixt

char* Array = new char[s][1][/s][10];
char drittesZeichen = Array[2];

Warum willst du überhaupt mit void-Zeigern hantieren?

Die Frage ist eher warum du einen solchen Cast machen musst. Aber ganz pragmatisch würde ich die erste Variante nehmen, weil es imo natürlicher ist zuerst das Array wieder in das umzuwandeln was es eigentlich ist und dann den Zugriff ganz normal zu machen (ggf. den cast in einer eigenen Variable verpackt).

@CStoll:
Das würde ich so nicht machen (1->10). ^^

Warum willst du überhaupt mit void-Zeigern hantieren?

Das ist ein Beispiel. Im echten Code muss es so sein.

CStoll schrieb:

Warum willst du überhaupt mit void-Zeigern hantieren?

Das ist ein Beispiel. Im echten Code muss es so sein.

Und mit welchem Hintergedanken?

@drakon: nun tu doch nicht so, als ob dir noch nie ein Tippfehler passiert ist

Und mit welchem Hintergedanken?

Heterogener Container. Aber meine Frage wurde bis jetzt erst von drakon beantwortet.

boost::any. Hat nebenbei auch noch Kopiersemantiken. void* ist die dümmste Form von Type Erasure.

Vielen Dank. Kann niemand ausser drakon meine Frage beantworten?

(und wenn du es doch unbedingt benötigst, sind beide Varianten gleichwertig)

Beschreib doch mal die konkrete Situation, wo du so etwas überhaupt benötigt. In den meisten Fällen dürfte es eine bessere Lösung geben als mit void-Zeigern und reinterpret_cast<> zu hantieren.

(und wenn du es doch unbedingt benötigst, sind beide Varianten gleichwertig)

Ist nicht eigentlich static_cast<> der 'richtige' cast für diesen Fall oder kann man laut Standard sowohl reinterpret_cast<> als auch static_cast<> verwenden?

Kann niemand ausser drakon meine Frage beantworten?

Ich kann Dir vielleicht sagen, was Du tun solltest, wenn Du sagst, was Du bezwecken willst. Heterogene Container? Und die verwalteten Typen haben gar nichts miteinander zu tun? Kann ich mir nicht vorstellen, wenn's nicht gerade ein Allokator ist.

----

EOutOfResources schrieb:

Kann niemand ausser drakon meine Frage beantworten?

Variante 1, nur dass ich static_cast statt reinterpret_cast verwenden würde.

MfG, EOutOfResources

@314159265358979:
Ich glaube nicht dass du mit der Erfahrung die du (kaum) hast qualifiziert bist Aussagen darüber zu treffen welche Form von Type-Erasure schlau oder dumm ist.

Das glaube ich schon

hustbaer schrieb:

Mal ganz davon abgesehen dass wir alle (noch) nicht wissen was EOutOfResources wirklich vor hat.

Da hast du Recht, war wohl etwas zu voreilig.

OK. Ich schreibe einen heterogenen Container. Der Container an und für sich merkt sich die Typen nicht. Deshalb void* . Jedoch biete ich ein Hilfskonzept an. Wenn zum Beispiel ein int gepusht wird, wird ein Handler zurückgegeben. Dieser Handler kennt den Typ und kann mit der entsprechenden Variable alles tun was er will. Wenn man diese Variable wieder entfernen will, kann man entwerder im Container die Bytes x - y löschen oder man sagt dem Handler einfach, er soll das tun. Und nun, wenn der Handler den int ausgeben soll, dann Caste ich einen bestimmten Teil des Arrays der Containers.

Und was ist daran jetzt besser, als wenn Du virtuelle Funktionen nehmen würdest?

Außerdem hast Du bei der Beschreibung noch um den heißen Brei geredet. Ist das ein Betriebsgeheimnis? Dann müßte ich hier abbrechen, weil mir die Zeit zu schade ist, Hilfeversuche durch Geheimniskrämerei torpedieren zu lassen. Dafür müßte Geld fließen.

Und was ist daran jetzt besser, als wenn Du virtuelle Funktionen nehmen würdest?

Genau wegen Antworten wie diesen will ich nicht sagen, worum es geht. Ich habe beschlossen wie ich es mache. Wenn ich dazu Hilfe brauchen würde, würde ich es sagen.

hustbaer schrieb:

@314159265358979:
Ich glaube nicht dass du mit der Erfahrung die du (kaum) hast qualifiziert bist Aussagen darüber zu treffen welche Form von Type-Erasure schlau oder dumm ist.

Das glaube ich schon

Das zeigt nur wie sehr du dich überschätzt.

Wie viele Zeilen produktiv eingesetzten Code hast du schon geschrieben?
Wie viele Programme > 10 KLOC von dir hast du > 6 Monate nach fertigstellung schon gewartet?

Und nochwas: das geht auch alles etwas freundlicher. Vonwegen "die dümmste Art" und so.

volkard schrieb:

Und was ist daran jetzt besser, als wenn Du virtuelle Funktionen nehmen würdest?

Genau wegen Antworten wie diesen will ich nicht sagen, worum es geht. Ich habe beschlossen wie ich es mache. Wenn ich dazu Hilfe brauchen würde, würde ich es sagen.

Hihi.
Statistisch gesehen bedeutet das du bist dir im Klaren darüber dass was du vor hast Unsinn ist, willst es aber aus einem bestimmten Grund trotzdem machen.

OK. Ich schreibe einen heterogenen Container. ...

Da dürfte die Frage, wie du die Rohdaten anzusprechen hast, wohl dein kleinstes Problem sein (so etwas ist eine Stilfrage und hat im fertigen Programm keine Auswirkungen). Das geht los mit dem korrekten Alignment der im Container verpackten Objekte und endet bei der Frage, wer nun dafür zuständig ist, die Destruktoren dieser Objekte aufzurufen.

@XPille: Ich hab' nicht angefangen mit den reinterpret_cast's

@XPille: Ich hab' nicht angefangen mit den reinterpret_cast's

Hab ich auch nie behauptet...