Rychlý tisk adresy proměnné paměti

original title: "Printing a variable memory address in swift"


Translate

Is there anyway to simulate the [NSString stringWithFormat:@"%p", myVar] code in the new swift language ?

For example:

let str = "A String"
println(" str value \(str) has address: ?")


Existuje přesto simulace kódu [NSString stringWithFormat: @ "% p", myVar] v novém rychlém jazyce? Například: let str = "A String" println ("str value \ (str) má adresu:?")

Toto je shrnutí po překladu. Pokud potřebujete zobrazit celý překlad, klikněte na ikonu „přeložit“


Všechny odpovědi
  • Translate

    Swift 2

    This is now part of the standard library: 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

    For Swift 3, use withUnsafePointer:

    var str = "A String"
    withUnsafePointer(to: &str) {
        print(" str value \(str) has address: \($0)")
    }
    

  • Translate

    Swift 4/5:

    print(Unmanaged.passUnretained(someVar).toOpaque())
    

    Prints the memory address of someVar. (thanks to @Ying)


    Swift 3.1:

    print(Unmanaged<AnyObject>.passUnretained(someVar as AnyObject).toOpaque())
    

    Prints the memory address of someVar.



  • Translate

    Note that this answer was quite old. Many of the methods it describes no longer work. Specifically .core cannot be accessed anymore.

    However @drew's answer is correct and simple:

    This is now part of the standard library: unsafeAddressOf.

    So the answer to your questions is:

    println(" str value \(str) has address: \(unsafeAddressOf(str))")
    

    Here is the original answer that was marked correct (for posterity/politeness):

    Swift "hides" pointers, but they still exists under the hood. (because the runtime needs it, and for compatibility reasons with Objc and C)

    There are few things to know however, but first how to print the memory address of a Swift String?

        var aString : String = "THIS IS A STRING"
        NSLog("%p", aString.core._baseAddress)  // _baseAddress is a COpaquePointer
       // example printed address 0x100006db0
    

    This prints the memory address of the string, if you open XCode -> Debug Workflow -> View Memory and go to the printed address, you will see the raw data of the string. Since this is a string literal, this is a memory address inside the storage of the binary (not stack or heap).

    However, if you do

        var aString : String = "THIS IS A STRING" + "This is another String"
        NSLog("%p", aString.core._baseAddress)
    
        // example printed address 0x103f30020
    

    This will be on the stack, because the string is created at runtime

    NOTE: .core._baseAddress is not documented, I found it looking in the variable inspector, and it may be hidden in the future

    _baseAddress is not available on all types, here another example with a CInt

        var testNumber : CInt = 289
        takesInt(&testNumber)
    

    Where takesInt is a C helper function like this

    void takesInt(int *intptr)
    {
        printf("%p", intptr);
    }
    

    On the Swift side, this function is takesInt(intptr: CMutablePointer<CInt>), so it takes a CMutablePointer to a CInt, and you can obtain it with &varname

    The function prints 0x7fff5fbfed98, an at this memory address you will find 289 (in hexadecimal notation). You can change its content with *intptr = 123456

    Now, some other things to know.

    String, in swift, is a primitive type, not an object.
    CInt is a Swift type mapped to the C int Type.
    If you want the memory address of an object, you have to do something different.
    Swift has some Pointer Types that can be used when interacting with C, and you can read about them here: Swift Pointer Types
    Moreover, you can understand more about them exploring their declaration (cmd+click on the type), to understand how to convert a type of pointer into another

        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 is a C helper function I created, with this implementation

    void printptr(void ** ptr)
    {
        printf("%p", *ptr);
    }
    

    Again, an example of the address printed: 0x6000000530b0 , and if you go through memory inspector you will find your NSString

    One thing you can do with pointers in Swift (this can even be done with inout parameters)

        func playWithPointer (stringa :AutoreleasingUnsafePointer<NSString>) 
        {
            stringa.memory = "String Updated";
        }
    
        var testString : NSString = "test string"
        println(testString)
        playWithPointer(&testString)
        println(testString)
    

    Or, interacting with 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
    

  • Translate

    To get the (heap) address of an object

    func address<T: AnyObject>(o: T) -> Int {
        return unsafeBitCast(o, Int.self)
    }
    
    class Test {}
    var o = Test()
    println(NSString(format: "%p", address(o))) // -> 0x7fd5c8700970
    

    (Edit: Swift 1.2 now includes a similar function called unsafeAddressOf.)

    In Objective-C this would be [NSString stringWithFormat:@"%p", o].

    o is a reference to the instance. So if o is assigned to another variable o2, the returned address for o2 will be the same.

    This doesn't apply to structs (including String) and primitive types (like Int), because those live directly on the stack. But we can retrieve the location on the stack.

    To get the (stack) address of a struct, build-in type or object reference

    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
    

    In Objective-C this would be [NSString stringWithFormat:@"%p", &o] or [NSString stringWithFormat:@"%p", &i].

    s is struct. So if s is assigned to another variable s2, the value will be copied and the returned address for s2 will be different.

    How it fits together (pointer recap)

    Like in Objective-C, there are two different addresses associated with o. The first is the location of the object, the second is the location of the reference (or pointer) to the object.

    Yes, this means that the content of address 0x7fff5fbfe658 is the number 0x6100000011d0 as the debugger can tell us:

    (lldb) x/g 0x7fff5fbfe658
    0x7fff5fbfe658: 0x00006100000011d0
    

    So, except for strings being structs, internally this all pretty much works the same as in (Objective-)C.

    (Current as of Xcode 6.3)


  • Translate

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

    (Gist)


    In Swift we deal either with value types (structures) or reference types (classes). When doing:

    let n = 42 // Int is a structure, i.e. value type
    

    Some memory is allocated at address X, and at this address we will find the value 42. Doing &n creates a pointer pointing to address X, therefore &n tells us where n is located.

    (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
    

    When doing:

    class C { var foo = 42, bar = 84 }
    var c = C()
    

    Memory is allocated in two places:

    • at address Y where the class instance data is located and
    • at address X where the class instance reference is located.

    As said, classes are reference types: so the value of c is located at address X, at which we'll find the value of Y. And at address Y + 16 we'll find foo and at address Y + 24 we'll find bar (at + 0 and + 8 we'll find type data and reference counts, I can't tell you much more about this...).

    (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 is 42 (foo) and 0x54 is 84 (bar).

    In both cases, using &n or &c will give us address X. For value types, that's what we want, but isn't for reference types.

    When doing:

    let referencePointer = UnsafeMutablePointer<C>(&c)
    

    We create a pointer on the reference, i.e. a pointer that points to address X. Same thing when using 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)
    

    Now that we have a better understanding of what goes on under the hood, and that we now that at address X we'll find address Y (which is the one we want) we can do the following to get it:

    let addressY = unsafeBitCast(c, to: Int.self)
    

    Verifying:

    (lldb) frame variable addressY -f hex
    (Int) addressY = 0x0000000101b2fd20
    (lldb) frame variable c
    (testmem.C) c = 0x0000000101b2fd20 (foo = 42, bar = 84)
    

    There are other ways to do this:

    let addressY1 = Int(bitPattern: Unmanaged.passUnretained(c).toOpaque())
    let addressY2 = withUnsafeMutableBytes(of: &c) { $0.load(as: Int.self) }
    

    toOpaque() actually calls unsafeBitCast(c, to: UnsafeMutableRawPointer.self).

    I hope this helped... it did for me ?.


  • Translate

    Reference Types:

    • It makes sense to get the memory address of a reference type as it represents identity.
    • === identity operator is used to check 2 objects point to the same reference.
    • Use ObjectIdentifier to get the memory address

    Code:

    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
    

    Value Types:

    • The need to get the memory address of a value type is not of much significance (as it is a value) and the emphasis would be more on the equality of the value.

  • Translate

    If you just want to see this in the debugger and not do anything else with it, there's no need to actually get the Int pointer. To get the string representation of an object's address in memory, just use something like this:

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

    Example usage:

    print(self.pointerString, "Doing something...")
    // Prints like: 0x7fd190d0f270 Doing something...
    

    Additionally, remember that you can simply print an object without overriding its description, and it will show its pointer address alongside more descriptive (if oft cryptic) text.

    print(self, "Doing something else...")
    // Prints like: <MyModule.MyClass: 0x7fd190d0f270> Doing something else...
    // Sometimes like: <_TtCC14__lldb_expr_668MyModule7MyClass: 0x7fd190d0f270> Doing something else...
    

  • Translate

    Swift 4

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

    Usage:

    print("FileManager.default: \(String.pointer(FileManager.default))")
    // FileManager.default: 0x00007fff5c287698
    
    print("nil: \(String.pointer(nil))")
    // nil: nil
    

  • Translate

    In Swift4 about Array:

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

  • Translate

    Just use this:

    print(String(format: "%p", object))
    

  • Translate

    The other answers are fine, though I was looking for a way to get the pointer address as an integer:

    let ptr = unsafeAddressOf(obj)
    let nullPtr = UnsafePointer<Void>(bitPattern: 0)
    
    /// This gets the address of pointer
    let address = nullPtr.distanceTo(ptr) // This is Int
    

    Just a little follow-up.


  • Translate

    The answer @Drew provide can only be used for class type.
    The answer @nschum provide can only be for struct type.

    However if you use the second method to get address of a array with value type element. Swift will copy the whole array because in Swift array is copy-on-write and Swift can't make sure it behave this way once it pass control over to C/C++ (Which is trigger by using & to get address). And if you use first method instead , it will automatically convert Array to NSArray which is surely something we don't want.

    So the most simple and unified way I found is using lldb instruction frame variable -L yourVariableName.

    Or you can combine their answers:

    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
    }
    

  • Translate

    This is for Swift 3.

    Like @CharlieMonroe I wanted to get the address as an integer. Specifically, I wanted the address of a Thread object for use as a thread ID in a diagnostic logging module, for situations where no thread name was available.

    Based on Charlie Monroe's code, here's what I've come up with so far. But beware, I'm very new to Swift, this may not be correct ...

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

    The last statement is there because without it I was getting addresses like 0x60000007DB3F. The modulo operation in the last statement converts that into 0x7DB3F.


  • Translate

    My solution on Swift 3

    extension MyClass: CustomStringConvertible {
        var description: String {
            return "<\(type(of: self)): 0x\(String(unsafeBitCast(self, to: Int.self), radix: 16, uppercase: false))>"
        }
    }
    

    this code create description like default description <MyClass: 0x610000223340>


  • Translate

    This is certainly not the fastest or safest way to go about it. But it works for me. This will allow for any nsobject subclass to adopt this property.

    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