Pass value to UnsafeRawPointer it prints different address

Using Swift
1 
func printMemoryAddress(_ pointer: UnsafeRawPointer) {
    print(pointer)
}

When it is a string:

var str = "what is that?"

withUnsafePointer(to: &str) {
    print($0)
}

printMemoryAddress(&str)
printMemoryAddress(str)

/*
It prints:
0x000055b5e702ae78
0x000055b5e702ae78
0x000055b5e7d6aa70
*/

When it is an array:

var arr = [12]

withUnsafePointer(to: &arr) {
    print($0)
}

printMemoryAddress(&arr)
printMemoryAddress(arr)

/*
0x000055f252050e88
0x000055f253cdba40
0x000055f253cdba40
*/

We could see, when it is string, the output of the first two addresses are the same.
what is the third address of the string without &?

But when it is an array, the output of the second and the third lines are the same address, but the first line is different, what is this address and why?

what is the different with & and without?

2 Likes
2

In order to make C interoperation easier, Swift does some special casing when passing strings or arrays to functions that take pointer parameters. Unfortunately, as you've seen, the behavior can be surprising and inconsistent.

What's happening is that when passing a string or array as a pointer parameter, you are sometimes passing the location of the string or array's data and sometimes passing the location of the local variable, which is almost never what you want. Unpleasantly, the same syntax has different behavior for the two types. Both versions of the call below pass a pointer to the array's storage, but only one does that for the string:

printMemoryAddress(&str)   // passes a pointer to `str`, the variable
printMemoryAddress(str)    // passes a pointer to the storage of `str`*

// the first syntax is required if the pointer is mutable:
printMemoryAddress(&arr)   // passes a pointer to the storage of `arr`
printMemoryAddress(arr)    // passes a pointer to the storage of `arr`

For both types, calling withUnsafePointer(to:) gives you access to the location of the local variable, not the data it represents. Instead of using that function, each of those types has methods that you can use to access their contents as a pointer (be sure to read the documentation for all methods that provide unsafe access to memory):

str.withUTF8 { ... }
str.withCString { ... }

arr.withUnsafeBuffer { ... }
arr.withUnsafeMutableBuffer { ... }

*As a final note, since strings can have different representations internally, passing a string with the printMemoryAddress(str) syntax can require a copy that ends up getting discarded immediately after the call, which can have performance impacts.

There used to be an article in the Swift documentation that covered these conventions, but I can't seem to find it anymore! If I come across it, I'll add it here.

8 Likes
3

if this is the case:

var str = "what is that?"

func printChar(_ pointer: UnsafeRawPointer) {

    var p = pointer.assumingMemoryBound(to: CChar.self)
    var buffer = String()
    while true {
        let c = p.pointee
        let uC = UnicodeScalar(UInt8(c))
        buffer.append(uC.description)
        if p.pointee == 0 {
            break
        }
        p = p.advanced(by: 1)
    }
    print(buffer)
}

printChar(&str)
printChar(str)

/*
It prints:
what is that?
what is that?
*/

So, why would it get this result?

1 Like
4

Ah, good catch! That's because when strings are small, Swift's String type stores its data inline, so the data and local variable are at the same memory location. If you increase the length of your string (past 14 UTF8 code units on 64-bit platforms, I believe), then the string will use a separate allocation for its data, and you should see the difference in behavior.

2 Likes