C++ 的 sizeof 是怎么实现的？
sizeof 关键字在 C++ 中，并不是一个普通的函数，而是一个编译时常量。理解它的实现，关键在于区分它在编译期和运行时的行为。
1. 编译期的魔法：类型的大小计算
当你使用 `sizeof` 关键字时，比如 `sizeof(int)` 或者 `sizeof(MyClass)`，编译器会立即在编译阶段就确定这个类型在内存中所占用的字节数。它不会在程序运行时去动态地计算。
内置类型: 对于 `int`, `float`, `double`, `char`, `bool` 等内置类型，编译器本身就内建了它们在目标平台上的大小信息。例如，在大多数 64 位系统上，`sizeof(int)` 会被直接替换成 `4`（代表 4 字节）。
用户定义类型（结构体、类、枚举等）:
普通结构体/类: 编译器会根据其成员变量的类型和顺序，以及潜在的内存对齐规则，来计算出整个结构体或类的总大小。
内存对齐 (Padding): 这是 `sizeof` 实现中一个非常重要的概念。为了提高 CPU 访问内存的效率，编译器会将成员变量放置在内存的特定地址上。如果成员变量的地址不是它的自然边界（例如，一个 4 字节的 `int` 应该放在 4 字节的边界上），编译器会在成员变量之间插入一些“填充字节”（padding），以满足对齐要求。`sizeof` 计算的就是包含这些填充字节在内的总大小。
继承: 如果一个类继承了其他类（基类），那么派生类的大小会包含其所有基类的大小，以及自身新增成员的大小，同样需要考虑对齐。
虚函数和虚表: 如果一个类包含了虚函数，编译器会在对象中放置一个指向虚函数表的指针（vptr）。这个指针的大小会被计入 `sizeof` 的结果。
抽象基类和纯虚函数: 即使一个类是抽象基类（包含纯虚函数），并且本身没有数据成员，它仍然会有虚函数表指针（vptr），所以 `sizeof` 也会返回指针的大小。
空类 (Empty Class): 一个没有任何成员（包括非静态成员函数、非静态数据成员）的类，在 C++ 中，`sizeof` 的结果至少是 1 字节，以确保每个对象都有一个独一无二的地址。这并不是因为有隐藏成员，而是 C++ 标准的要求。
数组: `sizeof(array)` 会返回整个数组所占用的总字节数，也就是 `数组元素个数 sizeof(数组元素类型)`。
指针: `sizeof(pointer)` 计算的是指针本身的大小，而不是它指向的对象的大小。例如，`sizeof(int)` 在 64 位系统上通常是 8 字节。
2. `sizeof` 作为操作符，而非函数
关键在于，`sizeof` 是一个操作符，而不是一个函数调用。这意味着：
没有函数调用的开销: 编译器直接将 `sizeof` 的结果替换到代码中。它不会产生函数调用的栈帧创建、参数传递、函数跳转等开销。
不能是右值引用: `sizeof` 的结果是一个 `size_t` 类型的值，它是一个右值常量，不能作为左值进行赋值。
不能用于不完整类型: 你不能对一个未知大小的类型使用 `sizeof`，例如 `void` 或者一个前向声明的类（`class MyClass;`）。
3. `sizeof(expression)` 的工作原理
当你使用 `sizeof(expression)` 时，编译器会：
1. 推导表达式的类型: 确定 `expression` 的类型。
2. 计算该类型的字节数: 根据前面提到的规则，计算出该类型的字节数。
3. 直接替换: 将 `sizeof(expression)` 这部分代码，在编译后的中间代码或最终汇编代码中，用计算出的具体数值（如 `4`、`8`、`16` 等）替换掉。
重要的例外：`sizeof(variable)` 和 `sizeof(type)`
`sizeof(type)`: 例如 `sizeof(int)`, `sizeof(std::string)`。编译器直接知道 `type` 的大小。
`sizeof(variable)`: 例如 `sizeof(my_int_variable)`, `sizeof(my_string_object)`。编译器同样会推断出 `my_int_variable` 或 `my_string_object` 的类型，然后查找该类型的预定义大小。
`sizeof` 运算符在 C++ 标准中的定义
C++ 标准（如 C++11, C++17 等）规定了 `sizeof` 运算符的行为。它是一个编译时常量表达式，其结果是一个 `size_t` 类型的无符号整数，表示操作数类型在内存中的字节数。
举个例子，我们来看一个类：
```c++
class MyData {
char a; // 1 byte
int b; // 4 bytes
double c; // 8 bytes
char d; // 1 byte
};
```
在大多数 64 位系统中，会发生内存对齐。假设 `int` 对齐到 4 字节边界，`double` 对齐到 8 字节边界。
1. `a` (char): 1 字节。
2. 填充: 为了让 `b` (int) 能够对齐到 4 字节边界，编译器可能会插入 3 个填充字节。
3. `b` (int): 4 字节。
4. `c` (double): 8 字节。
5. `d` (char): 1 字节。
6. 填充: 为了让 `MyData` 这个整体的大小能够对齐到 `double` 的对齐要求（8 字节），编译器会在 `d` 之后插入 7 个填充字节（假设 `sizeof(MyData)` 需要是 8 的整数倍）。
因此，`sizeof(MyData)` 的结果可能是：1 (a) + 3 (padding) + 4 (b) + 8 (c) + 1 (d) + 7 (padding) = 24 字节。
总结 `sizeof` 的实现方式：
1. 编译时解析: `sizeof` 是一个编译时操作符，其结果在编译阶段就已确定。
2. 类型信息: 编译器拥有所有已定义类型的内存大小信息。
3. 内存对齐: 编译器会考虑目标平台和类型成员的内存对齐规则，计算出包含填充字节的总大小。
4. 直接替换: 编译后的代码中，`sizeof(type)` 或 `sizeof(expression)` 被其具体数值直接替换，没有运行时开销。
正是因为 `sizeof` 是在编译时就确定的，它才能用于数组的大小计算，或者在模板元编程中发挥作用。它是一种高效且强大的工具，直接触及了 C++ 内存布局的底层细节。
1. 编译期的魔法：类型的大小计算
当你使用 `sizeof` 关键字时，比如 `sizeof(int)` 或者 `sizeof(MyClass)`，编译器会立即在编译阶段就确定这个类型在内存中所占用的字节数。它不会在程序运行时去动态地计算。
内置类型: 对于 `int`, `float`, `double`, `char`, `bool` 等内置类型，编译器本身就内建了它们在目标平台上的大小信息。例如，在大多数 64 位系统上，`sizeof(int)` 会被直接替换成 `4`（代表 4 字节）。
用户定义类型（结构体、类、枚举等）:
普通结构体/类: 编译器会根据其成员变量的类型和顺序，以及潜在的内存对齐规则，来计算出整个结构体或类的总大小。
内存对齐 (Padding): 这是 `sizeof` 实现中一个非常重要的概念。为了提高 CPU 访问内存的效率，编译器会将成员变量放置在内存的特定地址上。如果成员变量的地址不是它的自然边界（例如，一个 4 字节的 `int` 应该放在 4 字节的边界上），编译器会在成员变量之间插入一些“填充字节”（padding），以满足对齐要求。`sizeof` 计算的就是包含这些填充字节在内的总大小。
继承: 如果一个类继承了其他类（基类），那么派生类的大小会包含其所有基类的大小，以及自身新增成员的大小，同样需要考虑对齐。
虚函数和虚表: 如果一个类包含了虚函数，编译器会在对象中放置一个指向虚函数表的指针（vptr）。这个指针的大小会被计入 `sizeof` 的结果。
抽象基类和纯虚函数: 即使一个类是抽象基类（包含纯虚函数），并且本身没有数据成员，它仍然会有虚函数表指针（vptr），所以 `sizeof` 也会返回指针的大小。
空类 (Empty Class): 一个没有任何成员（包括非静态成员函数、非静态数据成员）的类，在 C++ 中，`sizeof` 的结果至少是 1 字节，以确保每个对象都有一个独一无二的地址。这并不是因为有隐藏成员，而是 C++ 标准的要求。
数组: `sizeof(array)` 会返回整个数组所占用的总字节数，也就是 `数组元素个数 sizeof(数组元素类型)`。
指针: `sizeof(pointer)` 计算的是指针本身的大小，而不是它指向的对象的大小。例如，`sizeof(int)` 在 64 位系统上通常是 8 字节。
2. `sizeof` 作为操作符，而非函数
关键在于，`sizeof` 是一个操作符，而不是一个函数调用。这意味着：
没有函数调用的开销: 编译器直接将 `sizeof` 的结果替换到代码中。它不会产生函数调用的栈帧创建、参数传递、函数跳转等开销。
不能是右值引用: `sizeof` 的结果是一个 `size_t` 类型的值，它是一个右值常量，不能作为左值进行赋值。
不能用于不完整类型: 你不能对一个未知大小的类型使用 `sizeof`，例如 `void` 或者一个前向声明的类（`class MyClass;`）。
3. `sizeof(expression)` 的工作原理
当你使用 `sizeof(expression)` 时，编译器会：
1. 推导表达式的类型: 确定 `expression` 的类型。
2. 计算该类型的字节数: 根据前面提到的规则，计算出该类型的字节数。
3. 直接替换: 将 `sizeof(expression)` 这部分代码，在编译后的中间代码或最终汇编代码中，用计算出的具体数值（如 `4`、`8`、`16` 等）替换掉。
重要的例外：`sizeof(variable)` 和 `sizeof(type)`
`sizeof(type)`: 例如 `sizeof(int)`, `sizeof(std::string)`。编译器直接知道 `type` 的大小。
`sizeof(variable)`: 例如 `sizeof(my_int_variable)`, `sizeof(my_string_object)`。编译器同样会推断出 `my_int_variable` 或 `my_string_object` 的类型，然后查找该类型的预定义大小。
`sizeof` 运算符在 C++ 标准中的定义
C++ 标准（如 C++11, C++17 等）规定了 `sizeof` 运算符的行为。它是一个编译时常量表达式，其结果是一个 `size_t` 类型的无符号整数，表示操作数类型在内存中的字节数。
举个例子，我们来看一个类：
```c++
class MyData {
char a; // 1 byte
int b; // 4 bytes
double c; // 8 bytes
char d; // 1 byte
};
```
在大多数 64 位系统中，会发生内存对齐。假设 `int` 对齐到 4 字节边界，`double` 对齐到 8 字节边界。
1. `a` (char): 1 字节。
2. 填充: 为了让 `b` (int) 能够对齐到 4 字节边界，编译器可能会插入 3 个填充字节。
3. `b` (int): 4 字节。
4. `c` (double): 8 字节。
5. `d` (char): 1 字节。
6. 填充: 为了让 `MyData` 这个整体的大小能够对齐到 `double` 的对齐要求（8 字节），编译器会在 `d` 之后插入 7 个填充字节（假设 `sizeof(MyData)` 需要是 8 的整数倍）。
因此，`sizeof(MyData)` 的结果可能是：1 (a) + 3 (padding) + 4 (b) + 8 (c) + 1 (d) + 7 (padding) = 24 字节。
总结 `sizeof` 的实现方式：
1. 编译时解析: `sizeof` 是一个编译时操作符，其结果在编译阶段就已确定。
2. 类型信息: 编译器拥有所有已定义类型的内存大小信息。
3. 内存对齐: 编译器会考虑目标平台和类型成员的内存对齐规则，计算出包含填充字节的总大小。
4. 直接替换: 编译后的代码中，`sizeof(type)` 或 `sizeof(expression)` 被其具体数值直接替换，没有运行时开销。
正是因为 `sizeof` 是在编译时就确定的，它才能用于数组的大小计算，或者在模板元编程中发挥作用。它是一种高效且强大的工具，直接触及了 C++ 内存布局的底层细节。
网友意见
sizeof的东西会被编译器直接替换掉，即使是汇编代码都只能看到一个常量，所以下面有童鞋说看反汇编源码是不行的，因为已经在编译器内部替换掉了（更严谨的说法是，VLA是特殊情况，这是后面的代码说明中有提到）。下面以Clang对sizeof的处理来看sizeof的实现。
在Clang的实现中，在lib/AST/ExprConstant.cpp中有这样的方法：
bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr 这个方法的实现如此：
switch(E->getKind()) { case UETT_AlignOf: { if (E->isArgumentType()) return Success(GetAlignOfType(Info, E->getArgumentType()), E); else return Success(GetAlignOfExpr(Info, E->getArgumentExpr()), E); } case UETT_VecStep: { QualType Ty = E->getTypeOfArgument(); if (Ty->isVectorType()) { unsigned n = Ty->castAs<VectorType>()->getNumElements(); // The vec_step built-in functions that take a 3-component // vector return 4. (OpenCL 1.1 spec 6.11.12) if (n == 3) n = 4; return Success(n, E); } else return Success(1, E); } case UETT_SizeOf: { QualType SrcTy = E->getTypeOfArgument(); // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, // the result is the size of the referenced type." if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>()) SrcTy = Ref->getPointeeType(); CharUnits Sizeof; if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof)) return false; return Success(Sizeof, E); } } llvm_unreachable("unknown expr/type trait"); } 然后通过这个方法，我们可以顺藤摸瓜，发现sizeof的处理其实是在HandleSizeof这个方法内，结果是会存储在Sizeof这个CharUnits中，而一个CharUnits是Clang内部的一个表示，引用Clang的注释如下
/// CharUnits - This is an opaque type for sizes expressed in character units. /// Instances of this type represent a quantity as a multiple of the size /// of the standard C type, char, on the target architecture. As an opaque /// type, CharUnits protects you from accidentally combining operations on /// quantities in bit units and character units. /// /// In both C and C++, an object of type 'char', 'signed char', or 'unsigned /// char' occupies exactly one byte, so 'character unit' and 'byte' refer to /// the same quantity of storage. However, we use the term 'character unit' /// rather than 'byte' to avoid an implication that a character unit is /// exactly 8 bits. /// /// For portability, never assume that a target character is 8 bits wide. Use /// CharUnit values wherever you calculate sizes, offsets, or alignments /// in character units. 然后，我们找寻HandleSizeof方法：
/// Get the size of the given type in char units. static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc, QualType Type, CharUnits &Size) { // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc // extension. if (Type->isVoidType() || Type->isFunctionType()) { Size = CharUnits::One(); return true; } if (!Type->isConstantSizeType()) { // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. // FIXME: Better diagnostic. Info.Diag(Loc); return false; } Size = Info.Ctx.getTypeSizeInChars(Type); return true; } 走到这里，我们就知道了为什么会被替换掉了，如你这里是void或者Function type，编译器都直接替换为CharUnits::One()这个常量（即一个Char的大小），所以这就是汇编也只能看到常量的原因，毕竟汇编是后面CodeGen的事情，而这里是在CodeGen之前发生的了。而在这里也会判断Type是不是ConstantSizeType，因为需要在编译期计算出来，而注释则是针对VLA，有兴趣的同学可以按照注释的C99地方去看说的是什么。接下来则是把Type传给getTypeSizeInChars方法了。
OK，接下来我们再一步一步的走下去，看getTypeSizeInChars做了什么。
/// getTypeSizeInChars - Return the size of the specified type, in characters. /// This method does not work on incomplete types. CharUnits ASTContext::getTypeSizeInChars(QualType T) const { return getTypeInfoInChars(T).first; } 走到这里的时候，虽然我们就算不走下去都能知道这个方法是返回特定类型的大小了，但是我们还是要打破沙锅问到底，看到底是怎么实现的。于是我们继续走getTypeInfoChars()这个方法。
std::pair<CharUnits, CharUnits> ASTContext::getTypeInfoInChars(QualType T) const { return getTypeInfoInChars(T.getTypePtr()); } 走到这里，我们也知道为什么会有first了，因为这个方法返回的是一个std::pair，接下来我们可以发现调用的还是getTypeInChar方法，但是参数一个TypePointers，于是我们找这个重载方法：
std::pair<CharUnits, CharUnits> ASTContext::getTypeInfoInChars(const Type *T) const { if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(T)) return getConstantArrayInfoInChars(*this, CAT); TypeInfo Info = getTypeInfo(T); return std::make_pair(toCharUnitsFromBits(Info.Width), toCharUnitsFromBits(Info.Align)); } 随后，我们可以发现是getTypeInfo这个方法，然后我们找到对应的代码：
TypeInfo ASTContext::getTypeInfo(const Type *T) const { TypeInfoMap::iterator I = MemoizedTypeInfo.find(T); if (I != MemoizedTypeInfo.end()) return I->second; // This call can invalidate MemoizedTypeInfo[T], so we need a second lookup. TypeInfo TI = getTypeInfoImpl(T); MemoizedTypeInfo[T] = TI; return TI; } 然后我们找到了这个，对于MemorizedTypeInfo我们暂时不需要关心，我们也能发现需要的东西其实在getTypeInfoImpl里面
/// getTypeInfoImpl - Return the size of the specified type, in bits. This /// method does not work on incomplete types. /// /// FIXME: Pointers into different addr spaces could have different sizes and /// alignment requirements: getPointerInfo should take an AddrSpace, this /// should take a QualType, &c. TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const { uint64_t Width = 0; unsigned Align = 8; bool AlignIsRequired = false; switch (T->getTypeClass()) { #define TYPE(Class, Base) #define ABSTRACT_TYPE(Class, Base) #define NON_CANONICAL_TYPE(Class, Base) #define DEPENDENT_TYPE(Class, Base) case Type::Class: #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: assert(!T->isDependentType() && "should not see dependent types here"); return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr()); #include "clang/AST/TypeNodes.def" llvm_unreachable("Should not see dependent types"); case Type::FunctionNoProto: case Type::FunctionProto: // GCC extension: alignof(function) = 32 bits Width = 0; Align = 32; break; case Type::IncompleteArray: case Type::VariableArray: Width = 0; Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); break; case Type::ConstantArray: { const ConstantArrayType *CAT = cast<ConstantArrayType>(T); TypeInfo EltInfo = getTypeInfo(CAT->getElementType()); uint64_t Size = CAT->getSize().getZExtValue(); assert((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && "Overflow in array type bit size evaluation"); Width = EltInfo.Width * Size; Align = EltInfo.Align; if (!getTargetInfo().getCXXABI().isMicrosoft() || getTargetInfo().getPointerWidth(0) == 64) Width = llvm::RoundUpToAlignment(Width, Align); break; } case Type::ExtVector: case Type::Vector: { const VectorType *VT = cast<VectorType>(T); TypeInfo EltInfo = getTypeInfo(VT->getElementType()); Width = EltInfo.Width * VT->getNumElements(); Align = Width; // If the alignment is not a power of 2, round up to the next power of 2. // This happens for non-power-of-2 length vectors. if (Align & (Align-1)) { Align = llvm::NextPowerOf2(Align); Width = llvm::RoundUpToAlignment(Width, Align); } // Adjust the alignment based on the target max. uint64_t TargetVectorAlign = Target->getMaxVectorAlign(); if (TargetVectorAlign && TargetVectorAlign < Align) Align = TargetVectorAlign; break; } case Type::Builtin: switch (cast<BuiltinType>(T)->getKind()) { default: llvm_unreachable("Unknown builtin type!"); case BuiltinType::Void: // GCC extension: alignof(void) = 8 bits. Width = 0; Align = 8; break; case BuiltinType::Bool: Width = Target->getBoolWidth(); Align = Target->getBoolAlign(); break; case BuiltinType::Char_S: case BuiltinType::Char_U: case BuiltinType::UChar: case BuiltinType::SChar: Width = Target->getCharWidth(); Align = Target->getCharAlign(); break; case BuiltinType::WChar_S: case BuiltinType::WChar_U: Width = Target->getWCharWidth(); Align = Target->getWCharAlign(); break; case BuiltinType::Char16: Width = Target->getChar16Width(); Align = Target->getChar16Align(); break; case BuiltinType::Char32: Width = Target->getChar32Width(); Align = Target->getChar32Align(); break; case BuiltinType::UShort: case BuiltinType::Short: Width = Target->getShortWidth(); Align = Target->getShortAlign(); break; case BuiltinType::UInt: case BuiltinType::Int: Width = Target->getIntWidth(); Align = Target->getIntAlign(); break; case BuiltinType::ULong: case BuiltinType::Long: Width = Target->getLongWidth(); Align = Target->getLongAlign(); break; case BuiltinType::ULongLong: case BuiltinType::LongLong: Width = Target->getLongLongWidth(); Align = Target->getLongLongAlign(); break; case BuiltinType::Int128: case BuiltinType::UInt128: Width = 128; Align = 128; // int128_t is 128-bit aligned on all targets. break; case BuiltinType::Half: Width = Target->getHalfWidth(); Align = Target->getHalfAlign(); break; case BuiltinType::Float: Width = Target->getFloatWidth(); Align = Target->getFloatAlign(); break; case BuiltinType::Double: Width = Target->getDoubleWidth(); Align = Target->getDoubleAlign(); break; case BuiltinType::LongDouble: Width = Target->getLongDoubleWidth(); Align = Target->getLongDoubleAlign(); break; case BuiltinType::NullPtr: Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) Align = Target->getPointerAlign(0); // == sizeof(void*) break; case BuiltinType::ObjCId: case BuiltinType::ObjCClass: case BuiltinType::ObjCSel: Width = Target->getPointerWidth(0); Align = Target->getPointerAlign(0); break; case BuiltinType::OCLSampler: // Samplers are modeled as integers. Width = Target->getIntWidth(); Align = Target->getIntAlign(); break; case BuiltinType::OCLEvent: case BuiltinType::OCLImage1d: case BuiltinType::OCLImage1dArray: case BuiltinType::OCLImage1dBuffer: case BuiltinType::OCLImage2d: case BuiltinType::OCLImage2dArray: case BuiltinType::OCLImage3d: // Currently these types are pointers to opaque types. Width = Target->getPointerWidth(0); Align = Target->getPointerAlign(0); break; } break; case Type::ObjCObjectPointer: Width = Target->getPointerWidth(0); Align = Target->getPointerAlign(0); break; case Type::BlockPointer: { unsigned AS = getTargetAddressSpace( cast<BlockPointerType>(T)->getPointeeType()); Width = Target->getPointerWidth(AS); Align = Target->getPointerAlign(AS); break; } case Type::LValueReference: case Type::RValueReference: { // alignof and sizeof should never enter this code path here, so we go // the pointer route. unsigned AS = getTargetAddressSpace( cast<ReferenceType>(T)->getPointeeType()); Width = Target->getPointerWidth(AS); Align = Target->getPointerAlign(AS); break; } case Type::Pointer: { unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); Width = Target->getPointerWidth(AS); Align = Target->getPointerAlign(AS); break; } case Type::MemberPointer: { const MemberPointerType *MPT = cast<MemberPointerType>(T); std::tie(Width, Align) = ABI->getMemberPointerWidthAndAlign(MPT); break; } case Type::Complex: { // Complex types have the same alignment as their elements, but twice the // size. TypeInfo EltInfo = getTypeInfo(cast<ComplexType>(T)->getElementType()); Width = EltInfo.Width * 2; Align = EltInfo.Align; break; } case Type::ObjCObject: return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); case Type::Adjusted: case Type::Decayed: return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr()); case Type::ObjCInterface: { const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); Width = toBits(Layout.getSize()); Align = toBits(Layout.getAlignment()); break; } case Type::Record: case Type::Enum: { const TagType *TT = cast<TagType>(T); if (TT->getDecl()->isInvalidDecl()) { Width = 8; Align = 8; break; } if (const EnumType *ET = dyn_cast<EnumType>(TT)) { const EnumDecl *ED = ET->getDecl(); TypeInfo Info = getTypeInfo(ED->getIntegerType()->getUnqualifiedDesugaredType()); if (unsigned AttrAlign = ED->getMaxAlignment()) { Info.Align = AttrAlign; Info.AlignIsRequired = true; } return Info; } const RecordType *RT = cast<RecordType>(TT); const RecordDecl *RD = RT->getDecl(); const ASTRecordLayout &Layout = getASTRecordLayout(RD); Width = toBits(Layout.getSize()); Align = toBits(Layout.getAlignment()); AlignIsRequired = RD->hasAttr<AlignedAttr>(); break; } case Type::SubstTemplateTypeParm: return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> getReplacementType().getTypePtr()); case Type::Auto: { const AutoType *A = cast<AutoType>(T); assert(!A->getDeducedType().isNull() && "cannot request the size of an undeduced or dependent auto type"); return getTypeInfo(A->getDeducedType().getTypePtr()); } case Type::Paren: return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); case Type::Typedef: { const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); // If the typedef has an aligned attribute on it, it overrides any computed // alignment we have. This violates the GCC documentation (which says that // attribute(aligned) can only round up) but matches its implementation. if (unsigned AttrAlign = Typedef->getMaxAlignment()) { Align = AttrAlign; AlignIsRequired = true; } else { Align = Info.Align; AlignIsRequired = Info.AlignIsRequired; } Width = Info.Width; break; } case Type::Elaborated: return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); case Type::Attributed: return getTypeInfo( cast<AttributedType>(T)->getEquivalentType().getTypePtr()); case Type::Atomic: { // Start with the base type information. TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType()); Width = Info.Width; Align = Info.Align; // If the size of the type doesn't exceed the platform's max // atomic promotion width, make the size and alignment more // favorable to atomic operations: if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth()) { // Round the size up to a power of 2. if (!llvm::isPowerOf2_64(Width)) Width = llvm::NextPowerOf2(Width); // Set the alignment equal to the size. Align = static_cast<unsigned>(Width); } } 一切真相大白了，已不需要解释了 :-)
类似的话题
-
sizeof 关键字在 C++ 中，并不是一个普通的函数，而是一个编译时常量。理解它的实现，关键在于区分它在编译期和运行时的行为。1. 编译期的魔法：类型的大小计算当你使用 `sizeof` 关键字时，比如 `sizeof(int)` 或者 `sizeof(MyClass)`，编译器会立即在编译阶段............. -
在 C 语言中，`sizeof()` 操作符的魔法之处在于它能够根据其操作数的类型和大小来返回一个数值。而对于数组名和指针，它们虽然在某些上下文中表现得相似（例如，在函数参数传递时），但在 `sizeof()` 的眼中，它们的身份是截然不同的。这其中的关键在于数组名在绝大多数情况下会发生“衰减”（d.............
-
C++ 模板：功能强大的工具还是荒谬拙劣的小伎俩？C++ 模板无疑是 C++ 语言中最具争议但也最引人注目的一项特性。它既能被誉为“代码生成器”、“通用编程”的基石，又可能被指责为“编译时地狱”、“难以理解”的“魔法”。究竟 C++ 模板是功能强大的工具，还是荒谬拙劣的小伎俩？这需要我们深入剖析它的.............
-
C++ 是一门强大而灵活的编程语言，它继承了 C 语言的高效和底层控制能力，同时引入了面向对象、泛型编程等高级特性，使其在各种领域都得到了广泛应用。下面我将尽可能详细地阐述 C++ 的主要优势： C++ 的核心优势：1. 高性能和底层控制能力 (Performance and LowLevel C.............
-
C++ 的核心以及“精通”的程度，这是一个非常值得深入探讨的话题。让我尽量详细地为您解答。 C++ 的核心究竟是什么？C++ 的核心是一个多层次的概念，可以从不同的角度来理解。我将尝试从以下几个方面来阐述：1. 语言设计的哲学与目标： C 的超集与面向对象扩展： C++ 最初的目标是成为 C 语.............
-
C++ 和 Java 都是非常流行且强大的编程语言，它们各有优劣，并在不同的领域发挥着重要作用。虽然 Java 在很多方面都非常出色，并且在某些领域已经取代了 C++，但仍然有一些 C++ 的独特之处是 Java 无法完全取代的，或者说取代的成本非常高。以下是 C++ 的一些 Java 不能（或难以.............
-
C++ `new` 操作符与 `malloc`：底层联系与内存管理奥秘在C++中，`new` 操作符是用于动态分配内存和调用构造函数的关键机制。许多开发者会好奇 `new` 操作符的底层实现，以及它与C语言中的 `malloc` 函数之间的关系。同时，在对象生命周期结束时，`delete` 操作符是.............
-
好，咱们来聊聊 C++ 单例模式里那个“为什么要实例化一个对象，而不是直接把所有成员都 `static`”的疑问。这确实是很多初学者都会纠结的地方，感觉直接用 `static` 更省事。但这里面涉及到 C++ 的一些核心概念和设计上的考量，咱们一点点掰开了说。 先明确一下单例模式的目标在深入“`st.............
-
在 C++ 标准库的 `std::string` 类设计之初，确实没有提供一个直接的 `split` 函数。这与其他一些高级语言（如 Python、Java）中普遍存在的 `split` 方法有所不同。要理解为什么会这样，我们需要深入探究 C++ 的设计哲学、标准库的演进过程以及当时的开发环境和需求.............
-
C 扩展方法：一把双刃剑C 的扩展方法，顾名思义，允许我们为现有的类型添加新的方法，而无需修改原始类型的源代码。这种能力最初听起来像是魔法，能够让代码更加优雅、富有表现力，并且提升了代码的复用性。然而，正如许多强大的工具一样，扩展方法也是一把双刃剑，如果使用不当，可能会导致代码可读性下降、维护困难，.............
-
C++ 的 `std::list`，作为 STL（Standard Template Library）中的一员，它是一种双向链表（doubly linked list）。它的核心特点在于，每个节点都存储了数据本身，以及指向前一个节点和后一个节点的指针。这使得 `std::list` 在某些特定场景下.............
-
你问了一个非常关键的问题，而且问得非常实在。确实，C++ 的智能指针，尤其是 `std::unique_ptr` 和 `std::shared_ptr`，在很大程度上解决了 C++ 中常见的野指针和内存泄漏问题。这玩意儿在 C++ 世界里，堪称“救世主”般的存在。那么，为什么大家对 Rust 的内存.............
-
C++ 中的常量后缀，顾名思义，就是用来标识字面量（literal）是何种类型的。虽然编译器通常能够通过字面量的形式推断出其类型，但在很多情况下，使用常量后缀能够明确表达开发者的意图，避免潜在的类型转换问题，并提升代码的可读性和健壮性。我们来详细探讨一下常量后缀在哪些情况下特别有用，并说明其背后的原.............
-
CRTP，也就是Curiously Recurring Template Pattern（奇特的递归模板模式），在C++中，它是一种利用模板的静态分派特性来实现多态的一种精巧技巧。很多人听到“多态”首先想到的是虚函数和运行时多态，但CRTP带来的多态是“静态多态”，这意味着多态的决策是在编译期完成的.............
-
C++ 运行时多态：性能的代价与权衡在 C++ 的世界里，我们常常惊叹于它的灵活性和表达力。其中，运行时多态（Runtime Polymorphism）是实现这一能力的关键机制之一，它允许我们在程序运行时根据对象的实际类型来决定调用哪个函数。这就像一个剧团的导演，在舞台上，他可以根据演员扮演的角色，.............
-
C++的move构造，作为语言引入的一项重要特性，其设计初衷是为了解决资源管理中的性能瓶颈，特别是针对那些拥有昂贵资源（如堆内存、文件句柄、网络连接等）的对象。它允许我们将一个对象的资源“转移”到另一个对象，而不是通过昂贵的拷贝操作来复制这些资源。然而，随着这项特性的应用和深入理解，关于其设计是否“.............
-
C++ 的 `switch` 语句之所以不默认添加 `break` 语句，这是 C++ 设计者们经过深思熟虑后做出的一个选择，其背后有明确的理由和意图。理解这一点，需要我们深入到 `switch` 语句的本质和它与其他控制流语句的区别。 1. fallthrough（贯穿）的意图与灵活性C++ 的 .............
-
咱们聊聊 C 里的接口，这玩意儿在实际开发中，那可是个顶顶重要的角色，但要是光看定义，可能觉得有点抽象。我试着把这些实际用法给你掰开了揉碎了讲讲，尽量避免那些“AI味儿”的说法，就跟咱们哥俩坐一块儿聊天一样。接口是啥？通俗点说，就是一份“合同”你可以把接口想象成一个约定，或者一份“合同”。这份合同规.............
-
C 的 `return ref` 并不是一个直接存在的语法特性。你可能是在将 `ref` 关键字用于函数参数传递（`ref` 参数）和 `readonly ref` 用于安全地返回对大型结构体的引用时产生了混淆。让我们详细探讨一下 C 中与“引用返回”相关的概念，以及它们在实际开发中的应用场景。 1.............
-
C 的 `async` 和 `await` 关键字，从表面上看，是让异步编程变得如同步编程一样简洁易读。但它们的背后，隐藏着一套精巧的机制，核心在于状态机（State Machine）。在深入之前，先理解一下异步操作的本质：它不是让 CPU 真的停止工作去等待，而是将一个耗时的工作（比如网络请求、文.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有