Swift chuyển đổi giữa uint và Int

Tôi đã các phương pháp sauSwift chuyển đổi giữa uint và 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] 
}

Tuy nhiên đối với người đầu tiên tôi nhận được Int is not convertible to UInt (kể từ self.photos.count là một Int

và cho phần thứ hai UInt is not convertible to Int - kể từ khi self.photos[ chỉ có thể đưa một Int cho chỉ mục của nó

Làm cách nào để chuyển đổi chính xác UInt sang Int và ngược lại?

Nguồn

2014-09-28 Akshat

Nếu đây là những phương pháp riêng của bạn, bạn chỉ nên sử dụng 'Int' thay vì' UInt'. Mặc dù các giá trị không bao giờ là tiêu cực, nhưng đề xuất từ tài liệu Swift về cơ bản luôn luôn sử dụng 'Int' trừ khi bạn có lý do cụ thể để làm khác (ví dụ như khả năng tương tác với các hàm C). –

Đây là từ MWPhotoBrowser (ObjectiveC). Tôi đã sử dụng Bridging Headers để cho tôi sử dụng nó nhưng nó hơi kỳ quặc theo cách này. Tôi không có lựa chọn nào khác ngoài việc sử dụng UInt hoặc fork ngoài MWPhotoBrowser và chỉnh sửa nó (khó khăn hơn để duy trì) – Akshat

Trong trường hợp đầu tiên, kiểu trả về là UInt, nhưng bạn trả về Int vì số lần trả về Int.

Về cơ bản UInt có trình khởi tạo có các biến thể của các đối số loại giá trị như Int, CGFloat, chuỗi kép hoặc chuỗi sự kiện và trả về một loại giá trị mới.

uint (8) // kết quả là 8 UINT kiểu giá trị
uint (20.12) // kết quả là 20 UINT kiểu giá trị
uint (đôi (10))// kết quả là 10 UINT giá trị kiểu
uint ("10") kết quả // là 10 UINT kiểu giá trị, lưu ý đây là failable initializer, có thể là một giá trị hoặc nil

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

    return UInt(self.photos.count) 
}

Đối với một thứ hai, subscript mảng hy vọng giá trị Int nơi bạn đang đi UINT, vì vậy tạo ra một Int kiểu giá trị mới từ UINT,

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

    return self.photos[Int(index)] 
}

Nguồn

2014-09-28 15:42:36 Sandeep

Tuyệt vời !, Tôi đã cố gắng sử dụng 'as' và': UInt' và các công cụ – Akshat

Điều này có thể là OK trong trường hợp này, nhưng bạn phải cẩn thận vì việc chuyển đổi 'Int' thành' UInt' theo cách này sẽ sụp đổ nếu 'Int' là số âm. Sử dụng 'UInt (bitPattern: myint)' an toàn hơn. Và ngược lại, việc chuyển đổi 'UInt' thành' Int' sẽ sụp đổ nếu 'UInt' quá lớn đối với int. Nó là an toàn hơn để sử dụng 'Int (bitPattern: myuint)'. – vacawama

Đó không phải là kiểu truyền, bạn đang tạo một Int/UInt mới. Trong ví dụ này, nó không tạo ra sự khác biệt thực sự nào. – Binarian

// 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

Nguồn

2014-09-28 15:40:20 appdevelopersspotlight

Bạn có thể muốn thêm một số chú thích tối thiểu – Besi

Thêm địa điểm này ở bất kỳ đâu bên ngoài một lớp học:

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

Sau đó, chỉ cần gọi:

self.photos[index].toInt

Nguồn

2015-10-29 19:20:12 Esqarrouth

Nếu bạn muốn int unsigned việc sử dụng giá trị âm uint (bitPattern :)

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

Nguồn

2016-01-15 16:22:09 coldfire

trong nhanh 2.3 bitPattern chỉ hoạt động với Int8 không Int. Bất kì giải pháp nào? –

tôi đã quá thất vọng với phương pháp khó hiểu Swift của thông số bitPattern: và truncatingBitPattern: và không có khả năng của tôi để nhớ cái nào để sử dụng khi nào, mà tôi tạo ra các lớp sau có chứa một số lượng lớn các phương pháp chuyển đổi.

Tôi không nhất thiết khuyên bạn nên đưa điều này vào chương trình của mình. Tôi chắc rằng nhiều người sẽ nói rằng Swift đang cố gắng bảo vệ chúng ta khỏi chính chúng ta và phá hoại nỗ lực đó là câm.Vì vậy, có lẽ bạn nên giữ tập tin này ở đâu đó như một loại cheat sheet để bạn có thể nhanh chóng xác định làm thế nào để thực hiện một chuyển đổi, và sao chép các tham số vào chương trình của bạn khi cần thiết.

Ngẫu nhiên, JDI là viết tắt của "chỉ cần thực hiện".

/// 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 
    } 
}

Dưới đây là một số mã kiểm tra:

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") 
    }

Nguồn

2017-01-30 08:13:24 RenniePet

Swift chuyển đổi giữa uint và Int

Trả lời

Các vấn đề liên quan