static_cast＜T＞(m) 的汇编解释

原创 于 2023-06-08 18:13:36 发布 · 134 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#汇编 #c++

文章探讨了静态类型转换在C++中的实现，特别是如何通过调用operatorT()函数来实现。同时，它也分析了std::move()函数内部如何利用这种转换，强调了在资源管理中的作用，以及对编译器优化的影响。

该静态类型转换，可以把当前类型 m 转换成 T 类型的对象值,其实该静态转换，编译器处理为调用对象 m 的 类型转换函数 ， operator T (){}

在这里插入图片描述

在这里插入图片描述
为什么研究这个函数呢？ 因为在 std :: move() 函数里，也有其调用

浅议 Dynamic_cast 和 RTTI
weixin_30319097的博客
03-07 408
写这篇博文的目的是，记录学习过程。 对于问题要较真，在解决这个问题中会学到很多，远远超过自己期望，锻炼思维，享受这个过程。 问题： Static_cast 与 Dynamic_cast的区别 来自书本上的解释： 用 static_cast<type-id > ( expression ) 1. static_cast(expression) The static_ca...
C++基础#22：C++中的静态强制static_cast
记录和分享程序人生的点点滴滴
02-06 1万+
与dynamic_cast对应的是static_cast（静态强制）。static_cast关键字一般用来将枚举类型转换成整型，或者短整形转换成长整形，又或者整型转换成浮点型。也可以用来将指向父类的指针转换成指向子类的指针。static_cast可以用于类层次结构中基类和子类之间指针或引用的转换。static_cast仅仅是依靠类型转换语句中提供的信息（尖括号中的类型）来进行转换。
C++中类型的强制转换
tmh_15195862719的博客
08-03 247
C++中类型的强制转换分为以下四种： 1、static_cast&lt;T&gt;(expr); 2、reinterpret_cast&lt;T&gt;(expr); 3、const_cast&lt;T&gt;(expr); 4、dynamic_cast&lt;T&gt;(expr); 其中前三种为编译时检查，最后一种为运行时检查。 static_cast&lt;T&gt;(expr)...
C++四种强转
YMY_mine的博客
08-17 650
标准C++中有四个类型转换符：static_cast、dynamic_cast、reinterpret_cast、和const_cast。 一、reinterpret_cast（不安全，类似于C语言的强制转换） reinterpret_cast转换是在类C转换的基础上，在编译期间，约束了整型、浮点型和枚举类型的相互转换。 用法：reinpreter_cast&lt;type-id&gt; (...
标准C++强制类型转换（C++风格的类型转换）
@奮 鬥@的专栏
07-07 1443
(1) 1）static_cast（a） 将地址a转换成类型T，T和a必须是指针、引用、算术类型或枚举类型。 表达式static_cast ( a ) a的值转换为模板中指定的类型T。在运行时转换过程中，不进行类型检查来确保转换的安全性。 2）dynamic_cast（a） 完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。 表达
static_cast<DWORD64>
最新发布
11-21
DWORD64 addr = static_cast<DWORD64>(reinterpret_cast<uintptr_t>(p)); ``` > ⚠️ **注意**： > - 直接 `static_cast<DWORD64>(p)` 可能编译失败（无关类型需用 `reinterpret_cast` 过渡）。 > - 更安全的...
reinterpret_cast<LPCWSTR>(&FetchModuleDirectory), // 使用当前函数地址 类型转换无效
10-14
<think>我们注意到用户指出 `reinterpret_cast<LPCWSTR>(&FetchModuleDirectory)` 存在类型转换无效的问题。这是因为 `FetchModuleDirectory` 是一个成员函数指针，而 `GetModuleHandleExW` 要求的是一个代码地址...
__int64 sub_228168(__int64 a1, unsigned __int8 *a2, unsigned int a3) { __int64 result = 0xFFFFFFFFLL; // 默认失败返回值 __int64 v5; void *v7; __int64 v8; if (!a2) { return result; // 如果 a2 为空，直接失败 } // 判断 a3 是否在特定范围: a3 - 1001 >= 0xFFFFFC18 → 即 a3 >= (0xFFFFFC18 + 1001) // 注意：0xFFFFFC18 是补码表示，等于 -1000（十进制） // 所以条件变成：a3 - 1001 >= -1000 → a3 >= 1 // 这个条件几乎总是成立！除非 a3 == 0 if (static_cast<int>(a3 - 1001) >= static_cast<int>(0xFFFFFC18) && *reinterpret_cast<uint64_t*>(a1 + 16) <= 0x400u) { if (*a2 <= 0x10u) { v5 = a3; } else { sub_4DF2BC(a1 + 1064); v7 = *reinterpret_cast<void**>(a1 + 26); *reinterpret_cast<uint16_t*>(a1 + 24) = static_cast<uint16_t>(a3); v5 = a3; memcpy(v7, a2, a3); // 安全复制 sub_4DF2EC(a1 + 1064); } v8 = sub_228230(a1, a2, v5); if (v8) { sub_4DF2BC(a1 + 1064); sub_2282F4(a1, &v8); sub_4DF2EC(a1 + 1064); return 0; // 成功 } else { return 0xFFFFFFFFLL; // 失败 } } return result; } Hook the entire code using below principal __int64 __fastcall h_sub_397138( int a1, __int64 a2, _QWORD *a3, __int64 a4, __int64 a5, __int64 a6, __int64 a7, __int64 a8) { // ✅ Safe register read __int64 v487 = read_tpidr_el0() + 40; // 🔥 Neutralized function return 0LL; }
11-18
你提供的代码是反汇编后的 C++ 风格伪代码（来自 IDA 或 Ghidra 等逆向工具），包含一个函数 `sub_228168`，其功能大致如下： - 接收三个参数：`a1`（上下文指针）、`a2`（数据缓冲区）、`a3`（数据长度） - 执行...
请仔细阅读和分析下面函数，进行优化后,采用C/C++11标准，完整推导并重构可编译的全部代码 特别注意： 1.保持所有原始功能不变 2.提高执行效率，降低计算复杂度 3.已经给定的结构体名字和元素不要更改，详细的中文注释 4.自动添加中文注释说明功能逻辑 5.不使用 auto，使用显式 for 循环 6.结构体采用32位定义 7.不要使用小函数，保持原始的函数定义 8.严格保持protobuf字段映射关系 函数中的 HDDMXng::Tile::Tile 映射为 message Tile { optional uint32 graphid = 1; optional sint32 tx = 2; optional sint32 ty = 3; optional uint32 firstsiteid = 4; optional string name = 5; } 将 _BYTE tile_msg[8] 映射为 HDDMXng::Tile tile_msg; 将 int *stream 映射为 std::istream *stream; void __cdecl HDDMTile::print(HDDMTile *this) { int v1; // ebp int v2; // edi _DWORD *v3; // edi int v4; // eax int v5; // edi int v6; // ebp int v7; // ebp int v8; // edi int v9; // edi int v10; // edi int v11; // edi stlp_std::ios_base *v12; // edi int v13; // eax int v14; // eax unsigned int v15; // esi unsigned int v16; // ebp unsigned int v17; // edi int v18; // edi int v19; // edi _DWORD *v20; // esi int v21; // eax int v22; // eax int v23; // eax stlp_std::ios_base *v24; // esi int v25; // eax int dword8; // [esp+10h] [ebp-2Ch] _BOOL4 v27; // [esp+14h] [ebp-28h] int v28; // [esp+18h] [ebp-24h] int v29; // [esp+1Ch] [ebp-20h] v1 = HIWORD(this->dword4) >> 6; sub_95FBDC(); v2 = sub_95FA19(); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v2, " m_graphid : "); v3 = (_DWORD *)stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(v2, v1); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::put(v3, 10); v4 = *(_DWORD *)((char *)v3 + *(_DWORD *)(*v3 - 12) + 72); if ( v4 && (*(int (__cdecl **)(_DWORD))(*(_DWORD *)v4 + 20))(*(_DWORD *)((char *)v3 + *(_DWORD *)(*v3 - 12) + 72)) == -1 && (v12 = (stlp_std::ios_base *)((char *)v3 + *(_DWORD *)(*v3 - 12)), v22 = *((_DWORD *)v12 + 2) | 1, *((_DWORD *)v12 + 2) = v22, (v22 & *((_DWORD *)v12 + 5)) != 0) ) { do { stlp_std::ios_base::_M_throw_failure(v12); LABEL_10: v12 = (stlp_std::ios_base *)((char *)v12 + *(_DWORD *)(*(_DWORD *)v12 - 12)); v23 = *((_DWORD *)v12 + 2) | 1; *((_DWORD *)v12 + 2) = v23; } while ( (v23 & *((_DWORD *)v12 + 5)) != 0 ); } else { dword8 = this->dword8; v29 = this->dword4 & 0x3FFFFF; v28 = HIBYTE(this->byte0) >> 4; v27 = (this->byte0 & 0x8000000) != 0; v5 = (this->byte0 >> 2) & 0x1FFFFFF; v6 = this->byte0 & 3; sub_95FBDC(); v7 = stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(&stlp_std::cout, v6); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v7, " m_tx : "); v8 = stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(v7, v5); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v8, " m_wasted1 : "); v9 = stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(v8, v27); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v9, " m_deviceid : "); v10 = stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(v9, v28); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v10, " m_firstsiteid : "); v11 = stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(v10, v29); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v11, " m_ty : "); v12 = (stlp_std::ios_base *)stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,long>(v11, dword8); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::put(v12, 10); v13 = *(_DWORD *)((char *)v12 + *(_DWORD *)(*(_DWORD *)v12 - 12) + 72); if ( v13 && (*(int (__cdecl **)(_DWORD))(*(_DWORD *)v13 + 20))(*(_DWORD *)((char *)v12 + *(_DWORD *)(*(_DWORD *)v12 - 12) + 72)) == -1 ) { goto LABEL_10; } } v14 = HDDMDeviceCache::m_devcache[HIBYTE(this->byte0) >> 4]; v15 = -1431655765 * (((int)this - *(_DWORD *)(v14 + 156)) >> 4); v16 = v15 % *(unsigned __int16 *)(v14 + 6); v17 = v15 / *(unsigned __int16 *)(v14 + 6); sub_95FBDC(); v18 = stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>( &stlp_std::cout, (unsigned __int16)v17); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v18, " tilecol : "); v19 = stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(v18, v16); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::_M_put_nowiden(v19, " index : "); v20 = (_DWORD *)stlp_std::priv::__put_num<char,stlp_std::char_traits<char>,unsigned long>(v19, v15); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::put(v20, 10); v21 = *(_DWORD *)((char *)v20 + *(_DWORD *)(*v20 - 12) + 72); if ( v21 && (*(int (__cdecl **)(_DWORD))(*(_DWORD *)v21 + 20))(*(_DWORD *)((char *)v20 + *(_DWORD *)(*v20 - 12) + 72)) == -1 ) { v24 = (stlp_std::ios_base *)((char *)v20 + *(_DWORD *)(*v20 - 12)); v25 = *((_DWORD *)v24 + 2) | 1; *((_DWORD *)v24 + 2) = v25; if ( (v25 & *((_DWORD *)v24 + 5)) != 0 ) { stlp_std::ios_base::_M_throw_failure(v24); HDDMTileType::print((HDDMTileType *)this); } } }
10-07
uint32_t tileIndex = ((reinterpret_cast<uint32_t>(this) - devcache[39]) >> 4); uint32_t magicNumber = 0xAAAAAAAB; // -1431655765的十六进制表示 uint32_t index = magicNumber * tileIndex; uint16_t ...
请仔细阅读和分析下面函数，进行优化后,采用C/C++11标准，完整推导并重构可编译的全部代码 特别注意： 1.保持所有原始功能不变 2.提高执行效率，降低计算复杂度 3.已经给定的结构体名字和元素不要更改，详细的中文注释 4.自动添加中文注释说明功能逻辑 5.不使用 auto，使用显式 for 循环 6.结构体采用32位定义 7.不要使用小函数，保持原始的函数定义 函数中的 HDDMXng::Chip::Chip 映射为 message Chip { optional uint32 numsites = 1; optional uint32 numrows = 2; optional uint32 numcols = 3; optional uint32 rpmgridx = 4; optional uint32 rpmgridy = 5; optional sint32 extremaxmin = 6; optional sint32 extremaxmax = 7; optional sint32 extremaymin = 8; optional sint32 extremaymax = 9; optional string chip = 10; optional string arch = 11; } 将 _BYTE chip_msg[8] 映射为 HDDMXng::Chip chip_msg; void __cdecl HDDMDevice::readchip_pb(HDDMDevice *this, HDDMChipDesc *hddmChipDesc) { HDDMChipType *v2; // eax HDDMDevice *v3; // eax int v4; // eax int v5; // esi HDDMChip *pHDDMChip; // ebp char *dword214; // esi int dword220; // ebp int v9; // edi void *v10; // esi __int16 v11; // dx __int16 v12; // dx int hddmTileVec; // edi unsigned int *v14; // esi int v15; // edx int v16; // ecx int v17; // ecx _DWORD *v18; // esi int v19; // ebp void *v20; // edi int hddmSiteVec; // edi int v22; // esi int v23; // edx int v24; // ecx int v25; // ecx _DWORD *v26; // esi int v27; // ebp void *v28; // edi _BYTE *src; // ecx size_t n; // ebp int v31; // edi unsigned int v32; // eax unsigned int v33; // edi char *v34; // edi HDDMChip **dest; // edx HDDMChip **v36; // eax _DWORD *v37; // esi void *dword210; // eax int v39; // edi int v40; // ebp HDDMChipType *pHDDMChipType; // esi _DWORD *v42; // eax int v43; // eax int v44; // edi __int16 v45; // dx int v46; // esi void *v47; // [esp+4h] [ebp-218h] const char *srca; // [esp+4h] [ebp-218h] const char *srcb; // [esp+4h] [ebp-218h] const char *srcc; // [esp+4h] [ebp-218h] const char *srcd; // [esp+4h] [ebp-218h] char *dword38; // [esp+1Ch] [ebp-200h] int dword3C; // [esp+1Ch] [ebp-200h] int dword40; // [esp+1Ch] [ebp-200h] HDDMChip **v55; // [esp+1Ch] [ebp-200h] HDDMChip **v56; // [esp+1Ch] [ebp-200h] unsigned int i; // [esp+20h] [ebp-1FCh] unsigned int j; // [esp+20h] [ebp-1FCh] int v59; // [esp+24h] [ebp-1F8h] int v60; // [esp+24h] [ebp-1F8h] HDDMChip *hddmChip; // [esp+28h] [ebp-1F4h] bool v62; // [esp+2Fh] [ebp-1EDh] int v63; // [esp+34h] [ebp-1E8h] int v64; // [esp+34h] [ebp-1E8h] int NumTiles; // [esp+38h] [ebp-1E4h] int NumSites; // [esp+38h] [ebp-1E4h] int v67; // [esp+3Ch] [ebp-1E0h] int v68; // [esp+3Ch] [ebp-1E0h] HDDMChipType hddmChipType; // [esp+4Ch] [ebp-1D0h] BYREF int v70; // [esp+C0h] [ebp-15Ch] int v71; // [esp+C4h] [ebp-158h] HDDMChip v72; // [esp+D0h] [ebp-14Ch] BYREF _DWORD v73[6]; // [esp+118h] [ebp-104h] BYREF _BYTE v74[16]; // [esp+130h] [ebp-ECh] BYREF _BYTE *v75; // [esp+140h] [ebp-DCh] _BYTE *v76; // [esp+144h] [ebp-D8h] int v77; // [esp+148h] [ebp-D4h] _BYTE chip_msg[8]; // [esp+150h] [ebp-CCh] BYREF int v79; // [esp+158h] [ebp-C4h] int v80; // [esp+15Ch] [ebp-C0h] int v81; // [esp+160h] [ebp-BCh] int v82; // [esp+164h] [ebp-B8h] int v83; // [esp+168h] [ebp-B4h] int v84; // [esp+16Ch] [ebp-B0h] int v85; // [esp+170h] [ebp-ACh] int v86; // [esp+174h] [ebp-A8h] int v87; // [esp+178h] [ebp-A4h] int v88; // [esp+180h] [ebp-9Ch] _BYTE v89[8]; // [esp+198h] [ebp-84h] BYREF int v90[31]; // [esp+1A0h] [ebp-7Ch] BYREF isl::iostreams::filtering_stream<boost::iostreams::input,char,stlp_std::char_traits<char>,stlp_std::allocator<char>,boost::iostreams::public_>::filtering_stream( v89, hddmChipDesc->dword50, 4, 0); sub_8D8DC4(); HDDMXng::Chip::Chip((HDDMXng::Chip *)chip_msg); HDDMDevice::readMessage((int)v90, (google::protobuf::MessageLite *)chip_msg); v2 = *(HDDMChipType **)stlp_std::map<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>,HDDMChipType *,stlp_std::less<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>>,stlp_std::allocator<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const,HDDMChipType *>>>::operator[]<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>>( &this->char1F8, hddmChipDesc); hddmChipDesc->hddmChipType = v2; hddmChipType.hddmChipType = v2; v62 = v2 == 0; if ( !v2 ) { v40 = (this->dword1F0 - this->hddmChipTypeVec) >> 2; stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::basic_string(&v72.gapD[11], v87); pHDDMChipType = (HDDMChipType *)operator new(0x78u); HDDMChipType::HDDMChipType((int)pHDDMChipType, (int)this, v40, (int)&v72.gapD[11]); hddmChipDesc->hddmChipType = pHDDMChipType; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(&v72.gapD[11]); hddmChipType.hddmChipType = hddmChipDesc->hddmChipType; stlp_std::vector<HDDMChipType *,stlp_std::allocator<HDDMChipType *>>::push_back( &this->hddmChipTypeVec, &hddmChipType.hddmChipType); HDDMChipType::getName((HDDMChipType *)&v72.hddmChipType); v42 = (_DWORD *)stlp_std::map<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>,HDDMChipType *,stlp_std::less<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>>,stlp_std::allocator<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const,HDDMChipType *>>>::operator[]<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>>( &this->char1F8, &v72.hddmChipType); *v42 = hddmChipType.hddmChipType; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(&v72.hddmChipType); v43 = hddmChipType.hddmChipType; v44 = v79; *(_DWORD *)(hddmChipType.hddmChipType + 36) = v79; *(_WORD *)(v43 + 44) = v82; *(_WORD *)(v43 + 46) = v83; v45 = v81; LOWORD(pHDDMChipType) = v80; *(_DWORD *)(v43 + 32) = v81 * v80; *(_WORD *)(v43 + 40) = v45; *(_WORD *)(v43 + 42) = (_WORD)pHDDMChipType; v75 = v74; v76 = v74; v74[0] = 0; stlp_std::vector<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>,stlp_std::allocator<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>>>::resize( v43 + 60, v44, v74); stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(v74); v75 = v74; v76 = v74; v74[0] = 0; stlp_std::vector<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>,stlp_std::allocator<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>>>::resize( hddmChipType.hddmChipType + 48, *(_DWORD *)(hddmChipType.hddmChipType + 32), v74); stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(v74); } v3 = this; if ( !this->isXngd ) { if ( (char *)v87 != &this->archFilePath ) stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_assign( (int)&this->archFilePath, *(void **)(v87 + 20), *(_DWORD *)(v87 + 16)); *(_DWORD *)&this->nDeviceCode = (16 * (v79 & 0x3FFFFF)) | *(_DWORD *)&this->nDeviceCode & 0xFC00000F; this->numrows = v80; this->numcols = v81; this->rpmgridx = v82; this->rpmgridy = v83; this->extremaxmin = v84; this->extremaxmax = v85; this->extremaymin = v86; this->extremaymax = v88; v4 = hddmChipType.hddmChipType; this->dword94 = hddmChipType.hddmChipType + 96; this->dword98 = v4 + 72; v3 = this; } v5 = (v3->dword214 - v3->dword210) >> 2; stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::basic_string( v73, (int)&hddmChipDesc->char18); pHDDMChip = (HDDMChip *)operator new(0x3Cu); HDDMChip::HDDMChip(pHDDMChip, (int)this, v5, v73, hddmChipType.hddmChipType); hddmChipDesc->hddmChip = pHDDMChip; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(v73); hddmChip = hddmChipDesc->hddmChip; dword214 = (char *)this->dword214; if ( dword214 != (char *)this->dword218 ) { *(_DWORD *)dword214 = hddmChipDesc->hddmChip; this->dword214 += 4; goto LABEL_9; } src = (_BYTE *)this->dword210; n = dword214 - src; v31 = 1; v32 = (dword214 - src) >> 2; if ( v32 ) v31 = (dword214 - src) >> 2; v33 = v32 + v31; if ( v33 > 0x3FFFFFFF || v32 > v33 ) { v39 = -4; LABEL_71: dest = (HDDMChip **)stlp_std::__malloc_alloc::allocate((stlp_std::__malloc_alloc *)v39, (unsigned int)v47); src = (_BYTE *)this->dword210; n = dword214 - src; v34 = (char *)dest + (v39 & 0xFFFFFFFC); goto LABEL_65; } if ( v33 ) { v39 = 4 * v33; goto LABEL_71; } v34 = 0; dest = 0; LABEL_65: v36 = dest; if ( n ) { v55 = dest; v36 = (HDDMChip **)((char *)memmove(dest, src, n) + n); dest = v55; } *v36 = hddmChip; v37 = v36 + 1; dword210 = (void *)this->dword210; if ( dword210 ) { v56 = dest; free(dword210); dest = v56; } this->dword210 = dest; this->dword214 = v37; this->dword218 = v34; LABEL_9: HDDMChip::getName(&v72); dword220 = this->dword220; if ( !dword220 ) { dword38 = &this->char21C; LABEL_58: stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::basic_string(v74, (int)&v72); v77 = 0; *(_DWORD *)&hddmChipType.gap9[11] = dword38; stlp_std::priv::_Rb_tree<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>,stlp_std::less<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>>,stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const,HDDMChip *>,stlp_std::priv::_Select1st<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const,HDDMChip *>>,stlp_std::priv::_MapTraitsT<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const,HDDMChip *>>,stlp_std::allocator<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const,HDDMChip *>>>::insert_unique(&hddmChipType.dword38); dword38 = (char *)hddmChipType.dword38; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(v74); goto LABEL_16; } v9 = *(_DWORD *)&v72.gapD[3]; v10 = *(void **)&v72.gapD[7]; dword38 = &this->char21C; do { while ( stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_compare( *(void **)(dword220 + 36), *(_DWORD *)(dword220 + 32), v10, v9) >= 0 ) { dword38 = (char *)dword220; dword220 = *(_DWORD *)(dword220 + 8); if ( !dword220 ) goto LABEL_14; } dword220 = *(_DWORD *)(dword220 + 12); } while ( dword220 ); LABEL_14: if ( &this->char21C == dword38 || stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_compare( v10, v9, *((void **)dword38 + 9), *((_DWORD *)dword38 + 8)) < 0 ) { goto LABEL_58; } LABEL_16: *((_DWORD *)dword38 + 10) = hddmChip; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(&v72); hddmChip->dword24 = hddmChipDesc->dword5C; hddmChip->dword28 = hddmChipDesc->dword60; *(_DWORD *)&hddmChip->hddmChipType = *(_DWORD *)&hddmChipDesc->word34; HDDMChipType::getTileGridExtent(&hddmChipType); v11 = hddmChipDesc->word36 + HIWORD(hddmChipType.dword0); hddmChip->word2C = hddmChipDesc->word34 + LOWORD(hddmChipType.dword0); hddmChip->word2E = v11; *(_DWORD *)&hddmChip->word38 = *(_DWORD *)&hddmChipDesc->word30; HDDMChipType::getRpmGridExtent(&hddmChipType); v12 = hddmChipDesc->word32 + HIWORD(hddmChipType.dword0); hddmChip->word34 = hddmChipDesc->word30 + LOWORD(hddmChipType.dword0); hddmChip->word36 = v12; if ( !this->hddmTileVec ) HDDMDevice::allocatesupersites(this); NumTiles = HDDMChipType::getNumTiles((HDDMChipType *)hddmChipType.hddmChipType); if ( NumTiles ) { v59 = 0; for ( i = 0; i != NumTiles; ++i ) { hddmTileVec = this->hddmTileVec; v14 = (unsigned int *)(hddmTileVec + 48 * (i + HDDMChip::getMinTileIndex(hddmChip))); HDDMTile::readme_pb(v14, v90); v14[11] = HDDMChip::getIndex(hddmChip); v14[1] = (v14[1] + HDDMChip::getMinSiteIndex(hddmChip)) & 0x3FFFFF | v14[1] & 0xFFC00000; *v14 = (4 * (((*v14 >> 2) + (__int16)hddmChipDesc->word38) & 0x1FFFFFF)) | *v14 & 0xF8000003; v14[2] += (__int16)hddmChipDesc->word3A; if ( !v62 ) { v75 = v74; v76 = v74; v74[0] = 0; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_swap(v74, v14 + 3); stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(v74); goto LABEL_31; } v15 = *(_DWORD *)(hddmChipType.hddmChipType + 48); if ( i >= -1431655765 * ((*(_DWORD *)(hddmChipType.hddmChipType + 52) - v15) >> 3) ) { v46 = stlp_std::__stl_throw_out_of_range((stlp_std *)"vector", srca); operator delete(hddmChip); goto LABEL_74; } stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_swap(v59 + v15, v14 + 3); v16 = *(_DWORD *)(hddmChipType.hddmChipType + 48); if ( i >= -1431655765 * ((*(_DWORD *)(hddmChipType.hddmChipType + 52) - v16) >> 3) ) { v46 = stlp_std::__stl_throw_out_of_range((stlp_std *)"vector", srcb); LABEL_74: stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(hddmTileVec); goto LABEL_75; } v17 = v59 + v16; v67 = v17; v63 = hddmChipType.hddmChipType + 72; v18 = *(_DWORD **)(hddmChipType.hddmChipType + 76); if ( v18 ) { v19 = *(_DWORD *)(v17 + 16); v20 = *(void **)(v17 + 20); dword3C = hddmChipType.hddmChipType + 72; do { while ( stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_compare( *(void **)(v18[4] + 20), *(_DWORD *)(v18[4] + 16), v20, v19) >= 0 ) { dword3C = (int)v18; v18 = (_DWORD *)v18[2]; if ( !v18 ) goto LABEL_28; } v18 = (_DWORD *)v18[3]; } while ( v18 ); LABEL_28: if ( v63 != dword3C && stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_compare( v20, v19, *(void **)(*(_DWORD *)(dword3C + 16) + 20), *(_DWORD *)(*(_DWORD *)(dword3C + 16) + 16)) >= 0 ) { goto LABEL_30; } } else { dword3C = hddmChipType.hddmChipType + 72; } hddmChipType.dword64 = v67; hddmChipType.dword68 = 0; hddmChipType.dword24 = dword3C; stlp_std::priv::_Rb_tree<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const*,HDDMChipType::_DerefStringPtrLessThan,stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>,stlp_std::priv::_Select1st<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>>,stlp_std::priv::_MapTraitsT<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>>,stlp_std::allocator<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>>>::insert_unique(&hddmChipType.dword3C); dword3C = hddmChipType.dword3C; LABEL_30: *(_DWORD *)(dword3C + 20) = i; LABEL_31: v59 += 24; } } if ( !this->hddmSiteVec ) HDDMDevice::allocatesites(this); NumSites = HDDMChipType::getNumSites((HDDMChipType *)hddmChipType.hddmChipType); if ( NumSites ) { v60 = 0; for ( j = 0; j != NumSites; ++j ) { hddmSiteVec = this->hddmSiteVec; v22 = hddmSiteVec + 36 * (j + HDDMChip::getMinSiteIndex(hddmChip)); HDDMSite::readme_pb(v22, (int)v90); *(_DWORD *)(v22 + 32) = HDDMChip::getIndex(hddmChip); *(_DWORD *)v22 = (4 * (((*(_DWORD *)v22 >> 2) + HDDMChip::getMinTileIndex(hddmChip)) & 0x3FFFFF)) | *(_DWORD *)v22 & 0xFF000003; if ( *(char *)(v22 + 7) >= 0 ) { HDDMChip::getRpmGridRect((HDDMChip *)&hddmChipType.dword44); *(_WORD *)(v22 + 4) = (*(_WORD *)&hddmChipType.byte48 + *(_WORD *)(v22 + 4)) & 0xFFF | *(_WORD *)(v22 + 4) & 0xF000; srcc = (const char *)hddmChip; HDDMChip::getRpmGridRect((HDDMChip *)&hddmChipType.dword54); *(_DWORD *)(v22 + 4) = ((((unsigned __int16)(*(_DWORD *)(v22 + 4) >> 12) + HIWORD(hddmChipType.dword58)) & 0xFFF) << 12) | *(_DWORD *)(v22 + 4) & 0xFF000FFF; } if ( !v62 ) { v75 = v74; v76 = v74; v74[0] = 0; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_swap(v74, v22 + 8); stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(v74); goto LABEL_49; } v23 = *(_DWORD *)(hddmChipType.hddmChipType + 60); if ( -1431655765 * ((*(_DWORD *)(hddmChipType.hddmChipType + 64) - v23) >> 3) <= j ) goto LABEL_78; stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_swap(v60 + v23, v22 + 8); v24 = *(_DWORD *)(hddmChipType.hddmChipType + 60); if ( -1431655765 * ((*(_DWORD *)(hddmChipType.hddmChipType + 64) - v24) >> 3) <= j ) { stlp_std::__stl_throw_out_of_range((stlp_std *)"vector", srcd); LABEL_78: v46 = stlp_std::__stl_throw_out_of_range((stlp_std *)"vector", srcc); stlp_std::priv::_String_base<char,stlp_std::allocator<char>>::_M_deallocate_block(v60); LABEL_75: HDDMXng::Chip::~Chip((HDDMXng::Chip *)chip_msg); isl::iostreams::filtering_stream<boost::iostreams::input,char,stlp_std::char_traits<char>,stlp_std::allocator<char>,boost::iostreams::public_>::~filtering_stream(v89); _Unwind_Resume(v46); } v25 = v60 + v24; v68 = v25; v64 = hddmChipType.hddmChipType + 96; v26 = *(_DWORD **)(hddmChipType.hddmChipType + 100); if ( v26 ) { v27 = *(_DWORD *)(v25 + 16); v28 = *(void **)(v25 + 20); dword40 = hddmChipType.hddmChipType + 96; do { while ( stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_compare( *(void **)(v26[4] + 20), *(_DWORD *)(v26[4] + 16), v28, v27) >= 0 ) { dword40 = (int)v26; v26 = (_DWORD *)v26[2]; if ( !v26 ) goto LABEL_46; } v26 = (_DWORD *)v26[3]; } while ( v26 ); LABEL_46: if ( dword40 != v64 && stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_compare( v28, v27, *(void **)(*(_DWORD *)(dword40 + 16) + 20), *(_DWORD *)(*(_DWORD *)(dword40 + 16) + 16)) >= 0 ) { goto LABEL_48; } } else { dword40 = hddmChipType.hddmChipType + 96; } v70 = v68; v71 = 0; hddmChipType.dword34 = dword40; stlp_std::priv::_Rb_tree<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const*,HDDMChipType::_DerefStringPtrLessThan,stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>,stlp_std::priv::_Select1st<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>>,stlp_std::priv::_MapTraitsT<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>>,stlp_std::allocator<stlp_std::pair<stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>> const* const,unsigned int>>>::insert_unique(&hddmChipType.dword40); dword40 = hddmChipType.dword40; LABEL_48: *(_DWORD *)(dword40 + 20) = j; LABEL_49: v60 += 24; } } HDDMXng::Chip::~Chip((HDDMXng::Chip *)chip_msg); isl::iostreams::filtering_stream<boost::iostreams::input,char,stlp_std::char_traits<char>,stlp_std::allocator<char>,boost::iostreams::public_>::~filtering_stream(v89); } void __cdecl HDDMDevice::writechip_pb(HDDMDevice *this, int ostream, __int16 nFileVersion) { int v3; // eax int v4; // eax int v5; // edi int v6; // ebp int v7; // ebp int v8; // edi int v9; // [esp+18h] [ebp-74h] __int16 v10; // [esp+2Ch] [ebp-60h] BYREF __int16 v11; // [esp+2Eh] [ebp-5Eh] BYREF _BYTE chip_msg[8]; // [esp+30h] [ebp-5Ch] BYREF int v13; // [esp+38h] [ebp-54h] int word4; // [esp+3Ch] [ebp-50h] int word6; // [esp+40h] [ebp-4Ch] int word8; // [esp+44h] [ebp-48h] int wordA; // [esp+48h] [ebp-44h] int dword10; // [esp+4Ch] [ebp-40h] int dword14; // [esp+50h] [ebp-3Ch] int dword18; // [esp+54h] [ebp-38h] int v21; // [esp+58h] [ebp-34h] int v22; // [esp+5Ch] [ebp-30h] int dword1C; // [esp+60h] [ebp-2Ch] int v24; // [esp+68h] [ebp-24h] stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::write(ostream, "xngp", 4); v10 = nFileVersion | 0x8000; v11 = 0; stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::write(ostream, &v10, 2); stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::write(ostream, &v11, 2); HDDMXng::Chip::Chip((HDDMXng::Chip *)chip_msg); v13 = (*(_DWORD *)&this->nDeviceCode >> 4) & 0x3FFFFF; word4 = (unsigned __int16)this->numrows; word6 = (unsigned __int16)this->numcols; word8 = (unsigned __int16)this->rpmgridx; wordA = (unsigned __int16)this->rpmgridy; dword10 = this->extremaxmin; dword14 = this->extremaxmax; dword18 = this->extremaymin; dword1C = this->extremaymax; v24 |= 0x5FFu; v3 = v22; if ( (_UNKNOWN *)v22 == &google::protobuf::internal::kEmptyString ) { v3 = operator new(0x18u); *(_DWORD *)(v3 + 16) = v3; *(_DWORD *)(v3 + 20) = v3; *(_BYTE *)v3 = 0; v22 = v3; } stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_assign( v3, (void *)this->dword38, this->dword34); v24 |= 0x200u; v4 = v21; if ( (_UNKNOWN *)v21 == &google::protobuf::internal::kEmptyString ) { v4 = operator new(0x18u); *(_DWORD *)(v4 + 16) = v4; *(_DWORD *)(v4 + 20) = v4; *(_BYTE *)v4 = 0; v21 = v4; } stlp_std::basic_string<char,stlp_std::char_traits<char>,stlp_std::allocator<char>>::_M_assign( v4, (void *)this->dword50, this->dword4C); HDDMDevice::writeMessage(ostream, chip_msg); v9 = (unsigned __int16)this->numrows * (unsigned __int16)this->numcols; v5 = 0; v6 = 0; if ( v9 ) { do { HDDMTile::writeme_pb(v5 + this->hddmTileVec, ostream); ++v6; v5 += 48; } while ( v6 != v9 ); } v7 = 0; v8 = 0; if ( (*(_DWORD *)&this->nDeviceCode & 0x3FFFFF0) != 0 ) { do { HDDMSite::writeme_pb(v7 + this->hddmSiteVec, ostream); ++v8; v7 += 36; } while ( ((*(_DWORD *)&this->nDeviceCode >> 4) & 0x3FFFFF) > v8 ); } stlp_std::basic_ostream<char,stlp_std::char_traits<char>>::flush(ostream); HDDMXng::Chip::~Chip((HDDMXng::Chip *)chip_msg); }
10-06
size_t totalTiles = static_cast<size_t>(chip.numrows) * static_cast<size_t>(chip.numcols); tileVec.resize(totalTiles); } // 分配 site 向量 void HDDMDevice::allocateSites() { size_t totalSites = ...
【C++】类型转换（静态转换 动态转换 常量转换 重新解释转换）
这道题我不会做...不会做啊..太难了！！
07-29 5351
C++类型转换类型转换概念静态转换(static_cast)（编译时类型检查）语法作用动态转换(dynamic_cast)（运行时类型检查）作用语法动态转换的运行时类型检查常量转换(const_cast)作用注意语法重新解释转换(reinterpret_cast)语法 类型转换概念 类型转换(cast)是将一种数据类型转换成另一种数据类型。 例如，如果将一个整型值赋给一个浮点类型的变量，编译器会暗地里将其转换成浮点类型（隐式类型转换）。 转换是非常有用的，但是它也会带来一些问题，比如在转换指针时，我们很
c++强制类型转换：dynamic_cast、const_cast 、static_cast、reinterpret_cast
人在旅途/章鸽 的专栏
12-02 2万+
dynamic_cast:   通常在基类和派生类之间转换时使用,run-time   castconst_cast:   主要针对const和volatile的转换. static_cast:   一般的转换，no   run-time   check.通常，如果你不知道该用哪个，就用这个。   reinterpret_cast:   用于进行没有任何关联之间的转换，比如一个字符指针转换为一
C++基础知识及相关底层汇编实现（更新中）
最不正经的计算机专业学生
06-27 1998
C++基础
深入static_cast运算符
痞子龙3D编程
03-29 5583
<br />本文下载地址：<br />http://bbs.sjtu.edu.cn/file/Apple/1200681928238350.pdf<br /><br />许可：<br />http://creativecommons.org/licenses/by-nc-nd/2.5/cn<br /><br />作者：Robert Schmidt<br />Microsoft Corporation<br />2000年5月18日<br /><br />译者：高博<br />http://www.gaobo
static_cast揭密
orichisonic的专栏
07-16 831
http://www.vckbase.com/document/viewdoc/?id=1651 原文链接：What static_cast本文讨论static_cast。 介绍大多程序员在学C++前都学过C，并且习惯于C风格（类型）转换。当写C++（程序）时，有时候我们在使用static_cast时可能会有点模糊。在本文中，我将说明static_cast泛型（Generic Types）
reinterpret_cast<T>() static_cast<T>() const_cast<T>() dynamic_cast<T>()
zheng2263的博客
12-14 658
reinterpret_cast() 从指针类型到一个足够大的整数类型 从整数类型或者枚举类型到指针类型 从一个指向函数的指针到另一个不同类型的指向函数的指针 从一个指向对象的指针到另一个不同类型的指向对象的指针 从一个指向类函数成员的指针到另一个指向不同类型的函数成员的指针 从一个指向类数据成员的指针到另一个指向不同类型的数据成员的指针 以在任意指针之间进行互相转换，即
static_cast用法浅析
热门推荐
wei.zhou的专栏
04-10 4万+
用法：static_cast ( expression ) 一般来说，编译器隐式执行的任何类型转换都可以由static_cast显式完成。static_cast可以用来将枚举类型转换成整型，或者整型转换成浮点型。也可以用来将指向父类的指针转换成指向子类的指针。做这些转换前，你必须确定要转换的数据确实是目标类型的数据，因为static_cast不做运行时的类型检查以保证转换的安全性。也因此，st
static_cast 用法
stormwangw的博客
04-11 2万+
https://blog.youkuaiyun.com/moruihong用法：static_cast &lt; type-id &gt; ( expression )　　该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：　　①用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。　　进行上行转换（把派生类的指针或引用转换成基类表...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhangzhangkeji

谢谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值