Swift 如何将字符串转换为不可配置指针<；UInt8>？斯威夫特3

我试过这个

 return areKeysConsistent(
     certificate as! UnsafeMutablePointer<UInt8>,
     certificate.lengthOfBytes(using: <#T##String.Encoding#>.utf8),
     privateKey as! UnsafeMutablePointer<UInt8>,
     privateKey.lengthOfBytes(using: <#T##String.Encoding#>.utf8),
     password as! UnsafeMutablePointer<UInt8>
 ) 

返回一个一致的(
证书为！Unsafemeutablepointer，
证书长度（使用：.utf8），
privateKey作为！不可女性化指针，
privateKey.lengthOfBytes（使用：.utf8），
密码为！UnsafeMutablePointer
) 

但是艾德说 -“字符串到总是失败

---

转换它的正确方法是什么？谢谢，这就是你不得不使用C语言而遇到一些复杂性的地方

这里主要关注的是传递给该函数的指针的生命周期。下面我的代码使用指向Swift字符串缓冲区的指针。如果

areKeysConsistent

捕获这些指针供以后使用，这将是一个问题。ARC可能释放Swift字符串，使那些存储的指针成为危险的指针指针

func areKeysConsistent(
        _ cert: UnsafeMutablePointer<UInt8>, _ certLength: Int,
        _ key: UnsafeMutablePointer<UInt8>, _ keyLength: Int,
        _ pass: UnsafeMutablePointer<UInt8>, _ passLength: Int
    ) {
    print(cert, key, pass)
}

let certificate = "cert"
let privateKey = "key"
let password = "password"

var certificateCString = certificate.utf8CString
var privateKeyCString = privateKey.utf8CString
var passwordCString = password.utf8CString


certificateCString.withUnsafeMutableBytes { certUMRBP in
privateKeyCString.withUnsafeMutableBytes { pkUMRBP in
passwordCString.withUnsafeMutableBytes { passUMRBP in

    areKeysConsistent(
        certUMRBP.baseAddress!.bindMemory(to: UInt8.self, capacity: certUMRBP.count),
        certUMRBP.count,
        pkUMRBP.baseAddress!.bindMemory(to: UInt8.self, capacity: pkUMRBP.count),
        pkUMRBP.count,
        passUMRBP.baseAddress!.bindMemory(to: UInt8.self, capacity: passUMRBP.count),
        passUMRBP.count
    )
}
}
}

func是一致的(
_cert:Unsafemeutablepointer，certLength:Int，
_key:unsafemeutablepointer，keyLength:Int，
_pass:UnsafeMutablePointer，\ passLength:Int
) {
打印（证书、钥匙、通行证）
}
让certificate=“cert”
让privateKey=“key”
让password=“password”
var certificateCString=certificate.utf8CString
var privateKeyCString=privateKey.utf8CString
var passwordCString=password.utf8CString
certificateCString.WithUnsafemtableBytes{certUMRBP in
privateKeyCString.WithUnsafemtableBytes{pkUMRBP in
passwordCString.WithUnsafemtableBytes{passUMRBP in
钥匙一致吗(
certUMRBP.baseAddress！.bindMemory（收件人：UInt8.self，容量：certUMRBP.count），
certUMRBP.count，
pkUMRBP.baseAddress！.bindMemory（收件人：UInt8.self，容量：pkUMRBP.count），
pkUMRBP.count，
passUMRBP.baseAddress！.bindMemory（收件人：UInt8.self，容量：passUMRBP.count），
passUMRBP.count
)
}
}
}

谢谢@Alexander解决了我的问题这是我的代码：

func areKeysConsistentSwift(_ certificate : String,
                            privateKey : String,
                            password : String) -> Int32 {

    var result: Int32 = 0
    var certificateCString = certificate.utf8CString
    var privateKeyCString = privateKey.utf8CString
    var passwordCString = password.utf8CString


    certificateCString.withUnsafeMutableBytes { certUMRBP in
        privateKeyCString.withUnsafeMutableBytes { pkUMRBP in
            passwordCString.withUnsafeMutableBytes { passUMRBP in

                result = areKeysConsistent(
                    certUMRBP.baseAddress!.bindMemory(to: UInt8.self, capacity: certUMRBP.count),
                    UInt32(certUMRBP.count),
                    pkUMRBP.baseAddress!.bindMemory(to: UInt8.self, capacity: pkUMRBP.count),
                    UInt32(pkUMRBP.count),
                    passUMRBP.baseAddress!.bindMemory(to: Int8.self, capacity: passUMRBP.count)

                )
                print ("-------1--------")
                print (certUMRBP)
                print ("---------------")

                print ("-------2--------")
                print (pkUMRBP)
                print ("---------------")

                print ("-------3--------")
                print (passUMRBP)
                print ("---------------")

            }
        }
    }
    return Int32(result)

}

试试这个（在swift 4中）：

func-stringToUnsafeMutablePointer（消息：String）->UnsafeMutablePointer{
var messageCString=message.utf8CString
返回消息cstring.WithUnsafemtableBytes{mesUMRBP in
返回mesUMRBP.baseAddress！.bindMemory（收件人：Int8.self，容量：mesUMRBP.count）
}
}

问题在于字符串是Int8（CChar）的数组，而不是UIInt8。这里存在类型不匹配。这是由UInt8组成的数据（data，NSData）。这个

areKeyConsistent

函数从何而来？它在您的控制下吗？奇怪的是它期望

UInt8

而不是

CChar

（

Int8

）可能重复的感谢，答案是above@ElizabethHernandez您是否检查了

areKeysConsistent

是否不允许指针逃逸？

func stringToUnsafeMutablePointer(message: String) -> UnsafeMutablePointer<Int8> {
    var messageCString = message.utf8CString
    return messageCString.withUnsafeMutableBytes { mesUMRBP in
        return mesUMRBP.baseAddress!.bindMemory(to: Int8.self, capacity: mesUMRBP.count)
    }

}