我正在制作一个Swift框架来处理大（256位）数字，所以我创建了一个名为UInt256的结构。我尝试使它符合FixedWidthInteger，UnsignedInteger和BinaryInteger，以便可以将其用作常规的Swift整数类型。我的问题是打印它。每当我创建具有特定值的UInt256时，它就可以正常工作。当我尝试打印它时，由于某种原因，它将调用UInt256.init（integerLiteral :)，这似乎将其陷入无限循环，最终导致EXC_BAD_ACCESS错误。
首先，我先回过头来，使它符合所有整数协议，然后它可以正常工作。我想知道为什么没有这个错误我不能成功地符合它。
我已经分析了该线程崩溃时的线程，并且每当它尝试打印该对象时，它将调用值为0的UInt256.init（integerLiteral :)命令。
我注意到的一件有趣的事是错误与数组和数组缓冲区有关。在该init函数中，我尝试创建一个无用的数组，并且它总是在包含数组初始化程序的第一行崩溃。这可能是因为重复循环后，它耗尽了数组缓冲区的空间吗？
我尝试在可疑的init函数中添加打印语句，并尝试打印传递给它的值。果然，该测试将“ 0”打印了100次，然后崩溃了。
这里是将其粘贴到Playground所需的全部代码：
import Foundation
/// Adds a character and a string
///
/// - Parameters:
/// - left: String
/// - right: Character
///
/// - Returns: The string with the appended character
public func +(left: String, right: Character) -> String {
var newString = left
newString.append(right)
return newString
}
/// Adds a character to a given string, and assigns the new string to the original
///
/// - Parameters:
/// - left: inout String
/// - right: Character
///
/// - Returns: The string with the appended character
@discardableResult public func +=(left: inout String, right: Character) -> String {
left = left + right
return left
}
extension String {
// MARK: Subscripts
/// References the ith character of a string
subscript (i: Int) -> Character {
return self[index(startIndex, offsetBy: i)]
}
}
/// The size of the big number
public let BN_SIZE = 4
/// Size of BN in Bytes
public let BN_SIZE_IN_BYTES = MemoryLayout<UInt64>.size * BN_SIZE
/// Size of a BN String
public let BN_STR_SIZE = (2 * BN_SIZE_IN_BYTES + 1)
/// An unsigned 256-bit integer, sometimes denoted as just 'BN', or a BigNumber
public struct UInt256: CustomDebugStringConvertible, FixedWidthInteger, UnsignedInteger {
// MARK: Static properties
/// It's just 0, expressed as a UInt256
public static let zero = BigNumber()
// MARK: Properties
/// The BN as a hex string
public var hexString: String {
var string = ""
let bnSizeCountdown = Array(1...BN_SIZE).reversed()
for i in bnSizeCountdown {
let uint64IndexCountdown = Array(1...16).reversed()
for j in uint64IndexCountdown {
string += toChar(self[i - 1] >> ((j - 1) * 4))
}
}
return string
}
/// The hex representation of the BN, used for debugging
public var debugDescription: String {
return hexString
}
/// The array of UInt64's representing the BN. This is a fixed size of BN_SIZE
public var array: [UInt64]
// MARK: Initializers
public init(integerLiteral value: UInt) {
self.array = [UInt64](repeating: 0, count: BN_SIZE) // THIS is the line that gives me the error: EXC_BAD_ACCESS (code=2, address=0x7ffeef3ffff8)
self[0] = UInt64(value)
}
public init(_truncatingBits bits: UInt) {
self.array = UInt256.from(int: bits).array
}
/// Creates a BN from an array of UInt64's
///
/// - Parameters:
/// - array: An array of UInt64's
///
/// - Returns: Nil if the array size is incorrect, but otherwise returns the corresponding BN
public init?(array: [UInt64]) {
if array.count != BN_SIZE { return nil }
self.array = array
}
/// Creates a BN from a hex string
///
/// - Parameters:
/// - hex: A hex string to be converted to BN
///
/// - Returns: Returns nil if hex string is invalid
public init?(hexString hex: String) {
self.array = [UInt64](repeating: 0, count: BN_SIZE)
for i in 0..<hex.count {
if toNibble(hex[i]) == 16 { return nil }
let reversedSequence = (1..<BN_SIZE).reversed()
for j in reversedSequence {
self[j] <<= 4
self[j] |= (self[j - 1] >> 60) & 0x0f
}
self[0] <<= 4
self[0] |= UInt64(toNibble(hex[i]) & 0x0f)
}
}
/// Creates a BN of value 0
public init() {
self.array = [UInt64](repeating: 0, count: BN_SIZE)
}
// MARK: Static Functions
/// Converts an Integer to a BigNumber
///
/// - Parameters:
/// - int: An UnsignedInteger to convert to a BigNumber
///
/// - Returns: A BigNumber
public static func from<T: UnsignedInteger>(int: T) -> BigNumber {
var bn = BigNumber()
bn[0] = UInt64(int)
return bn
}
// MARK: Enumerations
// MARK: Subscripts
/// Gets or sets a value for the given index in the BN array representation
public subscript(i: Int) -> UInt64 {
get {
return array[i]
} set(newValue) {
array[i] = newValue
}
}
// MARK: Conformance Requirements
public static var bitWidth: Int {
return BN_SIZE_IN_BYTES * 8
}
public typealias Words = UInt64.Words
public typealias IntegerLiteralType = UInt
public func addingReportingOverflow(_ rhs: UInt256) -> (partialValue: UInt256, overflow: Bool) {
return (self + rhs, (self > (self + rhs) ? false : true))
}
public func subtractingReportingOverflow(_ rhs: UInt256) -> (partialValue: UInt256, overflow: Bool) {
return (self + rhs, (self < (self - rhs) ? false : true))
}
public func multipliedReportingOverflow(by rhs: UInt256) -> (partialValue: UInt256, overflow: Bool) {
return (self * rhs, (self > (self * rhs) ? false : true))
}
public func dividedReportingOverflow(by rhs: UInt256) -> (partialValue: UInt256, overflow: Bool) {
// don't trust this, I don't even know what this does
return (self / rhs, (self > (self / rhs) ? false : true))
}
public func remainderReportingOverflow(dividingBy rhs: UInt256) -> (partialValue: UInt256, overflow: Bool) {
// I don't know how this would result in an overflow, but whatever
return (self % rhs, false)
}
public func multipliedFullWidth(by other: UInt256) -> (high: UInt256, low: UInt256) {
// what does this even mean? Seriously, if someone else would like to write this part, that'd be great
return (self, self)
}
public func dividingFullWidth(_ dividend: (high: UInt256, low: UInt256)) -> (quotient: UInt256, remainder: UInt256) {
// what does this even mean? Seriously, if someone else would like to write this part, that'd be great
return (self, self)
}
public var nonzeroBitCount: Int {
var nonzeros: Int = 0
for i in 0..<BN_SIZE {
nonzeros += self[i].nonzeroBitCount
}
return nonzeros
}
public var leadingZeroBitCount: Int {
var leadingZeros: Int = self[3].leadingZeroBitCount
for i in (0..<(BN_SIZE-1)).reversed() {
if self[i+1].nonzeroBitCount > 0 {
break
}
leadingZeros += self[i].leadingZeroBitCount
}
return leadingZeros
}
public var byteSwapped: UInt256 {
let reversedArray = self.array.reversed()
return UInt256(array: reversedArray.map { $0.byteSwapped })!
}
public var words: UInt64.Words {
// I have no idea what this variable is supposed to be.
// someone else please do this
return UInt64.Words(8)
}
public var trailingZeroBitCount: Int {
// I couldn't be bothered to write this right now.
// I'm in the car after a long day and I am tired
// I just want this project to build so I can say I had a good day and go to sleep
return 0
}
// MARK: Private Methods
/// Converts an ascii hex character to a nibble
func toNibble(_ char: Character) -> UInt8 {
let n = UInt64(char.asciiValue!)
return ((n >= 0x30) && (n <= 0x39)) ? UInt8(n - 0x30):
((n >= 0x41) && (n <= 0x46)) ? UInt8(n - 0x37):
((n >= 0x61) && (n <= 0x66)) ? UInt8(n - 0x57):
0x10
}
/// Converts a nibble to a hex character
func toChar(_ nibble: UInt64) -> Character {
var c: Character
let n = 0x0f&nibble
if 0 <= n && n < 10 {
c = String(n)[0]
} else {
switch n {
case 10:
c = "A"
case 11:
c = "B"
case 12:
c = "C"
case 13:
c = "D"
case 14:
c = "E"
case 15:
c = "F"
case 255:
c = "F"
case 16:
c = "0"
default:
c = "X"
}
}
return c
}
// MARK: Comparisons
/// Checks if two BNs are equal
///
/// - Parameters:
/// - a: A BN
/// - b: Another BN
///
/// - Returns: True if they are equal, false if not
public static func == (a: BN, b: BN) -> Bool {
for i in 0..<BN_SIZE {
if a[i] != b[i] {
return false
}
}
return true
}
/// Checks if two BNs are unequal
///
/// - Parameters:
/// - a: A BN
/// - b: Another BN
///
/// - Returns: True if they are unequal, false if not
public static func != (a: BN, b: BN) -> Bool {
return !(a == b)
}
/// Checks if a BN is smaller than another BN
///
/// - Parameters:
/// - a: The number that is checked to be smaller
/// - b: The number that is checked to be larger
///
/// - Returns: True if a < b, false if otherwise
public static func < (a: BN, b: BN) -> Bool {
if a == b { return false }
for i in 0..<BN_SIZE {
if a[3-i] > b[3-i] { return false }
}
return true
}
/// Checks if a BN is larger than another BN
///
/// - Parameters:
/// - a: The number that is checked to be larger
/// - b: The number that is checked to be smaller
///
/// - Returns: True if a < b, false if otherwise
public static func > (a: BN, b: BN) -> Bool {
if a == b { return false }
for i in 0..<BN_SIZE {
if a[3-i] < b[3-i] { return false }
}
return true
}
/// Greater than OR equal to
///
/// - Parameters:
/// - a: A BN
/// - b: Another BN
///
/// - Returns: TRUE if a >= b, false if otherwise
public static func >= (a: BN, b: BN) -> Bool {
return a == b || a > b
}
/// Less than OR equal to
///
/// - Parameters:
/// - a: A BN
/// - b: Another BN
///
/// - Returns: TRUE if a <= b, false if otherwise
public static func <= (a: BN, b: BN) -> Bool {
return a == b || a < b
}
// MARK: Arithemetic
/// Adds two BigNumbers
///
/// - Parameters:
/// - a: Left BN
/// - b: Right BN
///
/// - Returns: Sum of left BN and right BN
public static func + (a: BigNumber, b: BigNumber) -> BigNumber {
var r = BigNumber()
var carry_out: UInt64 = 0
var carry_in: UInt64 = 0
for i in 0..<BN_SIZE {
r[i] = a[i] &+ b[i]
if (r[i] < a[i]) {
carry_out = 1
}
if (carry_in != 0) {
r[i] &+= 1
if ( 0 == r[i]) {
carry_out = 1
}
}
carry_in = carry_out
carry_out = 0
}
return r
}
/// Subtracts BigNumber b from BigNumber a
///
/// If the subtraction will result in a negative number, there will be an overflow error
///
/// This uses Two's Complement subtraction
///
/// - Parameters:
/// - a: Left BigNumber
/// - b: Right BigNumber
///
/// - Returns: Difference of parameters
public static func - (a: BigNumber, b: BigNumber) -> BigNumber {
// First, calculate two's complement of B
var b_t = b
for i in 0..<b_t.array.count {
b_t.array[i] = ~b_t.array[i]
}
b_t = b_t + UInt256.from(int: UInt(1))
return a + b_t
}
/// Multiplies two BNs
///
/// - Parameters:
/// - a: A BN Factor
/// - b: Another BN Factor
///
/// - Returns: The product
public static func * (a: BigNumber, b: BigNumber) -> BigNumber {
var p = BN()
let multiplier = a < b ? a : b
let adder = a >= b ? a : b
var index = multiplier
let zero = BN()
while index != zero {
p = p + adder
index = index - UInt256.from(int: UInt(1))
}
return p
}
/// Divides BN a by BN b, and returns the quotient
///
/// - Parameters:
/// - a: Dividend
/// - b: Divisor
///
/// - Returns: The quotient
public static func / (a: BN, b: BN) -> BN {
if b == BN.zero { fatalError("Dude you can't divide by zero in OUR universe") }
var q = BN.zero
var dividend = a
while (dividend >= b) {
q = q + UInt256.from(int: UInt(1))
dividend = dividend - b
}
return q
}
/// Modulo operator
///
/// - Parameters:
/// - a: Dividend
/// - b: Divisor
///
/// - Returns: The remainder as a BN after division
public static func % (a: BN, b: BN) -> BN {
if b == BN.zero { fatalError("Dividing by zero is not possible, sorry!") }
var dividend = a
while (dividend >= b) {
dividend = dividend - b
}
return dividend
}
// MARK: Bitwise operators
/// Bitwise AND operator
///
/// - Parameters:
/// - a: A UInt256
/// - b: Another UInt256
///
/// - Returns: The bitwise AND of the two values
public static func & (a: UInt256, b: UInt256) -> UInt256 {
var ANDarray: [UInt64] = a.array
for i in 0..<ANDarray.count {
ANDarray[i] &= b[i]
}
return UInt256(array: ANDarray)!
}
/// Bitwise OR operator
///
/// - Parameters:
/// - a: A UInt256
/// - b: Another UInt256
///
/// - Returns: The bitwise OR of the two values
public static func | (a: UInt256, b: UInt256) -> UInt256 {
var ANDarray: [UInt64] = a.array
for i in 0..<ANDarray.count {
ANDarray[i] |= b[i]
}
return UInt256(array: ANDarray)!
}
/// Bitwise XOR operator
///
/// - Parameters:
/// - a: A UInt256
/// - b: Another UInt256
///
/// - Returns: The bitwise XOR of the two values
public static func ^ (a: UInt256, b: UInt256) -> UInt256 {
var ANDarray: [UInt64] = a.array
for i in 0..<ANDarray.count {
ANDarray[i] ^= b[i]
}
return UInt256(array: ANDarray)!
}
// MARK: Assignment operators
public static func *= (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs * rhs
}
public static func += (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs + rhs
}
public static func -= (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs - rhs
}
public static func /= (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs / rhs
}
public static func %= (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs % rhs
}
public static func &= (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs & rhs
}
public static func |= (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs | rhs
}
public static func ^= (lhs: inout UInt256, rhs: UInt256) {
lhs = lhs ^ rhs
}
public func hash(into hasher: inout Hasher) {
for uint64 in array {
hasher.combine(uint64)
}
}
}
/// For convenience, a UInt256 can be known as a BN
public typealias BN = UInt256
/// For convenience, a UInt256 can be known as a BigNumber
public typealias BigNumber = UInt256
这是测试代码：
let a: UInt256 = 42
print(a)
您要查看的其他任何代码都可以在the GitHub page
中找到测试的预期结果应为“ 2A”（十六进制为42），后跟一串0。相反，它只是崩溃了。
这个错误一直让我头疼，因为我完全不知道从哪里开始。任何帮助将不胜感激。
答案 0 :(得分：0)
将print(a)更改为debugPrint(a)。您有debugDescription的连贯实现，因此调用debugPrint可以正常工作。