只要用这个:

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

斯威夫特2

这是标准库的一部分: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

斯威夫特3

对于Swift 3,请使用withUnsafePointer:

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

获取对象的(堆)地址

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. Doing &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()

内存分配在两个地方:

在类实例数据所在的地址Y处

在类实例引用所在的地址X处.

如上所述,类是引用类型:因此值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).

我希望这有帮助......它对我有用.

Swift 4.X:

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

打印someVar的内存地址.(感谢@Ying)

Swift 3.1:

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

打印someVar的内存地址.

参考类型:

获取引用类型的内存地址是有意义的,因为它代表了身份.

=== identity运算符用于检查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

价值类型:

获取值类型的内存地址的需要没有多大意义(因为它是一个值),并且重点将更多地放在值的相等性上.

斯威夫特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)
    }
}

用法:

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

print("nil: \(String.pointer(nil))")
// nil: nil

请注意,这个答案很老了.它描述的许多方法不再有效.具体.core不能再访问了.

然而,@ drew的回答是正确而简单的:

现在这是标准库的一部分:unsafeAddressOf.

所以你的问题的答案是:

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

以下是标记正确的原始答案(后代/礼貌):

斯威夫特"隐藏"指针,但它们仍然存在于引擎盖下.(因为运行时需要它,并且出于与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

现在,还有其他一些事要知道.

swift中的字符串是原始类型,而不是对象.
CInt是映射到C int Type的Swift类型.
如果你想要一个对象的内存地址,你必须做一些不同的事情.
Swift有一些可以在与C交互时使用的指针类型
,你可以在这里阅读它们:Swift指针类型此外,你可以更多地了解它们探索它们的声明(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

在关于数组的Swift4中：

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