Converting a C string inside a struct to a Swift String

Swift 5.2 — this solution can accepts arbitrary-length tuples, doesn’t do any extra copying, and uses the latest conventions for safe memory binding.

extension String {
    init<T>(tupleOfCChars: T, length: Int = Int.max) {
        self = withUnsafePointer(to: tupleOfCChars) {
            let lengthOfTuple = MemoryLayout<T>.size / MemoryLayout<CChar>.size
            return $0.withMemoryRebound(to: UInt8.self, capacity: lengthOfTuple) {
                String(bytes: UnsafeBufferPointer(start: $0, count: Swift.min(length, lengthOfTuple)), encoding: .utf8)!
            }
        }
    }
}

I have been in the same boat the last few days. I eventually came out with a general scheme to deal with C Arrays in C structs from C API, good if one has to deal with large arrays, but it must make use of "unsafeBitCast()". Also it must be adapted for each single fixed C array. This is the adaption to answer the current question (the code has been tested and it is working):

// This is our C array in this case char[8]
typealias CArray8Chars = (
    CChar, CChar, CChar, CChar, CChar, CChar, CChar, CChar
)
let zero8Chars: CArray8Chars = (
    0, 0, 0, 0, 0, 0, 0, 0
)
struct CString8  {
    private var value: CArray8Chars = zero8Chars
    var asString: String {
        mutating get {
            var cString = [CChar]()
            for i in 0..<sizeofValue(value) {
                cString += [self[i]]
                if self[i] == 0 {
                    break
                }
            }
            return String.fromCStringRepairingIllFormedUTF8(&cString).0!
        }
        set {
            let cchars = Array(newValue.utf8).map { CChar(Int8(bitPattern: UInt8($0))) }
            for i in 0..<min(cchars.count,sizeof(CArray8Chars))-1 { self[i] = cchars[i] }
            self[min(cchars.count,sizeof(CArray8Chars))-1] = 0
        }
    }
    subscript(i: Int) -> CChar {
        mutating get {
            let bytePtr = withUnsafePointer(&value, { (ptr) -> UnsafePointer<CChar> in
                return unsafeBitCast(ptr, UnsafePointer<CChar>.self)
            })
            return bytePtr[i]
        }
        set {
            let bytePtr = withUnsafeMutablePointer(&value, { (ptr) -> UnsafeMutablePointer<CChar> in
                return unsafeBitCast(ptr, UnsafeMutablePointer<CChar>.self)
            })
            bytePtr[i] = newValue
        }
    }
}

Now in the case of the motorcycle C struct it will be as following:

struct MotorCycle {
    var mfg     = CString8()
    var model   = CString8()
}
var cycle = MotorCycle()
GetMotorcycle(&cycle)
var manufacturer = cycle.mfg.asString // Since the string comes from C it works fine 

This also allows to set mfg/model using Unicode strings, but with a caveat:

// "💖" utf8 encoding makes the C string too big, so it gets cut. What's left represents an unknown char
cycle.model.asString = "I do 💖 Motor Bikes"
println(cycle.model.asString)

and makes the tuples indexable:

println(cycle.mfg[2])
cycle.model[2] = 32 // space. They are CChars, thus Int8

If one likes CString8 can be further extended, allowing to get/set substrings and the likes. But that's beyond the scope of this question.

Swift's built-in reflect() and MirrorType are pretty neat and allow us to inspect the tuple, determine its length, and iterate over its contents.

let tuple = (100, 120, 49, 100)
let mirror = reflect(tuple)

var string = String()
for index in 0..<mirror.count {
    let value = mirror[index].1.value as! Int
    let character = UnicodeScalar(value)
    string.append(character)
}

println(string) // prints "dx1d"

Here is a type safe solution that works on swift 2.1.

func tuple2string<T>(tuple: T) -> String {
    var result = Array<CChar>()
    let mirror = Mirror(reflecting: tuple)
    for child in mirror.children {
        if let value = child.value as? CChar {
            result.append(value)
        }
    }
    result.append(CChar(0))  // Null terminate

    return String.fromCString(result) ?? ""
}

However, this is pretty slow for bigger arrays because it needs to check every character for type, because the compiler has no way of knowing that the passed in tuple is all of the same type.

swift 3:

String(cString: UnsafeRawPointer([myTuple]).assumingMemoryBound(to: CChar.self))

Here is a solution supported by Swift 3 and Swift 4.

func stringFromCString(tupleOfBytes: (CChar, CChar, CChar, CChar, CChar, CChar, CChar, CChar)) -> String {
    var bytes = tupleOfBytes
    let string = withUnsafePointer(to: &bytes) { ptr -> String in
        return String(cString: UnsafeRawPointer(ptr).assumingMemoryBound(to: CChar.self))
    }
    return string
}

Or if you want to use within line as a function with a tuple of bytes try this.

let string = withUnsafePointer(to: &tupleOfBytes) { ptr -> String in
    return String(cString: UnsafeRawPointer(ptr).assumingMemoryBound(to: CChar.self))
}
return string