とにかく[NSString stringWithFormat:@"%p", myVar]、新しいSwift言語でObjective-Cからをシミュレートすることはありますか？

例えば：

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

スウィフト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)")
}

注：これは参照タイプ用です。

Swift 4/5：

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

someVarのメモリアドレスを出力します。（@Yingに感謝）

Swift 3.1：

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

someVarのメモリアドレスを出力します。

この答えはかなり古いことに注意してください。それが説明するメソッドの多くはもはや機能しません。具体的に.coreはもうアクセスできません。

しかし、@ drewの答えは正しく簡単です。

これは現在、標準ライブラリunsafeAddressOfの一部です。

だからあなたの質問への答えは：

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

正しいとマークされた元の答えは次のとおりです（後世/丁寧さ）。

Swiftはポインターを「非表示」にしますが、内部にはまだ存在しています。（ランタイムがそれを必要とするため、およびObjcとCとの互換性の理由から）

ただし、知っておくべきことがいくつかありますが、最初にSwift文字列のメモリアドレスを出力する方法を教えてください。

    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を出力します（16進表記）。あなたはその内容を変更することができます*intptr = 123456

さて、他に知っておくべきことがいくつかあります。

文字列は、迅速に言えば、オブジェクトではなくプリミティブ型です。
CIntは、C int型にマップされたSwift型です。
オブジェクトのメモリアドレスが必要な場合は、別のことを行う必要があります。
：スウィフトはCと対話するときに使用することができ、いくつかのポインタ型を持っており、あなたがここでそれらについて読むことができスウィフトポインタ型を
変換する方法を理解するために、（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でポインターを使用して実行できる1つのこと（これは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と同様に、に関連付けられた2つの異なるアドレスがありますo。1つ目はオブジェクトの場所、2つ目はオブジェクトへの参照（またはポインタ）の場所です。

はい、これは、デバッガーが通知できるように、アドレス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()

メモリは2つの場所に割り当てられます。

• クラスインスタンスデータが配置されているアドレス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

0x2a42（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)。

これがお役に立てば幸いです...

参照タイプ：

• IDを表すため、参照型のメモリアドレスを取得することは理にかなっています。
• === 識別演算子は、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))

デバッガでこれを表示したいだけで、それ以外には何もしない場合は、実際に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...

スウィフト5

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

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

他の答えは結構ですが、ポインタアドレスを整数として取得する方法を探していました。

let ptr = unsafeAddressOf(obj)
let nullPtr = UnsafePointer<Void>(bitPattern: 0)

/// This gets the address of pointer
let address = nullPtr.distanceTo(ptr) // This is Int

ほんの少しフォローアップ。

@Drewが提供する回答は、クラス型にのみ使用できます。
@nschumが提供する回答は、構造体型に対してのみ可能です。

ただし、2番目のメソッドを使用して、値型の要素を持つ配列のアドレスを取得する場合。Swiftでは配列がcopy-on-writeであり、SwiftがC / C ++に制御を渡すと（Swiftは&アドレスを取得するためにトリガーされる）、このように動作することを確認できないため、Swiftは配列全体をコピーします。そして、代わりに最初のメソッドを使用する場合、それは自動的に変換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のように、アドレスを整数として取得したかったのです。具体的には、スレッド名が使用できない状況で、診断ログモジュールのスレッドIDとして使用するThreadオブジェクトのアドレスが必要でした。

チャーリー・モンローのコードに基づいて、これが私がこれまでに思いついたものです。しかし、注意してください、私は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