La conversion d'un C char tableau à une Chaîne

Le C tableau char name[8] est importé de Swift comme un n-uplet:

(Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8)

L'adresse de name est la même que l'adresse de name[0], et
Swift conserve la disposition de la mémoire de structures importées à partir de C, comme
confirmée par Apple ingénieur Joe Groff:

... Vous pouvez laisser la structure définie en C et l'importer dans Swift. Swift respect C est la mise en page.

En conséquence, nous pouvons nous passer l'adresse de record.name,
converti en UInt8 pointeur, à
la Chaîne de l'initialiseur:

var record = someFunctionReturningAStructRecord()

//Swift 2:
let name = withUnsafePointer(&record.name) {
    String.fromCString(UnsafePointer($0))!
}

//Swift 3:
let name = withUnsafePointer(to: &record.name) {
    $0.withMemoryRebound(to: UInt8.self, capacity: MemoryLayout.size(ofValue: record.name)) {
        String(cString: $0)
    }
}

REMARQUE: Il est supposé que les octets dans name[] sont valides NUL de terminaison UTF-8 séquence.

OriginalL'auteur Martin R

Je suis intéressé à travailler pour mes propres fins, j'ai donc ajouté une nouvelle fonction:

func asciiCArrayToSwiftString(cString:Int8...) -> String
{
    var swiftString = String()            //The Swift String to be Returned is Intialized to an Empty String
    var workingCharacter:UnicodeScalar = UnicodeScalar(UInt8(cString[0]))
    var count:Int = cString.count

    for var i:Int = 0; i < count; i++
    {
        workingCharacter = UnicodeScalar(UInt8(cString[i])) //Convert the Int8 Character to a Unicode Scalar
        swiftString.append(workingCharacter)             //Append the Unicode Scalar

    }

    return swiftString                     //Return the Swift String
}

J'appelle cette fonction avec:

    let t:Int8 = Int8(116)
    let e:Int8 = Int8(101)
    let s:Int8 = Int8(115)
    let testCString = (t, e, s, t)
    let testSwiftString = wispStringConverter.asciiCArrayToSwiftString(testCString.0, testCString.1, testCString.2, testCString.3)
    println("testSwiftString = \(testSwiftString)")

le résultat est:

testSwiftString = test

OriginalL'auteur jwlaughton

Que je viens de vivre une situation semblable, l'utilisation de Swift 3. (3.0.2). J'étais en train d'essayer de convertir un Tableau de CChar, [CChar] pour une Chaîne de Swift. Il s'avère Swift 3 est une Chaîne d'initialiseur qui prendra une cString.

Exemple:

let a = "abc".cString(using: .utf8) //type of a is [CChar]
let b = String(cString: a!, encoding: .utf8) //type of b is String
print("a = \(a)")
print("b = \(b)")

résultats dans

un = en Option([97, 98, 99, 0])

b = en Option("abc")

Noter que le cString fonction de la Chaîne de résultats dans une Option. Il doit être force déballé quand utilisé dans la Chaîne.la fonction init de la création de b. Et b est également en Option... ce qui veut dire à la fois risque d'être nul, de sorte qu'une vérification d'erreur devrait également être utilisés.

OriginalL'auteur Steve Rogers

Voici une solution je suis venu avec qui utilise la réflexion pour en fait de convertir le tuple dans une [Int8] (voir De toute façon pour réitérer un tuple dans swift?), puis le convertit en une chaîne à l'aide de fromCString...() méthodes.

func arrayForTuple<T,E>(tuple:T) -> [E] {
    let reflection = reflect(tuple)
    var arr : [E] = []
    for i in 0..<reflection.count {
        if let value = reflection[i].1.value as? E {
            arr.append(value)
        }
    }
    return arr
}

public extension String {
    public static func fromTuple<T>(tuple:T) -> String? {
        var charArray = arrayForTuple(tuple) as [Int8]
        var nameString = String.fromCString(UnsafePointer<CChar>(charArray))
        if nameString == nil {
            nameString = String.fromCStringRepairingIllFormedUTF8(UnsafePointer<CChar>(charArray)).0
        }
        return nameString
    }
}

OriginalL'auteur joeybladb