Kostet ein Cast was?

Kostet der Laufzeit?

natürlich, wie sollte es denn gehen ohne rechenleistung zu benötigen?

DrGreenthumb

Ich würde sagen, bis auf dynamic_cast findet das während des kompilierens statt.

Der cast ist ja nur ein Mittel um den Compiler zu überzeugen, dass er etwas eigentlich syntaktisch falsches, trotzdem akzeptieren soll.

japro

Original erstellt von DrGreenthumb:
**Ich würde sagen, bis auf dynamic_cast findet das während des kompilierens statt.

Der cast ist ja nur ein Mittel um den Compiler zu überzeugen, dass er etwas eigentlich syntaktisch falsches, trotzdem akzeptieren soll.**

static_cast ist sicher nicht kompilerzeit....

ChrisM

reinterpret_cast kostet keinen Prozessortick mehr, static_cast ein wenig (oder auch viel, bei großen Klassen) und dynamic_cast am meisten, da zur Laufzeit erst noch die RTTI-Prüfung durchgeführt werden muss.

ChrisM

Gerard

Original erstellt von ChrisM:
**reinterpret_cast kostet keinen Prozessortick mehr, static_cast ein wenig (oder auch viel, bei großen Klassen) und dynamic_cast am meisten, da zur Laufzeit erst noch die RTTI-Prüfung durchgeführt werden muss.

ChrisM**

das stimmt so nicht,
wills du mir sagen das

int main()
{
    float a = 100.0
    int b = static_cast<int>( a );
}

was kostet?
und

int main()
{
    float a;
    cin >> a;
    int b = reinterpret_cast<int>( a );
}

nix?

Mr. N

@Dimah: ChrisM hat vollkommen recht.

ChrisM

Genau das will ich sagen, Dimah. Ein static_cast kostet immer etwas, weil eine Konvertierung durchgeführt werden muss und ein reinterpret_cast ist genauso wie ein const_cast ohne Overhead (das soll aber nicht als Argument dienen, auch nur einen const_cast zu verwenden!!), weil er nur dazu dient, die Typsicherung des Compilers aufzuhebeln und den Compiler zu sagen, wie er die Daten interpretieren soll.

ChrisM

ChrisM

So, ein Test von mir, der Code für die cout's ist bei reinterpret_cast genau gleich!

1:    #include <iostream>
2:
3:    int main()
4:    {
00401560 55                   push        ebp
00401561 8B EC                mov         ebp,esp
00401563 83 EC 48             sub         esp,48h
00401566 53                   push        ebx
00401567 56                   push        esi
00401568 57                   push        edi
00401569 8D 7D B8             lea         edi,[ebp-48h]
0040156C B9 12 00 00 00       mov         ecx,12h
00401571 B8 CC CC CC CC       mov         eax,0CCCCCCCCh
00401576 F3 AB                rep stos    dword ptr [edi]
5:        int test = 10;
00401578 C7 45 FC 0A 00 00 00 mov         dword ptr [ebp-4],0Ah
6:        void *test2 = &test;
0040157F 8D 45 FC             lea         eax,[ebp-4]
00401582 89 45 F8             mov         dword ptr [ebp-8],eax
7:
8:        std::cout << test << std::endl;
00401585 68 C8 10 40 00       push        offset @ILT+195(std::endl) (004010c8)
0040158A 8B 4D FC             mov         ecx,dword ptr [ebp-4]
0040158D 51                   push        ecx
0040158E B9 E0 67 47 00       mov         ecx,offset std::cout (004767e0)
00401593 E8 67 FB FF FF       call        @ILT+250(std::basic_ostream<char,std::char_traits<char> >::operator<< ) (004010ff)
00401598 8B C8                mov         ecx,eax
0040159A E8 46 FC FF FF       call        @ILT+480(std::basic_ostream<char,std::char_traits<char> >::operator<< ) (004011e5)
9:        std::cout << reinterpret_cast<int>(test2) << std::endl;
0040159F 68 C8 10 40 00       push        offset @ILT+195(std::endl) (004010c8)
004015A4 8B 55 F8             mov         edx,dword ptr [ebp-8]
004015A7 52                   push        edx
004015A8 B9 E0 67 47 00       mov         ecx,offset std::cout (004767e0)
004015AD E8 4D FB FF FF       call        @ILT+250(std::basic_ostream<char,std::char_traits<char> >::operator<< ) (004010ff)
004015B2 8B C8                mov         ecx,eax
004015B4 E8 2C FC FF FF       call        @ILT+480(std::basic_ostream<char,std::char_traits<char> >::operator<< ) (004011e5)
10:
11:       return 0;
004015B9 33 C0                xor         eax,eax
12:   }
004015BB 5F                   pop         edi
004015BC 5E                   pop         esi
004015BD 5B                   pop         ebx
004015BE 83 C4 48             add         esp,48h
004015C1 3B EC                cmp         ebp,esp
004015C3 E8 58 EF 01 00       call        __chkesp (00420520)
004015C8 8B E5                mov         esp,ebp
004015CA 5D                   pop         ebp
004015CB C3                   ret

