static_castvs dynamic_castvs reinterpret_castinternals downcast / upcast görünüm
Bu cevapta, somut bir inişli çıkışlı / inişli çıkış örneğinde bu üç mekanizmayı karşılaştırmak ve nasıl karşılaştırıldığına dair somut bir anlayış sağlamak için altta yatan işaretlere / bellek / düzeneğe ne olduğunu analiz etmek istiyorum.
Bunun, bu yayınların nasıl farklı olduğu konusunda iyi bir sezgi vereceğine inanıyorum:
static_cast: çalışma zamanında bir adres ofseti yapar (düşük çalışma zamanı etkisi) ve bir downcast'in doğru olduğunu kontrol etmez.
dyanamic_cast: çalışma zamanında aynı adres ofsetini yapar, aynı static_castzamanda ve RTTI kullanarak bir downcast'in doğru olup olmadığını pahalı bir güvenlik kontrolü yapar.
Bu güvenlik denetimi, bir temel sınıf işaretçisinin çalışma zamanında belirli bir türde olup nullptrolmadığını, geri dönüşünü geçersiz bir downcast işaret ettiğini kontrol ederek sorgulamanızı sağlar .
Bu nedenle, kodunuz bunu kontrol edemiyor nullptrve geçerli bir iptal edilmedi eylemi gerçekleştiremiyorsa, yalnızca static_castdinamik döküm yerine kullanmanız gerekir .
Bir iptal işlemi kodunuzun gerçekleştirebileceği tek işlemse, belki de yalnızca dynamic_casthata ayıklama yapılarını ( -NDEBUG) etkinleştirmek ve hızlı çalışmalarınızı yavaşlatmamak için static_castörneğin burada yapıldığı gibi başka şekilde kullanmak istersiniz .
reinterpret_cast: çalışma zamanında hiçbir şey yapmaz, adres ofseti bile. İşaretçi, temel sınıfın bile çalışmadığından tam olarak doğru türün üzerine gelmelidir. Ham bayt akışları sürece genellikle bunu istemezsiniz.
Aşağıdaki kod örneğini düşünün:
main.cpp
#include <iostream>
struct B1 {
B1(int int_in_b1) : int_in_b1(int_in_b1) {}
virtual ~B1() {}
void f0() {}
virtual int f1() { return 1; }
int int_in_b1;
};
struct B2 {
B2(int int_in_b2) : int_in_b2(int_in_b2) {}
virtual ~B2() {}
virtual int f2() { return 2; }
int int_in_b2;
};
struct D : public B1, public B2 {
D(int int_in_b1, int int_in_b2, int int_in_d)
: B1(int_in_b1), B2(int_in_b2), int_in_d(int_in_d) {}
void d() {}
int f2() { return 3; }
int int_in_d;
};
int main() {
B2 *b2s[2];
B2 b2{11};
D *dp;
D d{1, 2, 3};
// The memory layout must support the virtual method call use case.
b2s[0] = &b2;
// An upcast is an implicit static_cast<>().
b2s[1] = &d;
std::cout << "&d " << &d << std::endl;
std::cout << "b2s[0] " << b2s[0] << std::endl;
std::cout << "b2s[1] " << b2s[1] << std::endl;
std::cout << "b2s[0]->f2() " << b2s[0]->f2() << std::endl;
std::cout << "b2s[1]->f2() " << b2s[1]->f2() << std::endl;
// Now for some downcasts.
// Cannot be done implicitly
// error: invalid conversion from ‘B2*’ to ‘D*’ [-fpermissive]
// dp = (b2s[0]);
// Undefined behaviour to an unrelated memory address because this is a B2, not D.
dp = static_cast<D*>(b2s[0]);
std::cout << "static_cast<D*>(b2s[0]) " << dp << std::endl;
std::cout << "static_cast<D*>(b2s[0])->int_in_d " << dp->int_in_d << std::endl;
// OK
dp = static_cast<D*>(b2s[1]);
std::cout << "static_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "static_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
// Segfault because dp is nullptr.
dp = dynamic_cast<D*>(b2s[0]);
std::cout << "dynamic_cast<D*>(b2s[0]) " << dp << std::endl;
//std::cout << "dynamic_cast<D*>(b2s[0])->int_in_d " << dp->int_in_d << std::endl;
// OK
dp = dynamic_cast<D*>(b2s[1]);
std::cout << "dynamic_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "dynamic_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
// Undefined behaviour to an unrelated memory address because this
// did not calculate the offset to get from B2* to D*.
dp = reinterpret_cast<D*>(b2s[1]);
std::cout << "reinterpret_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "reinterpret_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
}
Aşağıdakilerle derleyin, çalıştırın ve sökün:
g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
setarch `uname -m` -R ./main.out
gdb -batch -ex "disassemble/rs main" main.out
nerede çalıştırmayı karşılaştırmayı kolaylaştırmak için ASLR'yi devre dışı bırakmaksetarch için kullanılır .
Olası çıktı:
&d 0x7fffffffc930
b2s[0] 0x7fffffffc920
b2s[1] 0x7fffffffc940
b2s[0]->f2() 2
b2s[1]->f2() 3
static_cast<D*>(b2s[0]) 0x7fffffffc910
static_cast<D*>(b2s[0])->int_in_d 1
static_cast<D*>(b2s[1]) 0x7fffffffc930
static_cast<D*>(b2s[1])->int_in_d 3
dynamic_cast<D*>(b2s[0]) 0
dynamic_cast<D*>(b2s[1]) 0x7fffffffc930
dynamic_cast<D*>(b2s[1])->int_in_d 3
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940
reinterpret_cast<D*>(b2s[1])->int_in_d 32767
Şimdi, sanal yöntem çağrılarını verimli bir şekilde desteklemek için https://en.wikipedia.org/wiki/Virtual_method_table adresinde belirtildiği gibi , bellek veri yapısı aşağıdaki Dgibi görünmelidir:
B1:
+0: pointer to virtual method table of B1
+4: value of int_in_b1
B2:
+0: pointer to virtual method table of B2
+4: value of int_in_b2
D:
+0: pointer to virtual method table of D (for B1)
+4: value of int_in_b1
+8: pointer to virtual method table of D (for B2)
+12: value of int_in_b2
+16: value of int_in_d
Anahtar gerçek şu ki, içerisindeki bellek veri yapısı D, içerideki B1ve B2dahili olanla uyumlu olan bellek yapısını içerir .
Bu nedenle kritik sonuca ulaşıyoruz:
upcast veya downcast yalnızca işaretçi değerini derleme zamanında bilinen bir değere kaydırmalıdır.
Bu şekilde, Dtemel tür dizisine geçtiğinde, cast türü aslında bu dengeyi hesaplar ve tam olarak B2bellekte geçerli gibi görünen bir şeyi işaret eder :
b2s[1] = &d;
Dbunun yerine bunun için vtable olması B2ve bu nedenle tüm sanal çağrılar şeffaf bir şekilde çalışır.
Şimdi nihayet tip dökümüne ve somut örneğimizin analizine geri dönebiliriz.
Stdout çıktısından şunu görüyoruz:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
Bu nedenle, static_castorada yapılan örtük D, 0x7fffffffc930'daki tam veri yapısından 0x7fffffffc940'takine B2benzer bir şekilde ofseti doğru bir şekilde hesapladı . Ayrıca, 0x7fffffffc930 ve 0x7fffffffc940 arasında yatan şeyin muhtemelen B1veri ve vtable olduğunu da çıkarıyoruz.
Sonra, downcast bölümlerinde, geçersiz olanların nasıl başarısız olduğunu ve nedenini anlamak artık kolay:
static_cast<D*>(b2s[0]) 0x7fffffffc910: derleyici sadece denemek ve B2içeren bir denemek için derleme zamanı bayt 0x10 gittiD
Ancak b2s[0]bir a olmadığı için D, şimdi tanımlanmamış bir hafıza bölgesine işaret ediyor.
Sökme:
49 dp = static_cast<D*>(b2s[0]);
0x0000000000000fc8 <+414>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x0000000000000fcc <+418>: 48 85 c0 test %rax,%rax
0x0000000000000fcf <+421>: 74 0a je 0xfdb <main()+433>
0x0000000000000fd1 <+423>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x0000000000000fd5 <+427>: 48 83 e8 10 sub $0x10,%rax
0x0000000000000fd9 <+431>: eb 05 jmp 0xfe0 <main()+438>
0x0000000000000fdb <+433>: b8 00 00 00 00 mov $0x0,%eax
0x0000000000000fe0 <+438>: 48 89 45 98 mov %rax,-0x68(%rbp)
yani GCC'nin şunları yaptığını görüyoruz:
- işaretçinin NULL olup olmadığını kontrol edin ve evet ise NULL döndürün
- Aksi ulaşması ondan 0x10 çıkarma
Dyok ki
dynamic_cast<D*>(b2s[0]) 0: C ++ aslında kadronun geçersiz olduğunu ve geri döndüğünü buldu nullptr!
Bunun derleme zamanında yapılmasının bir yolu yoktur ve bunu sökme işleminden doğrulayacağız:
59 dp = dynamic_cast<D*>(b2s[0]);
0x00000000000010ec <+706>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x00000000000010f0 <+710>: 48 85 c0 test %rax,%rax
0x00000000000010f3 <+713>: 74 1d je 0x1112 <main()+744>
0x00000000000010f5 <+715>: b9 10 00 00 00 mov $0x10,%ecx
0x00000000000010fa <+720>: 48 8d 15 f7 0b 20 00 lea 0x200bf7(%rip),%rdx # 0x201cf8 <_ZTI1D>
0x0000000000001101 <+727>: 48 8d 35 28 0c 20 00 lea 0x200c28(%rip),%rsi # 0x201d30 <_ZTI2B2>
0x0000000000001108 <+734>: 48 89 c7 mov %rax,%rdi
0x000000000000110b <+737>: e8 c0 fb ff ff callq 0xcd0 <__dynamic_cast@plt>
0x0000000000001110 <+742>: eb 05 jmp 0x1117 <main()+749>
0x0000000000001112 <+744>: b8 00 00 00 00 mov $0x0,%eax
0x0000000000001117 <+749>: 48 89 45 98 mov %rax,-0x68(%rbp)
İlk olarak bir NULL kontrolü vardır ve çıkış NULL ise NULL döndürür.
Aksi takdirde, RDX, RSI ve RDI ve çağrılarda bazı argümanlar kurar __dynamic_cast.
Bunu daha fazla analiz etmek için sabrım yok, ancak diğerlerinin söylediği gibi, bunun çalışmasının tek yolu __dynamic_cast, sınıf hiyerarşisini temsil eden bazı ekstra RTTI bellek içi veri yapılarına erişmektir.
Bu nedenle B2, bu tablonun girişinden başlamalı , sonra bu tür hiyerarşisinde bir tür Dtahmini için vtable'ı bulana kadar yürümelidir b2s[0].
Bu yüzden dökümün yeniden yorumlanması potansiyel olarak pahalıdır! İşte bir dönüştürücü bir astar yama örnek dynamic_casta static_castkarmaşık bir projede% 33 çalışma zamanı düşük! .
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940bu sadece bize körü körüne inanıyor: bir Dadres olduğunu söyledik b2s[1]ve derleyici ofset hesaplama yapmıyor.
Ancak bu yanlıştır, çünkü D aslında 0x7fffffffc930'dadır, 0x7fffffffc940'ta olan şey D içindeki B2 benzeri yapıdır! Böylece çöp kutusuna erişilir.
Bunu -O0, değeri sadece hareket ettiren korkunç montajdan doğrulayabiliriz:
70 dp = reinterpret_cast<D*>(b2s[1]);
0x00000000000011fa <+976>: 48 8b 45 d8 mov -0x28(%rbp),%rax
0x00000000000011fe <+980>: 48 89 45 98 mov %rax,-0x68(%rbp)
İlgili sorular:
Ubuntu 18.04 amd64, GCC 7.4.0 üzerinde test edilmiştir.