Swift中值类型Array的元素访问与追加：是否类似C用指针解引用？

Great question! Let's unpack how Swift's Array—a value type—handles element access and appends, and whether it uses C-style pointer operations under the hood.

1. 核心基础：Swift Array的底层存储逻辑 #

First off, even though Array is a value type (implemented as a struct), it doesn't store all its elements directly in the struct itself. Instead, it uses a hidden reference to a contiguous memory buffer (backed by heap allocation). This is where the magic of Copy-On-Write (COW) comes in—this mechanism lets Swift avoid unnecessary copies while preserving value semantics.

2. 元素访问的实现过程 #

When you access an element like myArray[2], here's what happens under the hood:

• The subscript(_: Int) method of Array is called. First, it performs a bounds check—if the index is out of range, it triggers a runtime crash (unlike C, which lets you access memory out of bounds silently).
• If the index is valid, Swift checks if the array's buffer is uniquely referenced (via COW tracking). If it is, it proceeds to access the buffer directly.
• Under the covers, Swift uses safe pointer types (like UnsafeBufferPointer) to interact with the contiguous memory. The logic is similar to C's *(basePtr + index), but it's wrapped in Swift's type-safe APIs. For example, it might get a pointer to the start of the buffer, then use ptr.advanced(by: index) to get the pointer to the target element, then load the value from that pointer.
• Crucially, all this pointer logic is encapsulated in the standard library—you never have to deal with raw pointers directly as a developer, unless you explicitly opt into unsafe code.

3. 追加操作（append(_:)）的实现 #

Appending elements to an Array leverages COW to keep performance efficient:

• First, Swift checks if the array's buffer has enough capacity (unused space at the end of the buffer) to fit the new element. If yes, and if the buffer is uniquely referenced, it simply writes the new element to the next available position in the existing buffer—no copy needed.
• If the buffer is full, Swift allocates a new, larger buffer (usually doubling the capacity to amortize future appends), copies all existing elements from the old buffer to the new one, then writes the new element.
• If the array is shared (multiple variables reference the same buffer), Swift first makes a full copy of the buffer to ensure each value type instance has its own independent storage, then performs the append on the new buffer.
• Again, the actual memory operations use safe pointer APIs to copy elements and write new values—raw C-style pointer arithmetic is abstracted away.

4. Does Swift use C-style *(a + 2) under the hood? #

In terms of low-level logic, yes—accessing elements in a contiguous buffer does involve calculating an offset from a base pointer and dereferencing it. But Swift doesn't use the exact C syntax *(a + 2). Instead, it uses its own type-safe pointer operations:

• For example, an UnsafeBufferPointer lets you access elements via subscript (ptr[index]), which is equivalent to the C-style dereference but with built-in safety checks.
• The standard library's implementation uses these safe pointer APIs to avoid undefined behavior, which is a key difference from C's raw pointer operations.

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