每个对象和引用都有生存期 (lifetime) ，这是一项运行时性质：每个对象或引用在程序执行时都存在一个时刻开始其生存期，也都存在一个时刻结束其生存期。

对象的生存期始于：

• 获得拥有其类型的正确大小与对齐的存储，并且
• 完成其初始化（若存在）（包括不经由构造函数或经由平凡默认构造函数的默认初始化），除非

• 若该对象是联合体成员或其子对象，则其生存期在该联合体成员是联合体中的被初始化成员，或它被设为活跃才开始，或者
• 若该对象内嵌于联合体对象，则其生存期开始于平凡特殊成员函数赋值或构造含有它的联合体对象，或者
• 数组对象的生存期可以因为该对象被 std::allocator::allocate 分配而开始。

某些操作在给定的存储区域中隐式创建对象，并开始其生存期，这些对象拥有隐式生存期类型（见后述）。

对象的生存期结束于：

• 若它拥有非类类型，则为销毁该对象时（可能经由伪析构函数调用） (C++20 起)，或者
• 若它拥有类类型，则为析构函数调用开始时，或者
• 该对象所占据的存储被释放，或被不内嵌于它的对象所重用。

对象的生存期与它的存储的生存期相同，或者内嵌于其中，参见存储期。

引用的生存期，从其初始化完成之时开始，并与标量对象以相同的方式结束。

注意：被引用对象的生存期可能在引用的生存期结束之前就会结束，这会造成悬垂引用。

非静态数据成员和基类子对象的生存期，按照类初始化顺序开始和结束。

隐式生存期类型

一个对象类型被称为隐式生存期类型，若它是：

• 标量类型，或
• 数组类型，或
• 聚合类类型，或
• 拥有下列成员的类类型

• 至少一个平凡的符合构造函数，以及
• 一个平凡且未被删除的析构函数，

• 或上述类型之一的 cv 限定版本。

注意若隐式创建的对象的子对象不拥有隐式生存期类型，则其生存期不会隐式开始。

临时对象的生存期

在下列情况中进行纯右值的实质化，从而能将它作为泛左值使用，即 (C++17 起)创建临时对象：

• 绑定引用到纯右值

所有临时对象的销毁都是在（词法上）包含创建它的位置的全表达式的求值过程的最后一步进行的，而当创建了多个临时对象时，它们是以其创建的相反顺序销毁的。即便求值过程以抛出异常而终止也是如此。

对此有两种例外情况：

• 可以通过绑定到 const 左值引用或右值引用 (C++11 起)来延长临时对象的生存期，细节见引用初始化。

存储的重用

如果对象可平凡析构，或者程序并不关心析构函数中的副作用的话，程序不必调用该对象的析构函数。然而如果程序显式终止非平凡对象的生存期的话，它必须确保在可能隐式地调用析构函数前（例如对于自动对象是由于退出作用域或发生异常，对于线程局部对象是由于线程退出，或对于静态对象是由于程序退出），原位构造（比如使用布置 new ）一个新的同类型对象；否则行为未定义。

class T {}; // 平凡
struct B {
    ~B() {} // 非平凡
};
void x() {
    long long n; // 自动、平凡
    new (&n) double(3.14); // 以不同的类型进行重用没有问题
} // OK
void h() {
    B b; // 自动的非可平凡析构对象
    b.~B(); // 生存期结束（不必要，因为没有副作用）
    new (&b) T; // 类型错误：直到析构函数被调用之前都没问题
} // 调用了析构函数：未定义行为

重用某个具有静态、线程局部或者自动存储期的 const 完整对象所占据的存储是未定义行为，因为这种对象可能被存储于只读内存中。

struct B {
    B(); // 非平凡
    ~B(); // 非平凡
};
const B b; // const 静态对象
void h() {
    b.~B(); // b 的生存期结束
    new (const_cast<B*>(&b)) const B; // 未定义行为：试图重用 const 对象
}

一旦在某个对象所曾占据的地址上创建了新的对象，所有原对象的指针、引用及名字都会自动代表新的对象，而且一旦新对象的生存期开始，它们就可以用于操作这个新对象，但只能在满足下列条件的情况下才能这样做：

• 新对象的存储与原对象曾占据的存储位置严格重合
• 新对象和原对象（忽略顶层的 cv 限定符）具有相同的类型
• 原对象的类型非 const 限定
• 如果原对象具有类类型，则它不能含有任何 const 限定的类型或引用类型的非静态数据成员
• 原对象曾为 T 类型的最终派生对象，且新对象也是 T 类型的最终派生对象（就是说，它们都不是基类子对象）。

struct C {
  int i;
  void f();
  const C& operator=( const C& );
};
const C& C::operator=( const C& other) {
  if ( this != &other ) {
    this->~C();          // *this 的生存期结束
    new (this) C(other); // 创建了 C 类型的新对象
    f();                 // 定义明确的
  }
  return *this;
}
C c1;
C c2;
c1 = c2; // 定义明确的
c1.f();  // 定义明确的；c1 代表 C 类型的一个新对象

struct X { const int n; };
union U { X x; float f; };
void tong() {
  U u = { { 1 } };
  u.f = 5.f;                          // OK ：创建了 'u' 的新的子对象
  X *p = new (&u.x) X {2};            // OK ：创建了 'u' 的新的子对象
  assert(p->n == 2);                  // OK
  assert(*std::launder(&u.x.n) == 2); // OK
  assert(u.x.n == 2);                 // 未定义： 'u.x' 不指名新的子对象
}

template<typename ...T>
struct AlignedUnion {
  alignas(T...) unsigned char data[maxv(sizeof(T)...)];
};
int f() {
  AlignedUnion<int, char> au;
  int *p = new (au.data) int;     // OK ： au.data 提供存储
  char *c = new (au.data) char(); // OK ： *p 的生存期结束
  char *d = new (au.data + 1) char();
  return *c + *d; // OK
}

在生存期之外进行访问

在对象的生存期开始之前但其存储将要占据的存储已经分配之后，或者在对象的生存期已经结束之后但其所曾占据的存储被重用或释放之前，对代表这个对象的泛左值表达式的以下这些用法是未定义的：

1. 左值向右值转换（比如对接受其值的函数进行调用）。
2. 访问其非静态数据成员或调用非静态成员函数。
3. 绑定引用到其某个虚基类子对象。
4. dynamic_cast 或 typeid 表达式。

以上规则也适用于指针（绑定引用到虚基类改为隐式转换为虚基类的指针），并有两条额外的规则：

1. 对指向没有对象的存储的指针进行 static_cast 时只允许将其强制转换为（可能 cv 限定的）void*。
2. 转型到 void* 的指向无对象存储的指针，只能被 static_cast 到指向可能 cv 限定的 char 、可能 cv 限定的 unsigned char 或可能 cv 限定的 std::byte 的指针。

在构造和析构的过程中，还有其他的限制条件，参见在构造和析构过程中调用虚函数。

注解

在核心问题 2256 解决前，非类对象（存储期的终止）和类对象（按构造顺序的逆序）的生存期终止规则存在差别：

struct A {
  int* p;
  ~A() { std::cout << *p; } // CWG2256 起为未定义行为： n 不活到 a 的生存期之后
                            // CWG2256 前有恰当定义：打印 123
};
void f() {
  A a;
  int n = 123; // 假如 n 不活到 a 的生存期之后，则能把这条语句优化掉（死存储）
  a.p = &n;
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

参阅