C++ 程序可以创建、销毁、引用、访问并操作对象。

在 C++ 中，一个对象是拥有这些性质的一段存储区域：

  • 大小（可以使用 sizeof 获取）；
  • 对齐要求（可以使用 alignof 获取）；
  • 存储期（自动、静态、动态、线程局部）；
  • 生存期（与存储期绑定，或为临时的）
  • 类型；
  • 值（可能是不确定的，例如默认初始化的非类类型）；
  • 名字（可选）。

以下实体都不是对象：值，引用，函数，枚举项，类型，类的非静态成员，位域，模板，类或函数模板的特化，命名空间，形参包，和 this。

变量是由声明所引入的对象或不是非静态数据成员的引用。

对象是由定义，new 表达式，throw 表达式，改变联合体的活跃成员，以及需要临时对象的时候创建的。

对象表示与值表示

对于一个 T 类型的对象，其对象表示 (object representation) 是和它开始于同一个地址，且长度为 sizeof(T) 的一段 unsigned char 类型的对象序列。

对象的值表示 (value representation)则是用于持有它的类型 T 的值的位的集合。

对于可平凡复制 (TriviallyCopyable) 类型，其值表示是对象表示的一部分，这意味着复制该对象在存储中所占据的字节就足以产生另一个具有相同值的对象（除非这个值是该类型的一个“陷阱表示（trap representation）”，将它读取到 CPU 中会产生一个硬件异常，就像浮点值的 SNaN（“Signaling NaN 发信非数”）或整数值的 NaT（“Not a Thing 非事物”））。

反过来不一定是对的：可平凡复制 (TriviallyCopyable) 类型的两个具有不同对象表示的对象可能表现出相同的值。例如，浮点数有多种位模式都表示相同的特殊值 NaN 。更常见的是，对象表示的一些位可能根本不参与值表示；这些位可能是为了满足对齐要求，位域的大小等得以满足而填充其间的。

  1. #include <cassert>
  2. struct S {
  3.     char c;  // 1 字节值
  4.              // 3 字节填充（假设 alignof(float) == 4 ）
  5.     float f; // 4 字节值（假设 sizeof(float) == 4 ）
  6.     bool operator==(const S& arg) const { // 基于值的相等
  7.         return c == arg.c && f == arg.f;
  8.     }
  9. };
  10.  
  11. void f() {
  12.     static_assert(sizeof(S) == 8);
  13.     S s1 = {'a', 3.14};
  14.     S s2 = s1;
  15.     reinterpret_cast<unsigned char*>(&s1)[2] = 'b'; // 更改填充的第 2 字节
  16.     assert(s1 == s2); // 值并未更改
  17. }

对于 char，signed char，和 unsigned char 类型的对象，除非它们是大小过大的位域，否则其对象表示的每个位都参与其值表示，而且每一种位模式都表示一个独立的值（没有填充位或陷阱位，不允许值的多种表示）。

子对象

一个对象可以包含其他对象，它们被称为子对象。子对象有：

  • 成员对象
  • 基类子对象
  • 数组元素

不是其他任何对象的子对象的对象称为完整对象。

若子对象是以下之一，则它潜在重叠：

  • 基类子对象，或
  • 声明有 [[no_unique_address]] 属性的非静态数据成员。

完整对象、成员对象和数组元素也被称为最终派生对象 (most derived object) ，以便和基类子对象区分开。不是位域且未被标记为 [[nounique_address]] (C++20 起)的最终派生对象_的大小不能为零（基类子对象的大小可能为零，即使无 [[no_unique_address]] 也是如此 (C++20 起)：参见空基类优化）。

任何两个具有交叠的生存期的（非位域）对象必然有不同的地址，除非其中一个是另一个的子对象或为另一个对象提供存储，或者两个对象都是同一个完整对象中的不同类型的子对象，且其中一个是零大小的子对象。

  1. static const char c1 = 'x';
  2. static const char c2 = 'x';
  3. assert(&c1 != &c2); // 值相同，地址不同

多态对象

声明或继承了至少一个虚函数的类类型的对象是多态对象。每个多态对象中，实现都会储存额外的信息（在所有现存的实现中，如果没被编译器优化掉的话，这就是一个指针），它被用于进行虚函数的调用，RTTI 功能特性（dynamic_cast 和 typeid）也用它在运行时确定对象创建时所用的类型，而不管使用它的表达式是什么类型。

对于非多态对象，值的解释方式由使用对象的表达式所确定，这在编译期就已经决定了。