ChrisM

DrGreenthumb

Aber was wird denn beim static_cast während der Laufzeit "konvertiert" ? Ich meine, entweder es lässt sich nicht compilieren und der Compiler beschwert sich, oder es lässt sich compilieren und es läuft, oder das Programm stürzt ab weil irgendwas total daneben war.

Btw, das ganze ist völlig wurst, weil man eh immer dann castet wenn man's muss. Da gibts nix wo man überlegen könnte aus Geschwindigkeitsgründen darauf zu verzichten.

davie

bevor du dynamic_castest solltest du dir auch im klaren sein, wieso und vielleicht dein design neu überdenken.
damit will ich nicht sagen, dass dynamic_cast sinnlos ist. man sollte es sich nur genau überlegen!

Shade Of Mine

sekunde!
warum soll Dimah unrecht haben?
ein cast kostet nichts (es sei denn der cast Operator ist überladen worden und dort wird code ausgeführt) aber führ builtings kostet es nix.

warum? weil ein type nur auf C++ ebene existiert!
Ob cout einen char als char oder als int interpretiert steht bereits zur compile Time fest. (deshalb gibt es auch die Meldung: 'kein überladener operator<< für xxx')

rüdiger

@davie

man sollte es sich nur genau überlegen!

soll man das nicht immer machen, bevor man castet? Ich seh eigentlich keinen Grund dynamic_cast nicht zu benutzen, weil der dynamic_cast sicher ist, falls etwas daneben geht, erhalte ich eben NULL. Natürlich kostet das was.

japro

Original erstellt von Shade Of Mine:
warum? weil ein type nur auf C++ ebene existiert!
Ob cout einen char als char oder als int interpretiert steht bereits zur compile Time fest. (deshalb gibt es auch die Meldung: 'kein überladener operator<< für xxx')

ok jetzt hab ich folgenden code:

float f = 1/rand();
std::cout << static_cast<int>(f) << std::endl;

irgendwie muss der float doch in den int konvertiert werden... und da der wert des floats zur kompilerzeit noch nicht feststeht kostet er auch was...

[ Dieser Beitrag wurde am 19.04.2003 um 11:43 Uhr von japro editiert. ]

ChrisM

warum? weil ein type nur auf C++ ebene existiert!
Ob cout einen char als char oder als int interpretiert steht bereits zur compile Time fest. (deshalb gibt es auch die Meldung: 'kein überladener operator<< für xxx')

Richtig, aber wenn du z.B. einen float einfach als int interpretierst, hast du eine komplett andere Zahl. Der static_cast sorgt dafür, dass der float nach int konvertiert wird, also z.B. Nachkommastellen abgeschnitten werden.

ChrisM

DrGreenthumb

Ist doch egal welcher Wert sich hinter der Variable versteckt. Letztendlich müssen doch nur die Bytes hin und hergeschoben werden.
Und mit dem Cast sagt man halt dem Compiler, das er es erlauben soll.

float f = 1.23f;
004322FE  mov         dword ptr [f],3F9D70A4h 
    int i = static_cast<int>(f);
00432305  fld         dword ptr [f] 
00432308  call        @ILT+7755(__ftol2) (42FE50h) <-- hier wird noch ne konvertierungsfunktion aufgerufen
0043230D  mov         dword ptr [i],eax

Daniel E.

reinterpret_cast bildet Bitmuster auch nicht zwingend Eins zu Eins ab; darum läuft er auch nicht unbedingt in konstanter Zeit ab.

Irgendwie verwirrt mich dieser Thread. Was ist eigemtlich das derzeitige Thema?

entelechie

aeh nur mal so ne zwischenfrage:
wen interessiert das, ob der cast was kostet?!

Warum schmeissen die nicht einfach den static_cast raus und bieten dafür Umwandelfunktionen a la FloatToInt etc. Das wär doch viel schicker.