对象

来自cppreference.com
< cpp‎ | language

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

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

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

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

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

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

目录

[编辑] 对象表示与值表示

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

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

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

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

#include <cassert>
struct S {
    char c;  // 1 个字节的值
             // 3 个字节的填充
    float f; // 4 个字节的值(假定 sizeof(float) == 4 )
    bool operator==(const S& arg) const { // 基于值的相等性
        return c == arg.c && f == arg.f;
    }
};
assert(sizeof(S) == 8);
S s1 = {'a', 3.14};
S s2 = s1;
reinterpret_cast<char*>(&s1)[2] = 'b'; // 改变其第二个字节
assert(s1 == s2); // 值并未变化

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

[编辑] 子对象

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

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

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

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

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

static const char c1 = 'x';
static const char c2 = 'x';
assert(&c1 != &c2); // 值相同,地址不同

[编辑] 多态对象

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

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

#include <iostream>
#include <typeinfo>
struct Base1 {
    // 多态类型:声明了虚成员
    virtual ~Base1() {}
};
struct Derived1 : Base1 {
     // 多态类型:继承了虚成员
};
 
struct Base2 {
     // 非多态类型
};
struct Derived2 : Base2 {
     // 非多态类型
};
 
int main()
{
    Derived1 obj1; // object1 创建为类型 Derived1
    Derived2 obj2; // object2 创建为类型 Derived2
 
    Base1& b1 = obj1; // b1 指代对象 obj1
    Base2& b2 = obj2; // b2 指代对象 obj2
 
    std::cout << "b1的表达式类型: " << typeid(decltype(b1)).name() << ' '
              << "b2的表达式类型: " << typeid(decltype(b2)).name() << '\n'
              << "b1的对象类型: " << typeid(b1).name() << ' '
              << "b2的对象类型: " << typeid(b2).name() << '\n'
              << "b1的大小: " << sizeof b1 << ' '
              << "b2的大小: " << sizeof b2 << '\n';
}

输出:

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

[编辑] 严格的别名使用

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

[编辑] 对齐

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

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

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

#include <iostream>
 
// S 类型的对象可以在任何地址上分配
// 因为 S.a 和 S.b 都可以在任何地址上分配
struct S {
  char a; // 大小:1,对齐:1
  char b; // 大小:1,对齐:1
}; // 大小:2,对齐:1
 
// X 类型的对象只能在 4 字节边界上分配
// 因为 X.n 必须在 4 字节边界上分配
// 因为 int 的对齐要求(通常)就是 4
struct X {
  int n;  // 大小:4,对齐:4
  char c; // 大小:1,对齐:1
  // 三个填充字节
}; // 大小:8,对齐:4
 
int main()
{
    std::cout << "sizeof(S) = " << sizeof(S)
              << " alignof(S) = " << alignof(S) << '\n';
    std::cout << "sizeof(X) = " << sizeof(X)
              << " alignof(X) = " << alignof(X) << '\n';
}

输出:

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

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

[编辑] 参考

对象C 文档