运行此代码

  1. #include <iostream>
  2. #include <typeinfo>
  3. struct Base1 {
  4.     // 多态类型：声明了虚成员
  5.     virtual ~Base1() {}
  6. };
  7. struct Derived1 : Base1 {
  8.      // 多态类型：继承了虚成员
  9. };
  10.  
  11. struct Base2 {
  12.      // 非多态类型
  13. };
  14. struct Derived2 : Base2 {
  15.      // 非多态类型
  16. };
  17.  
  18. int main()
  19. {
  20.     Derived1 obj1; // object1 创建为类型 Derived1
  21.     Derived2 obj2; // object2 创建为类型 Derived2
  22.  
  23.     Base1& b1 = obj1; // b1 指代对象 obj1
  24.     Base2& b2 = obj2; // b2 指代对象 obj2
  25.  
  26.     std::cout << "b1的表达式类型: " << typeid(decltype(b1)).name() << ' '
  27.               << "b2的表达式类型: " << typeid(decltype(b2)).name() << '\n'
  28.               << "b1 的对象类型: " << typeid(b1).name() << ' '
  29.               << "b2 的对象类型: " << typeid(b2).name() << '\n'
  30.               << "b1 的大小: " << sizeof b1 << ' '
  31.               << "b2 的大小: " << sizeof b2 << '\n';
  32. }

可能的输出：

  1. b1 的表达式类型: Base1 b2 的表达式类型: Base2
  2. b1 的对象类型: Derived1 b2 的对象类型: Base2
  3. b1 的大小: 8 b2 的大小: 1

严格的别名使用

在很多情况下，通过类型与对象的创建类型不同的表达式来访问对象都是未定义行为，其例子和例外请参考 reinterpret_cast。

对齐

每个对象类型都具有被称为对齐要求（alignment requirement）的性质，它是一个整数（类型为 std::size_t，总是 2 的幂），表示这个类型的不同对象所能分配放置的连续相邻地址之间的字节数。可以使用 alignof 或 std::alignment_of 来查询类型的对齐要求。可以使用指针对齐函数 std::align 来获取某个缓冲区中经过适当对齐的指针，还可以使用 std::aligned_storage 来获取经过适当对齐的存储区。

对象类型会强制该类型的所有对象实行这个类型的对齐要求；可以使用 alignas 来要求更严格的对齐（更大的对齐要求）。

为了使类中的所有非静态成员都符合对齐要求，会在一些成员后面插入一些填充。

运行此代码

  1. #include <iostream>
  2.  
  3. // S 类型的对象可以在任何地址上分配
  4. // 因为 S.a 和 S.b 都可以在任何地址上分配
  5. struct S {
  6.   char a; // 大小：1，对齐：1
  7.   char b; // 大小：1，对齐：1
  8. }; // 大小：2，对齐：1
  9.  
  10. // X 类型的对象只能在 4 字节边界上分配
  11. // 因为 X.n 必须在 4 字节边界上分配
  12. // 因为 int 的对齐要求（通常）就是 4
  13. struct X {
  14.   int n;  // 大小：4，对齐：4
  15.   char c; // 大小：1，对齐：1
  16.   // 三个填充字节
  17. }; // 大小：8，对齐：4
  18.  
  19. int main()
  20. {
  21.     std::cout << "sizeof(S) = " << sizeof(S)
  22.               << " alignof(S) = " << alignof(S) << '\n';
  23.     std::cout << "sizeof(X) = " << sizeof(X)
  24.               << " alignof(X) = " << alignof(X) << '\n';
  25. }

可能的输出：

  1. sizeof(S) = 2 alignof(S) = 1
  2. sizeof(X) = 8 alignof(X) = 4

最弱的对齐（最小的对齐要求）是 char 、 signed char 和 unsigned char 的对齐，等于 1 ；所有类型中最大的基础对齐（fundamental alignment）是 std::max_align_t 的对齐。当使用 alignas 使某个类型的对齐比 std::max_align_t 的更严格（更大）时，称其为具有扩展对齐（extended alignment）要求的类型。具有扩展对齐的类型或包含具有扩展对齐的非静态成员的类，称为过对齐（over-aligned）类型。 new 表达式、 std::allocator::allocate 和 std::get_temporary_buffer 是否支持过对齐类型是由实现定义的。以过对齐类型实例化的分配器 (Allocator) ，允许在编译期发生实例化失败，在运行时抛出 std::bad_alloc 异常，安静地忽略不支持的对齐要求，也允许正确的处理它们。

参考