斯威夫特UINT和Int

之間的轉換

var photos = [MWPhoto] = [MWPhoto]() 

func numberOfPhotosInPhotoBrowser(photoBrowser: MWPhotoBrowser!) -> UInt { 

    return self.photos.count 
} 

func photoBrowser(photoBrowser: MWPhotoBrowser!, photoAtIndex index: UInt) -> MWPhotoProtocol! { 

    return self.photos[index] 
}

不過，對於第一次我得到Int is not convertible to UInt（因爲self.photos.count是Int

和第二UInt is not convertible to Int - 因爲self.photos[只能拿Int爲其索引

如何正確地將UInt轉換爲Int並返回？

來源

2014-09-28 Akshat

如果這些是你自己的方法，你應該使用'的Int'代替'UInt'。儘管這些值永遠不會是消極的，但Swift文檔中的建議基本上總是使用'Int'，除非您有其他特定的原因（例如與C函數的互操作性）。 – 2014-09-28 16:44:02

這些來自MWPhotoBrowser（ObjectiveC）。我已經使用橋接頭來讓我使用它，但它有點古怪這種方式。我別無選擇，只能使用UInt或撥出MWPhotoBrowser並編輯它（難以維護） – Akshat 2014-09-28 16:52:31

在第一個中，返回類型爲UInt，但由於count返回Int，所以返回Int。

基本上UInt有一個初始值設定項，它使用Int類型，CGFloat類型，Double類型或事件字符串等值類型參數的變體，並返回一個新的值類型。

UINT（8） //結果是8 UINT值類型
UINT（20.12） //結果是20 UINT值類型
UINT（雙（10））//結果是10 UINT值類型
UINT（「10」） //結果是10 UINT值類型，注意這是failable初始化，可以是一個值或零

func numberOfPhotosInPhotoBrowser(photoBrowser: MWPhotoBrowser!) -> UInt { 

    return UInt(self.photos.count) 
}

對於第二個，數組下標希望你在哪裏穿過UINT int值，所以從創建新詮釋值類型UINT，

func photoBrowser(photoBrowser: MWPhotoBrowser!, photoAtIndex index: UInt) -> MWPhotoProtocol! { 

    return self.photos[Int(index)] 
}

來源

2014-09-28 15:42:36 Sandeep

太棒了！我一直試圖使用'as'和'：UInt'和東西 – Akshat 2014-09-28 15:46:01

在這種情況下，這可能是確定的，但是您必須小心，因爲如果「Int」爲負，則以這種方式將「Int」轉換爲「UInt」會崩潰。使用'UInt（bitPattern：myint）'更安全。反之亦然，如果'UInt'對於int而言太大，則將'UInt'轉換爲'Int'將會崩潰。使用'Int（bitPattern：myuint）'更安全。 – vacawama 2014-09-28 15:50:16

這不是一個類型轉換，你正在創建一個新的Int/UInt。在這個例子中，它並沒有真正的區別。 – Binarian 2014-09-28 16:30:18

// initializing Int 
var someInt: Int = 8 
someInt 

// Converting Int to UInt 
var someIntToUInt: UInt = UInt(someInt) 
someIntToUInt 

// initializing UInt 
var someUInt: UInt = 10 
someUInt 

// Converting UInt to Int 
var someUIntToInt: Int = Int(someUInt) 
someUIntToInt

來源

2014-09-28 15:40:20 appdevelopersspotlight

您可能想添加一些最小的註釋 – Besi 2015-07-19 10:26:01

在課堂以外的任何地方添加：

extension UInt { 
    /// SwiftExtensionKit 
    var toInt: Int { return Int(self) } 
}

然後，只需撥打：

self.photos[index].toInt

來源

2015-10-29 19:20:12 Esqarrouth

如果你想從負值使用UINT（一位模式unsigned int類型:)

let intVal = -1 
let uintVal = UInt(bitPattern: intVal) // uintVal == 0xffffffffffffffff

來源

2016-01-15 16:22:09 coldfire

swift 2.3 bitPattern只適用於Int8而不是Int。任何解決方案 – 2017-04-17 06:00:12

我買了雨燕的神祕方法很沮喪參數位模式：和truncatingBitPattern：和我無法記住哪一個使用時，我創建了以下包含大量轉換方法的類。

