How to copy a pointer to an array in Swift?

Question

I'm basically trying to wrap a C structure within a Swift class.

The Swift class has an instance property of type of the C structure.

The C structure contains several properties which are of type const char *.

In order to assign values to the structure, I wrote getters and setters for each property:

public class MyClass: NSObject {
    private var configuration = c_structure_config()
}

// Function of MyClass
// f.ex. on "registrationUri:"
private(set) public var registrationUri: String {
    get {
        return String(cString: configuration.reg_uri)
    }
    set {
        if (configuration.reg_uri != nil) {
            configuration.reg_uri.deallocate()
        }
        let maxLength = newValue.count + 1 // +1 for NULL
        var buffer: [CChar] = [CChar](UnsafeMutableBufferPointer<Int8>.allocate(capacity: maxLength))
        guard newValue.getCString(&buffer, maxLength: maxLength, encoding: .utf8) == true else {
            fatalError("Could not allocate memory for Account Config reg uri")
        }
        // "configuration" is the instance property (see above)
        // reg_uri is of type char const *
        configuration.reg_uri = UnsafePointer<Int8>(buffer)
    }
}

However, this approach leads to weird crashes and error reports complaining about pointers overlapping range (Fatal error: UnsafeMutablePointer.initialize overlapping range).

I know that I'm deallocating and allocating memory whenever the string is set and that that's probably not very efficient. I haven't found a better solution so far though.

What's wrong here (or is this right, I made a wrong assumption and I gotta search somewhere else)?

Answer 1

There are a couple of problems with your solution.

First, it is ill-advised to use String.count to count to get the size of the underlying C buffer. The reason is that String.count returns the number of actual characters of your string, and not the number of bytes used to represent it. Not all characters fit the 256 bits of Int8 (a.k.a. CChar). Hence, your code will probably crash if you attempt setting your property with non-ascii characters. It is better to use the String.utf8CString property, which returns a contiguous array of CChar.

Second, since your buffer is allocated within the setter, it will be deallocated when your setter returns (Swift arrays are instances of value types, who's lifetime is bound by the stack). That means the pointer corresponding to buffer's base is actually invalidated when your setter returns. I suspect this is the reason why the error you reported occurs at runtime.

Finally, please do not test for true in guards and if statements.

Here is a corrected version:

var registrationUri: String {
  get {
    return String(cString: reg_uri)
  }
  set {
    if (reg_uri != nil) {
      reg_uri.deallocate()
    }

    newValue.withCString { cString in
      // No need to add 1, newValue.utf8CString already has the correct buffer capacity.
      let capacity = newValue.utf8CString.count
      let buffer: UnsafeMutablePointer<Int8> = .allocate(capacity: capacity)
      buffer.assign(from: cString, count: capacity)
      reg_uri = UnsafePointer(buffer)
    }
  }
}

// ...

myInstance.registrationUri = "こんいちは"
print(myInstance.registrationUri)
// Prints "こんいちは"