无论如何,是否可以[NSString stringWithFormat:@"%p", myVar]
使用新的Swift语言从Objective-C 模拟?
例如:
let str = "A String"
println(" str value \(str) has address: ?")
无论如何,是否可以[NSString stringWithFormat:@"%p", myVar]
使用新的Swift语言从Objective-C 模拟?
例如:
let str = "A String"
println(" str value \(str) has address: ?")
Answers:
现在,它已成为标准库的一部分:unsafeAddressOf
。
/// Return an UnsafePointer to the storage used for `object`. There's
/// not much you can do with this other than use it to identify the
/// object
对于Swift 3,请使用withUnsafePointer
:
var str = "A String"
withUnsafePointer(to: &str) {
print(" str value \(str) has address: \($0)")
}
withUnsafePointer
导致cannot pass immutable value as inout argument
错误。
print(self.description)
prints <MyViewController: 0x101c1d580>
,我们将其用作参考。var mutableSelf = self; withUnsafePointer(to: &mutableSelf) { print(String(format: "%p", $0)) }
打印0x16fde4028
明显不同的地址。有人可以解释为什么吗?
0x101c1d580
按预期打印:print(String(format: "%p", unsafeBitCast(self, to: Int.self)))
UnsafePointer
是一个结构,因此要打印它指向的地址(而不是结构本身),必须打印String(format: "%p", $0.pointee)
!
注意:这是参考类型。
print(Unmanaged.passUnretained(someVar).toOpaque())
打印someVar的内存地址。(感谢@Ying)
print(Unmanaged<AnyObject>.passUnretained(someVar as AnyObject).toOpaque())
打印someVar的内存地址。
print(Unmanaged<AnyObject>.passUnretained(someVar as AnyObject).toOpaque())
Unmanaged
它可以做到这样的:print(Unmanaged<AnyObject>.fromOpaque(&myStruct).toOpaque())
。
Unmanaged.passUnretained(someVar).toOpaque()
(无需通用规格)
debugDescription
在其末尾添加。
请注意,这个答案很旧。它描述的许多方法不再起作用。特别.core
是无法再访问。
但是@drew的答案是正确和简单的:
现在,它已成为标准库的一部分:unsafeAddressOf。
因此,您的问题的答案是:
println(" str value \(str) has address: \(unsafeAddressOf(str))")
这是被标记为正确的原始答案(出于后代/礼貌):
Swift会“隐藏”指针,但它们仍然存在。(因为运行时需要它,并且出于与Objc和C的兼容性原因)
但是,有几件事要了解,但是首先如何打印Swift String的内存地址?
var aString : String = "THIS IS A STRING"
NSLog("%p", aString.core._baseAddress) // _baseAddress is a COpaquePointer
// example printed address 0x100006db0
这将打印字符串的内存地址,如果打开XCode-> Debug Workflow-> View Memory并转到打印的地址,您将看到字符串的原始数据。由于这是字符串文字,因此它是二进制存储区(不是堆栈或堆)内部的内存地址。
但是,如果您这样做
var aString : String = "THIS IS A STRING" + "This is another String"
NSLog("%p", aString.core._baseAddress)
// example printed address 0x103f30020
这将在堆栈上,因为字符串是在运行时创建的
注意:.core._baseAddress没有记录,我在变量检查器中找到了它,以后可能会隐藏它
_baseAddress并非在所有类型上都可用,这里是带有CInt的另一个示例
var testNumber : CInt = 289
takesInt(&testNumber)
这样takesInt
的C辅助函数在哪里
void takesInt(int *intptr)
{
printf("%p", intptr);
}
在Swift方面,此功能是 takesInt(intptr: CMutablePointer<CInt>)
,因此它将CMutablePointer带到CInt,您可以使用&varname来获取它
该函数打印0x7fff5fbfed98
,并且在该内存地址上您将找到289(以十六进制表示)。您可以使用更改内容*intptr = 123456
现在,还有其他一些事情要知道。
迅速地,字符串是原始类型,而不是对象。
CInt是映射到C int类型的Swift类型。
如果要对象的内存地址,则必须做一些不同的事情。
Swift有一些与C交互时可以使用的Pointer Type
,您可以在这里阅读它们:Swift Pointer Types此外,您可以了解更多关于它们探索其声明的信息(cmd +单击该类型),以了解如何进行转换。一种指向另一种的指针
var aString : NSString = "This is a string" // create an NSString
var anUnmanaged = Unmanaged<NSString>.passUnretained(aString) // take an unmanaged pointer
var opaque : COpaquePointer = anUnmanaged.toOpaque() // convert it to a COpaquePointer
var mut : CMutablePointer = &opaque // this is a CMutablePointer<COpaquePointer>
printptr(mut) // pass the pointer to an helper function written in C
printptr
是我通过此实现创建的C帮助程序函数
void printptr(void ** ptr)
{
printf("%p", *ptr);
}
再次,显示一个打印地址的示例:0x6000000530b0
,如果您通过内存检查器,则会找到您的NSString
您可以在Swift中使用指针做一件事(甚至可以使用inout参数来完成)
func playWithPointer (stringa :AutoreleasingUnsafePointer<NSString>)
{
stringa.memory = "String Updated";
}
var testString : NSString = "test string"
println(testString)
playWithPointer(&testString)
println(testString)
或者,与Objc / c进行交互
// objc side
+ (void)writeString:(void **)var
{
NSMutableString *aString = [[NSMutableString alloc] initWithFormat:@"pippo %@", @"pluto"];
*var = (void *)CFBridgingRetain(aString); // Retain!
}
// swift side
var opaque = COpaquePointer.null() // create a new opaque pointer pointing to null
TestClass.writeString(&opaque)
var string = Unmanaged<NSString>.fromOpaque(opaque).takeRetainedValue()
println(string)
// this prints pippo pluto
func address<T: AnyObject>(o: T) -> Int {
return unsafeBitCast(o, Int.self)
}
class Test {}
var o = Test()
println(NSString(format: "%p", address(o))) // -> 0x7fd5c8700970
(编辑: Swift 1.2现在包括一个名为的类似功能unsafeAddressOf
。)
在Objective-C中,这将是[NSString stringWithFormat:@"%p", o]
。
o
是对该实例的引用。因此,如果o
将其分配给另一个变量o2
,则返回的地址o2
将相同。
这不适用于结构体(包括String
)和基本类型(如Int
),因为它们直接存在于堆栈中。但是我们可以检索堆栈上的位置。
func address(o: UnsafePointer<Void>) -> Int {
return unsafeBitCast(o, Int.self)
}
println(NSString(format: "%p", address(&o))) // -> 0x10de02ce0
var s = "A String"
println(NSString(format: "%p", address(&s))) // -> 0x10de02ce8
var i = 55
println(NSString(format: "%p", address(&i))) // -> 0x10de02d00
在Objective-C中,该值为[NSString stringWithFormat:@"%p", &o]
或[NSString stringWithFormat:@"%p", &i]
。
s
是结构。因此,如果s
将其分配给另一个变量s2
,则将复制该值,并且的返回地址s2
将不同。
像在Objective-C中一样,有两个不同的地址与关联o
。第一个是对象的位置,第二个是对象的引用(或指针)的位置。
是的,这意味着地址0x7fff5fbfe658的内容是数字0x6100000011d0,调试器可以告诉我们:
(lldb) x/g 0x7fff5fbfe658
0x7fff5fbfe658: 0x00006100000011d0
因此,除了字符串是结构以外,在内部所有这些工作都与(Objective-)C中的工作相同。
(最新版本为Xcode 6.3)
TL; DR
struct MemoryAddress<T>: CustomStringConvertible {
let intValue: Int
var description: String {
let length = 2 + 2 * MemoryLayout<UnsafeRawPointer>.size
return String(format: "%0\(length)p", intValue)
}
// for structures
init(of structPointer: UnsafePointer<T>) {
intValue = Int(bitPattern: structPointer)
}
}
extension MemoryAddress where T: AnyObject {
// for classes
init(of classInstance: T) {
intValue = unsafeBitCast(classInstance, to: Int.self)
// or Int(bitPattern: Unmanaged<T>.passUnretained(classInstance).toOpaque())
}
}
/* Testing */
class MyClass { let foo = 42 }
var classInstance = MyClass()
let classInstanceAddress = MemoryAddress(of: classInstance) // and not &classInstance
print(String(format: "%018p", classInstanceAddress.intValue))
print(classInstanceAddress)
struct MyStruct { let foo = 1 } // using empty struct gives weird results (see comments)
var structInstance = MyStruct()
let structInstanceAddress = MemoryAddress(of: &structInstance)
print(String(format: "%018p", structInstanceAddress.intValue))
print(structInstanceAddress)
/* output
0x0000000101009b40
0x0000000101009b40
0x00000001005e3000
0x00000001005e3000
*/
(要点)
在Swift中,我们处理值类型(结构)或引用类型(类)。进行时:
let n = 42 // Int is a structure, i.e. value type
在地址X处分配了一些内存,在该地址处我们将找到值42。这样做&n
会创建一个指向地址X的指针,从而&n
告诉我们n
位置。
(lldb) frame variable -L n
0x00000001005e2e08: (Int) n = 42
(lldb) memory read -c 8 0x00000001005e2e08
0x1005e2e08: 2a 00 00 00 00 00 00 00 // 0x2a is 42
进行时:
class C { var foo = 42, bar = 84 }
var c = C()
内存分配在两个位置:
如前所述,类是引用类型:所以的值c
位于地址X处,我们将在其中找到Y的值。在地址Y + 16处我们将找到foo
,在地址Y + 24处我们将找到bar
(在+ 0和+ 8处,我们将找到类型数据和引用计数,对此我不能告诉您太多...)。
(lldb) frame variable c // gives us address Y
(testmem.C) c = 0x0000000101a08f90 (foo = 42, bar = 84)
(lldb) memory read 0x0000000101a08f90 // reading memory at address Y
0x101a08f90: e0 65 5b 00 01 00 00 00 02 00 00 00 00 00 00 00
0x101a08fa0: 2a 00 00 00 00 00 00 00 54 00 00 00 00 00 00 00
0x2a
是42(foo)和0x54
84(bar)。
在这两种情况下,使用&n
或&c
都会给我们提供地址X。对于值类型,这就是我们想要的,但不是引用类型。
进行时:
let referencePointer = UnsafeMutablePointer<C>(&c)
我们在引用上创建一个指针,即指向地址X的指针。使用时也是如此withUnsafePointer(&c) {}
。
(lldb) frame variable referencePointer
(UnsafeMutablePointer<testmem.C>) referencePointer = 0x00000001005e2e00 // address X
(lldb) memory read -c 8 0x00000001005e2e00 // read memory at address X
0x1005e2e00: 20 ec 92 01 01 00 00 00 // contains address Y, consistent with result below:
(lldb) frame variable c
(testmem.C) c = 0x000000010192ec20 (foo = 42, bar = 84)
现在我们对幕后情况有了更好的了解,并且现在我们在地址X上找到了地址Y(这是我们想要的地址),我们可以执行以下操作来获取地址:
let addressY = unsafeBitCast(c, to: Int.self)
验证中:
(lldb) frame variable addressY -f hex
(Int) addressY = 0x0000000101b2fd20
(lldb) frame variable c
(testmem.C) c = 0x0000000101b2fd20 (foo = 42, bar = 84)
还有其他方法可以做到这一点:
let addressY1 = Int(bitPattern: Unmanaged.passUnretained(c).toOpaque())
let addressY2 = withUnsafeMutableBytes(of: &c) { $0.load(as: Int.self) }
toOpaque()
实际打电话unsafeBitCast(c, to: UnsafeMutableRawPointer.self)
。
我希望这对我有帮助...。
MemoryLocation
会产生2个不同的地址。
===
身份运算符用于检查2个对象指向相同的引用。ObjectIdentifier
得到的内存地址class C {}
let c1 = C()
let c2 = c1
//Option 1:
print("c1 address: \(Unmanaged.passUnretained(c1).toOpaque())")
//Option 2:
let o1 = ObjectIdentifier(c1)
let o2 = ObjectIdentifier(c2)
print("o1 -> c1 = \(o1)")
print("o2 -> c2 = \(o2)")
if o1 == o2 {
print("c1 = c2")
} else {
print("c1 != c2")
}
//Output:
//c1 address: 0x000060c000005b10
//o1 -> c1 = ObjectIdentifier(0x000060c000005b10)
//o2 -> c2 = ObjectIdentifier(0x000060c000005b10)
//c1 = c2
只需使用此:
print(String(format: "%p", object))
MyClass?
”不符合CVarArg 的编译器投诉,则可以这样做extension Optional : CVarArg { }
。否则,这似乎在打印地址时不会出现其他答案的所有“不安全”错误。
var _cVarArgEncoding: [Int]
on的实现CVarArg
。尚不清楚应如何实施。
如果您只想在调试器中看到它,而不对其进行任何其他操作,则无需实际获取Int
指针。要获取内存中对象地址的字符串表示形式,只需使用如下代码:
public extension NSObject { // Extension syntax is cleaner for my use. If your needs stem outside NSObject, you may change the extension's target or place the logic in a global function
public var pointerString: String {
return String(format: "%p", self)
}
}
用法示例:
print(self.pointerString, "Doing something...")
// Prints like: 0x7fd190d0f270 Doing something...
另外,请记住,您可以简单地打印一个对象而不覆盖它的对象description
,它会在更具描述性(如果经常是隐秘的)文本的旁边显示其指针地址。
print(self, "Doing something else...")
// Prints like: <MyModule.MyClass: 0x7fd190d0f270> Doing something else...
// Sometimes like: <_TtCC14__lldb_expr_668MyModule7MyClass: 0x7fd190d0f270> Doing something else...
extension String {
static func pointer(_ object: AnyObject?) -> String {
guard let object = object else { return "nil" }
let opaque: UnsafeMutableRawPointer = Unmanaged.passUnretained(object).toOpaque()
return String(describing: opaque)
}
}
print("FileManager.default: \(String.pointer(FileManager.default))")
// FileManager.default: 0x00007fff5c287698
print("nil: \(String.pointer(nil))")
// nil: nil
Unmanaged.passUnretained(myObject).toOpaque()
而是可以正常工作。
AnyObject
参数。我希望将其Any
作为输入类型。
let array1 = [1,2,3]
let array2 = array1
array1.withUnsafeBufferPointer { (point) in
print(point) // UnsafeBufferPointer(start: 0x00006000004681e0, count: 3)
}
array2.withUnsafeBufferPointer { (point) in
print(point) // UnsafeBufferPointer(start: 0x00006000004681e0, count: 3)
}
self?.array
。
@Drew提供的答案只能用于类类型。
@nschum提供的答案只能用于结构类型。
但是,如果您使用第二种方法来获取具有值类型元素的数组的地址。Swift将复制整个数组,因为在Swift数组中,它是写时复制的,并且一旦将控制权交给C / C ++(通过使用&
获取地址来触发),Swift就无法确保它具有这种行为。而且,如果您改用first方法,它将自动转换Array
为NSArray
我们不想要的东西。
因此,我找到的最简单统一的方法是使用lldb指令frame variable -L yourVariableName
。
或者,您可以结合他们的答案:
func address(o: UnsafePointer<Void>) {
let addr = unsafeBitCast(o, Int.self)
print(NSString(format: "%p", addr))
}
func address<T: AnyObject>(o: T) -> String{
let addr = unsafeBitCast(o, Int.self)
return NSString(format: "%p", addr) as String
}
这是Swift 3的。
像@CharlieMonroe一样,我想以整数形式获取地址。具体来说,在没有线程名称可用的情况下,我希望在诊断日志记录模块中将Thread对象的地址用作线程ID。
根据Charlie Monroe的代码,这是我到目前为止提出的内容。但是请注意,我是Swift的新手,这可能不正确...
// Convert the memory address of the current Thread object into an Int for use as a thread ID
let objPtr = Unmanaged.passUnretained(Thread.current).toOpaque()
let onePtr = UnsafeMutableRawPointer(bitPattern: 1)! // 1 used instead of 0 to avoid crash
let rawAddress : Int64 = onePtr.distance(to: objPtr) + 1 // This may include some high-order bits
let address = rawAddress % (256 * 1024 * 1024 * 1024) // Remove high-order bits
最后一条语句是存在的,因为没有它,我将获得0x60000007DB3F之类的地址。最后一条语句中的模运算将其转换为0x7DB3F。
我在Swift 3上的解决方案
extension MyClass: CustomStringConvertible {
var description: String {
return "<\(type(of: self)): 0x\(String(unsafeBitCast(self, to: Int.self), radix: 16, uppercase: false))>"
}
}
此代码创建类似默认描述的描述
<MyClass: 0x610000223340>
当然,这不是最快或最安全的方法。但这对我有用。这将允许任何nsobject子类采用此属性。
public extension NSObject {
public var memoryAddress : String? {
let str = "\(self.self)".components(separatedBy: ": ")
guard str.count > 1 else { return nil }
return str[1].replacingOccurrences(of: ">", with: "")
}
}
//usage
let foo : String! = "hello"
Swift.print(foo.memoryAddress) // prints 0x100f12980
[NSString stringWithFormat:@"%p", myVar]
,myVar
必须是一个指针。在您的Swift代码中,str
不是指针。因此,该比较不适用。