我不一定建議您在程序中包含此項。我相信很多人會說斯威夫特試圖保護我們免受自己的破壞，而這種努力是愚蠢的。所以也許你應該把這個文件作爲一種備忘單保存在某個地方，這樣你就可以快速確定如何進行轉換，並在需要時將這些參數複製到你的程序中。

順便提一句，JDI代表「只是做」。

/// Class containing a large number of static methods to convert an Int to a UInt or vice-versa, and 
/// also to perform conversions between different bit sizes, for example UInt32 to UInt8. 
/// 
/// Many of these "conversions" are trivial, and are only included for the sake of completeness. 
/// 
/// A few of the conversions involving Int and UInt can give different results when run on 32-bit 
/// and 64-bit systems. All of the conversion where the bit size of both the source and the target 
/// are specified will always give the same result independent of platform. 
public class JDI { 

    // MARK: - To signed Int 

    // To Int8 
    public static func ToInt8(_ x : Int8) -> Int8 { 
     return x 
    } 
    public static func ToInt8(_ x : Int32) -> Int8 { 
     return Int8(truncatingBitPattern: x) 
    } 
    public static func ToInt8(_ x : Int64) -> Int8 { 
     return Int8(truncatingBitPattern: x) 
    } 
    public static func ToInt8(_ x : Int) -> Int8 { 
     return Int8(truncatingBitPattern: x) 
    } 
    public static func ToInt8(_ x : UInt8) -> Int8 { 
     return Int8(bitPattern: x) 
    } 
    public static func ToInt8(_ x : UInt32) -> Int8 { 
     return Int8(truncatingBitPattern: x) 
    } 
    public static func ToInt8(_ x : UInt64) -> Int8 { 
     return Int8(truncatingBitPattern: x) 
    } 
    public static func ToInt8(_ x : UInt) -> Int8 { 
     return Int8(truncatingBitPattern: x) 
    } 

    // To Int32 
    public static func ToInt32(_ x : Int8) -> Int32 { 
     return Int32(x) 
    } 
    public static func ToInt32(_ x : Int32) -> Int32 { 
     return x 
    } 
    public static func ToInt32(_ x : Int64) -> Int32 { 
     return Int32(truncatingBitPattern: x) 
    } 
    public static func ToInt32(_ x : Int) -> Int32 { 
     return Int32(truncatingBitPattern: x) 
    } 
    public static func ToInt32(_ x : UInt8) -> Int32 { 
     return Int32(x) 
    } 
    public static func ToInt32(_ x : UInt32) -> Int32 { 
     return Int32(bitPattern: x) 
    } 
    public static func ToInt32(_ x : UInt64) -> Int32 { 
     return Int32(truncatingBitPattern: x) 
    } 
    public static func ToInt32(_ x : UInt) -> Int32 { 
     return Int32(truncatingBitPattern: x) 
    } 

    // To Int64 
    public static func ToInt64(_ x : Int8) -> Int64 { 
     return Int64(x) 
    } 
    public static func ToInt64(_ x : Int32) -> Int64 { 
     return Int64(x) 
    } 
    public static func ToInt64(_ x : Int64) -> Int64 { 
     return x 
    } 
    public static func ToInt64(_ x : Int) -> Int64 { 
     return Int64(x) 
    } 
    public static func ToInt64(_ x : UInt8) -> Int64 { 
     return Int64(x) 
    } 
    public static func ToInt64(_ x : UInt32) -> Int64 { 
     return Int64(x) 
    } 
    public static func ToInt64(_ x : UInt64) -> Int64 { 
     return Int64(bitPattern: x) 
    } 
    public static func ToInt64(_ x : UInt) -> Int64 { 
     return Int64(bitPattern: UInt64(x)) // Does not extend high bit of 32-bit input 
    } 

