---

Hvis vi har
void* pVoid;
int *pInt;

Hvad er så lige den praktiske forskel mellem at skrive

pInt=reinterpret_cast<int*>(pVoid);
og
pInt=(int*)pVoid;

Den sidste metode, som jeg normalt anvender, er da noget kortere at skrive,
og gør tilsyneladende det samme. reinterpret_cast laver jo alligevel ingen
validering af konverteringen.. så vidt jeg da kan se.

---

Hej

> Hvad er så lige den praktiske forskel mellem at skrive
> pInt=reinterpret_cast<int*>(pVoid);
> pInt=(int*)pVoid;

Den første cast er skrevet i C++ og den anden i C. De opnår det samme (ved
reinterpret_cast<> - de andre C++ casting operatorer har andre semantics,
som du sikkert ved). Under C++ standardiseringen var der oprindeligt lagt op
til, at C-style casts helt skulle bortfalde - man valgte dog alligevel at
bibeholde dem af hensyn til legacy kode.

Du bør anvende 1. løsning hvis du skriver C++ og din compiler understøtter
de "nye" casting operators. Med de nye cast operatorer indikerer man
tydeligt sin intention med cast'en, og det bliver dermed langt lettere at
finde frem til system-specifikke casts (og resultatet af en
reinterpret_cast<> er uvægerlig platform/system-specifikt). Ved at bruge
reinterpret_cast<> angiver du eksplicit at her har du anvendt en usikker
cast, med de risici og porteringsproblemer det kan give. Det giver noget at
lede efter for folk der fx skal porte koden. Endelig anses C-style casts
faktisk som 'deprecated' i C++ - de kan teoretisk set blive fjernet fra
fremtidige revisioner af C++ standarden.

/\/\\ads Orbesen Troest

---

"J Hansen" <send.no.mail@here.please> wrote in message
news:apucu9$5ib$1@news.cybercity.dk...

> Hvis vi har
> void* pVoid;
> int *pInt;
>
> Hvad er så lige den praktiske forskel mellem at skrive
>
> pInt=reinterpret_cast<int*>(pVoid);
> og
> pInt=(int*)pVoid;

Som Mads Orbesen Troest allerede har skrevet, så er fordelen ved "new style
casts" at man angiver intentionen, og hvis det man skriver ikke er det man
mente, så brokker compileren sig.
New style casts er: static_cast, dynamic_cast, const_cast og
reinterpret_cast.

I dit tilfælde bør du skrive

pInt = static_cast<int*>(pVoid);

Det er veldefineret (og portabelt) at cast'e en void* til en int*, hvis
pointeren "i virkeligheden" peger på en int. Derfor er der ikke brug for
reinterpret_cast. Reglerne for casts er indviklede, men jeg mener at
hovedreglen for reinterpret_cast er at det har uspecificeret effekt (dvs.
uportablet), og man bør derfor undgå den.
reinterpret_cast er "motorsaven" i cast-branchen. Hvis man
reinterpret_cast'er en Foo til en Bar, så tager den bare motorsaven for at
få Foo'en til at passe ind i en Bar-kasse .

Der hvor jeg oftest er nødt til at reinterpret_cast'e, er mellem char* og
unsigned char*. Det er desværre uportabelt, da man ikke er garanteret noget
om byte-repræsentationen af negative chars.
Hvor ville livet dog være nemmere hvis "unsigned char" var synonym med
"char", og hvis "signed char" var en syntaksfejl.

Iøvrigt, en lille forskel på "gammel" cast (dvs. "(int*)") og de nye casts,
er at kun const_cast kan ændre const og volatile. Det kan ikke engang
reinterpret_cast.

Følgende er ulovligt:
const void* p = /* ... */
int* ip = reinterpret_cast<int*>(p);

Man skal gøre sådan:
int* ip = const_cast<int*>(static_cast<const int*>(p));


Mvh. Bjarke