关于C++17草案n4659中条款3.3语句含义的技术问询

Great question! Let's break down exactly what that "no smaller array object" clause means, using the provided example to make it concrete.

First, let's recap the context: this rule defines which array object is considered the storage provider for a new object created in the memory associated with an array of unsigned char or std::byte. The three conditions work together to narrow down the correct array, and clause (3.3) is the final filter to pick the most appropriate one.

What does clause (3.3) actually mean? #

Put simply: when you create a new object inside an array's memory, we need to find the smallest possible array object that meets the first two conditions (its lifetime is active, and the new object fits entirely inside it). If there's a smaller array that satisfies those constraints, that smaller array is the one providing storage—not any larger outer array that also contains the new object.

This ensures we associate the new object with the most specific, innermost array that contains it, rather than a bigger, more outer array that just happens to include the memory region.

Let's walk through the example to see this in action #

Let's look at the code snippet step by step:

struct A { unsigned char a[32]; };
struct B { unsigned char b[16]; };
A a;
B *b = new (a.a + 8) B; // a.a provides storage for *b
int *p = new (b->b + 4) int; // b->b provides storage for *p

1. For the *b object:

   • *b is placed starting at a.a + 8, so it's entirely within a.a (the 32-byte array).
   • At this point, there are no smaller array objects in that region (we haven't created b->b yet—its lifetime starts when *b is constructed).
   • Since there's no smaller array that meets the constraints, a.a is the storage provider for *b.

2. For the *p object:

   • *p is placed starting at b->b +4, which is inside both b->b (the 16-byte array) and the outer a.a (32-byte array).
   • Now, b->b is an active array object (its lifetime is tied to *b, which is alive), and *p fits entirely inside it.
   • Is there a smaller array than b->b that contains *p? No—there's no other nested array object in that 4-byte region of b->b.
   • So b->b is the smallest array that meets all constraints, making it the storage provider for *p (not the larger a.a).

Why does this matter? #

This rule is critical for the C++ object model because it defines the relationship between the new object and its underlying storage. For example:

• If we destroy *b, the lifetime of b->b ends too. Since b->b is the storage provider for *p, *p can no longer be accessed legally (its storage's lifetime has ended).
• If a.a were the provider instead, *p could still be used as long as a remains alive.

By picking the smallest valid array, the standard ensures that the storage association is as precise as possible, aligning with the programmer's intent when using nested arrays or placement new.

内容的提问来源于stack exchange，提问作者Serge Ballesta