    // To Int 
    public static func ToInt(_ x : Int8) -> Int { 
     return Int(x) 
    } 
    public static func ToInt(_ x : Int32) -> Int { 
     return Int(x) 
    } 
    public static func ToInt(_ x : Int64) -> Int { 
     return Int(truncatingBitPattern: x) 
    } 
    public static func ToInt(_ x : Int) -> Int { 
     return x 
    } 
    public static func ToInt(_ x : UInt8) -> Int { 
     return Int(x) 
    } 
    public static func ToInt(_ x : UInt32) -> Int { 
     if MemoryLayout<Int>.size == MemoryLayout<Int32>.size { 
     return Int(Int32(bitPattern: x)) // For 32-bit systems, non-authorized interpretation 
     } 
     return Int(x) 
    } 
    public static func ToInt(_ x : UInt64) -> Int { 
     return Int(truncatingBitPattern: x) 
    } 
    public static func ToInt(_ x : UInt) -> Int { 
     return Int(bitPattern: x) 
    } 

    // MARK: - To unsigned Int 

    // To UInt8 
    public static func ToUInt8(_ x : Int8) -> UInt8 { 
     return UInt8(bitPattern: x) 
    } 
    public static func ToUInt8(_ x : Int32) -> UInt8 { 
     return UInt8(truncatingBitPattern: x) 
    } 
    public static func ToUInt8(_ x : Int64) -> UInt8 { 
     return UInt8(truncatingBitPattern: x) 
    } 
    public static func ToUInt8(_ x : Int) -> UInt8 { 
     return UInt8(truncatingBitPattern: x) 
    } 
    public static func ToUInt8(_ x : UInt8) -> UInt8 { 
     return x 
    } 
    public static func ToUInt8(_ x : UInt32) -> UInt8 { 
     return UInt8(truncatingBitPattern: x) 
    } 
    public static func ToUInt8(_ x : UInt64) -> UInt8 { 
     return UInt8(truncatingBitPattern: x) 
    } 
    public static func ToUInt8(_ x : UInt) -> UInt8 { 
     return UInt8(truncatingBitPattern: x) 
    } 

    // To UInt32 
    public static func ToUInt32(_ x : Int8) -> UInt32 { 
     return UInt32(bitPattern: Int32(x)) // Extend sign bit, assume minus input significant 
    } 
    public static func ToUInt32(_ x : Int32) -> UInt32 { 
     return UInt32(bitPattern: x) 
    } 
    public static func ToUInt32(_ x : Int64) -> UInt32 { 
     return UInt32(truncatingBitPattern: x) 
    } 
    public static func ToUInt32(_ x : Int) -> UInt32 { 
     return UInt32(truncatingBitPattern: x) 
    } 
    public static func ToUInt32(_ x : UInt8) -> UInt32 { 
     return UInt32(x) 
    } 
    public static func ToUInt32(_ x : UInt32) -> UInt32 { 
     return x 
    } 
    public static func ToUInt32(_ x : UInt64) -> UInt32 { 
     return UInt32(truncatingBitPattern: x) 
    } 
    public static func ToUInt32(_ x : UInt) -> UInt32 { 
     return UInt32(truncatingBitPattern: x) 
    } 

    // To UInt64 
    public static func ToUInt64(_ x : Int8) -> UInt64 { 
     return UInt64(bitPattern: Int64(x)) // Extend sign bit, assume minus input significant 
    } 
    public static func ToUInt64(_ x : Int32) -> UInt64 { 
     return UInt64(bitPattern: Int64(x)) // Extend sign bit, assume minus input significant 
    } 
    public static func ToUInt64(_ x : Int64) -> UInt64 { 
     return UInt64(bitPattern: x) 
    } 
    public static func ToUInt64(_ x : Int) -> UInt64 { 
     return UInt64(bitPattern: Int64(x)) // Extend sign bit if necessary, assume minus input significant 
    } 
    public static func ToUInt64(_ x : UInt8) -> UInt64 { 
     return UInt64(x) 
    } 
    public static func ToUInt64(_ x : UInt32) -> UInt64 { 
     return UInt64(x) 
    } 
    public static func ToUInt64(_ x : UInt64) -> UInt64 { 
     return x 
    } 
    public static func ToUInt64(_ x : UInt) -> UInt64 { 
     return UInt64(x) // Does not extend high bit of 32-bit input 
    } 

    // To UInt 
    public static func ToUInt(_ x : Int8) -> UInt { 
     return UInt(bitPattern: Int(x)) // Extend sign bit, assume minus input significant 
    } 
    public static func ToUInt(_ x : Int32) -> UInt { 
     return UInt(truncatingBitPattern: Int64(x)) // Extend sign bit, assume minus input significant 
    } 
    public static func ToUInt(_ x : Int64) -> UInt { 
     return UInt(truncatingBitPattern: x) 
    } 
    public static func ToUInt(_ x : Int) -> UInt { 
     return UInt(bitPattern: x) 
    } 
    public static func ToUInt(_ x : UInt8) -> UInt { 
     return UInt(x) 
    } 
    public static func ToUInt(_ x : UInt32) -> UInt { 
     return UInt(x) 
    } 
    public static func ToUInt(_ x : UInt64) -> UInt { 
     return UInt(truncatingBitPattern: x) 
    } 
    public static func ToUInt(_ x : UInt) -> UInt { 
     return x 
    } 
}

下面是一些測試代碼：

public func doTest() { 

     // To Int8 

     assert(JDI.ToInt8(42 as Int8) == 42) 
     assert(JDI.ToInt8(-13 as Int8) == -13) 

     assert(JDI.ToInt8(42 as Int32) == 42) 
     assert(JDI.ToInt8(257 as Int32) == 1) 

     assert(JDI.ToInt8(42 as Int64) == 42) 
     assert(JDI.ToInt8(257 as Int64) == 1) 

     assert(JDI.ToInt8(42 as Int) == 42) 
     assert(JDI.ToInt8(257 as Int) == 1) 

     assert(JDI.ToInt8(42 as UInt8) == 42) 
     assert(JDI.ToInt8(0xf3 as UInt8) == -13) 

     assert(JDI.ToInt8(42 as UInt32) == 42) 
     assert(JDI.ToInt8(0xfffffff3 as UInt32) == -13) 

     assert(JDI.ToInt8(42 as UInt64) == 42) 
     assert(JDI.ToInt8(UInt64.max - 12) == -13) 

     assert(JDI.ToInt8(42 as UInt) == 42) 
     assert(JDI.ToInt8(UInt.max - 12) == -13) 

     // To Int32 

     assert(JDI.ToInt32(42 as Int8) == 42) 
     assert(JDI.ToInt32(-13 as Int8) == -13) 

     assert(JDI.ToInt32(42 as Int32) == 42) 
     assert(JDI.ToInt32(-13 as Int32) == -13) 

     assert(JDI.ToInt32(42 as Int64) == 42) 
     assert(JDI.ToInt32(Int64(Int32.min) - 1) == Int32.max) 

     assert(JDI.ToInt32(42 as Int) == 42) 
     assert(JDI.ToInt32(-13 as Int) == -13) 

     assert(JDI.ToInt32(42 as UInt8) == 42) 
     assert(JDI.ToInt32(0xf3 as UInt8) == 243) 

     assert(JDI.ToInt32(42 as UInt32) == 42) 
     assert(JDI.ToInt32(0xfffffff3 as UInt32) == -13) 

     assert(JDI.ToInt32(42 as UInt64) == 42) 
     assert(JDI.ToInt32(UInt64.max - 12) == -13) 

     assert(JDI.ToInt32(42 as UInt) == 42) 
     assert(JDI.ToInt32(UInt.max - 12) == -13) 

     // To Int64 

     assert(JDI.ToInt64(42 as Int8) == 42) 
     assert(JDI.ToInt64(-13 as Int8) == -13) 

     assert(JDI.ToInt64(42 as Int32) == 42) 
     assert(JDI.ToInt64(-13 as Int32) == -13) 

     assert(JDI.ToInt64(42 as Int64) == 42) 
     assert(JDI.ToInt64(-13 as Int64) == -13) 

     assert(JDI.ToInt64(42 as Int) == 42) 
     assert(JDI.ToInt64(-13 as Int) == -13) 

     assert(JDI.ToInt64(42 as UInt8) == 42) 
     assert(JDI.ToInt64(0xf3 as UInt8) == 243) 

     assert(JDI.ToInt64(42 as UInt32) == 42) 
     assert(JDI.ToInt64(0xfffffff3 as UInt32) == 4294967283) 

     assert(JDI.ToInt64(42 as UInt64) == 42) 
     assert(JDI.ToInt64(UInt64.max - 12) == -13) 

     assert(JDI.ToInt64(42 as UInt) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToInt64(UInt.max - 12) == 4294967283) // For 32-bit systems 
     #else 
     assert(JDI.ToInt64(UInt.max - 12) == -13) // For 64-bit systems 
     #endif 

     // To Int 

     assert(JDI.ToInt(42 as Int8) == 42) 
     assert(JDI.ToInt(-13 as Int8) == -13) 

     assert(JDI.ToInt(42 as Int32) == 42) 
     assert(JDI.ToInt(-13 as Int32) == -13) 

     assert(JDI.ToInt(42 as Int64) == 42) 
     assert(JDI.ToInt(-13 as Int64) == -13) 

     assert(JDI.ToInt(42 as Int) == 42) 
     assert(JDI.ToInt(-13 as Int) == -13) 

     assert(JDI.ToInt(42 as UInt8) == 42) 
     assert(JDI.ToInt(0xf3 as UInt8) == 243) 

     assert(JDI.ToInt(42 as UInt32) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToInt(0xfffffff3 as UInt32) == -13) // For 32-bit systems 
     #else 
     assert(JDI.ToInt(0xfffffff3 as UInt32) == 4294967283) // For 64-bit systems 
     #endif 

     assert(JDI.ToInt(42 as UInt64) == 42) 
     assert(JDI.ToInt(UInt64.max - 12) == -13) 

     assert(JDI.ToInt(42 as UInt) == 42) 
     assert(JDI.ToInt(UInt.max - 12) == -13) 

     // To UInt8 

     assert(JDI.ToUInt8(42 as Int8) == 42) 
     assert(JDI.ToUInt8(-13 as Int8) == 0xf3) 

     assert(JDI.ToUInt8(42 as Int32) == 42) 
     assert(JDI.ToUInt8(-13 as Int32) == 0xf3) 

     assert(JDI.ToUInt8(42 as Int64) == 42) 
     assert(JDI.ToUInt8(-13 as Int64) == 0xf3) 
     assert(JDI.ToUInt8(Int64.max - 12) == 0xf3) 

     assert(JDI.ToUInt8(42 as Int) == 42) 
     assert(JDI.ToUInt8(-13 as Int) == 0xf3) 
     assert(JDI.ToUInt8(Int.max - 12) == 0xf3) 

     assert(JDI.ToUInt8(42 as UInt8) == 42) 
     assert(JDI.ToUInt8(0xf3 as UInt8) == 0xf3) 

     assert(JDI.ToUInt8(42 as UInt32) == 42) 
     assert(JDI.ToUInt8(0xfffffff3 as UInt32) == 0xf3) 

     assert(JDI.ToUInt8(42 as UInt64) == 42) 
     assert(JDI.ToUInt8(UInt64.max - 12) == 0xf3) 

     assert(JDI.ToUInt8(42 as UInt) == 42) 
     assert(JDI.ToUInt8(UInt.max - 12) == 0xf3) 

     // To UInt32 

     assert(JDI.ToUInt32(42 as Int8) == 42) 
     assert(JDI.ToUInt32(-13 as Int8) == 0xfffffff3) 

     assert(JDI.ToUInt32(42 as Int32) == 42) 
     assert(JDI.ToUInt32(-13 as Int32) == 0xfffffff3) 

     assert(JDI.ToUInt32(42 as Int64) == 42) 
     assert(JDI.ToUInt32(-13 as Int64) == 0xfffffff3) 
     assert(JDI.ToUInt32(Int64.max - 12) == 0xfffffff3) 

     assert(JDI.ToUInt32(42 as Int) == 42) 
     assert(JDI.ToUInt32(-13 as Int) == 0xfffffff3) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt32(Int.max - 12) == 0x7ffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt32(Int.max - 12) == 0xfffffff3) // For 64-bit systems 
     #endif 

     assert(JDI.ToUInt32(42 as UInt8) == 42) 
     assert(JDI.ToUInt32(0xf3 as UInt8) == 0xf3) 

     assert(JDI.ToUInt32(42 as UInt32) == 42) 
     assert(JDI.ToUInt32(0xfffffff3 as UInt32) == 0xfffffff3) 

     assert(JDI.ToUInt32(42 as UInt64) == 42) 
     assert(JDI.ToUInt32(UInt64.max - 12) == 0xfffffff3) 

     assert(JDI.ToUInt32(42 as UInt) == 42) 
     assert(JDI.ToUInt32(UInt.max - 12) == 0xfffffff3) 

     // To UInt64 

     assert(JDI.ToUInt64(42 as Int8) == 42) 
     assert(JDI.ToUInt64(-13 as Int8) == 0xfffffffffffffff3) 

     assert(JDI.ToUInt64(42 as Int32) == 42) 
     assert(JDI.ToUInt64(-13 as Int32) == 0xfffffffffffffff3) 

     assert(JDI.ToUInt64(42 as Int64) == 42) 
     assert(JDI.ToUInt64(-13 as Int64) == 0xfffffffffffffff3) 
     assert(JDI.ToUInt64(Int64.max - 12) == (UInt64.max >> 1) - 12) 

     assert(JDI.ToUInt64(42 as Int) == 42) 
     assert(JDI.ToUInt64(-13 as Int) == 0xfffffffffffffff3) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt64(Int.max - 12) == 0x7ffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt64(Int.max - 12) == 0x7ffffffffffffff3) // For 64-bit systems 
     #endif 

     assert(JDI.ToUInt64(42 as UInt8) == 42) 
     assert(JDI.ToUInt64(0xf3 as UInt8) == 0xf3) 

     assert(JDI.ToUInt64(42 as UInt32) == 42) 
     assert(JDI.ToUInt64(0xfffffff3 as UInt32) == 0xfffffff3) 

     assert(JDI.ToUInt64(42 as UInt64) == 42) 
     assert(JDI.ToUInt64(UInt64.max - 12) == 0xfffffffffffffff3) 

     assert(JDI.ToUInt64(42 as UInt) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt64(UInt.max - 12) == 0xfffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt64(UInt.max - 12) == 0xfffffffffffffff3) // For 64-bit systems 
     #endif 

     // To UInt 

     assert(JDI.ToUInt(42 as Int8) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt(-13 as Int8) == 0xfffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt(-13 as Int8) == 0xfffffffffffffff3) // For 64-bit systems 
     #endif 

     assert(JDI.ToUInt(42 as Int32) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt(-13 as Int32) == 0xfffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt(-13 as Int32) == 0xfffffffffffffff3) // For 64-bit systems 
     #endif 

     assert(JDI.ToUInt(42 as Int64) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt(-13 as Int64) == 0xfffffff3) // For 32-bit systems 
     assert(JDI.ToUInt(Int64.max - 12) == 0xfffffff3) 
     #else 
     assert(JDI.ToUInt(-13 as Int64) == 0xfffffffffffffff3) // For 64-bit systems 
     assert(JDI.ToUInt(Int64.max - 12) == 0x7ffffffffffffff3) 
     #endif 

     assert(JDI.ToUInt(42 as Int) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt(Int.max - 12) == 0x7ffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt(Int.max - 12) == 0x7ffffffffffffff3) // For 64-bit systems 
     #endif 

     assert(JDI.ToUInt(42 as UInt8) == 42) 
     assert(JDI.ToUInt(0xf3 as UInt8) == 0xf3) 

     assert(JDI.ToUInt(42 as UInt32) == 42) 
     assert(JDI.ToUInt(0xfffffff3 as UInt32) == 0xfffffff3) 

     assert(JDI.ToUInt(42 as UInt64) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt(UInt64.max - 12) == 0xfffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt(UInt64.max - 12) == 0xfffffffffffffff3) // For 64-bit systems 
     #endif 

     assert(JDI.ToUInt(42 as UInt) == 42) 
     #if (arch(i386) || arch(arm)) 
     assert(JDI.ToUInt(UInt.max - 12) == 0xfffffff3) // For 32-bit systems 
     #else 
     assert(JDI.ToUInt(UInt.max - 12) == 0xfffffffffffffff3) // For 64-bit systems 
     #endif 

     print("\nTesting JDI complete.\n") 
    }

來源

2017-01-30 08:13:24 RenniePet

斯威夫特UINT和Int

回答

相關問題