Using Swift with Cocoa and Objective-C (Swift 4.1): Interacting with C APIs

As part of its interoperability with Objective-C, Swift maintains compatibility with a number of C language types and features. Swift also provides a way of working with common C constructs and patterns, in case your code requires it.
そのObjective-Cとの相互運用性の一部として、スウィフトはたくさんのC言語型と特徴との互換性を維持します。スウィフトはまた、あなたのコードがそれを必要とする場合に備えて、一般的なC構造物とパターンを扱う方法を提供します。

Primitive Types
基本の型

Swift provides equivalents of C primitive integer types—for example, char, int, float, and double. However, there is no implicit conversion between these types and core Swift integer types, such as Int. Therefore, use these types if your code specifically requires them, but use Int wherever possible otherwise.
スウィフトは、Cの基本の整数型の等価物を提供します ― 例えば、char、int、float、そしてdouble。しかし、これらの型と中心的なスウィフト整数型、例えばIntとの間に暗黙的な変換はありません。したがって、あなたのコードが特にそれらを必要とする場合にこれらの型を使ってください、しかし一方で可能な場合にはいつでもIntを使ってください。


C Type C型	Swift Type スウィフト型
`bool`	`CBool`
`char`, `signed char`	`CChar`
`unsigned char`	`CUnsignedChar`
`short`	`CShort`
`unsigned short`	`CUnsignedShort`
`int`	`CInt`
`unsigned int`	`CUnsignedInt`
`long`	`CLong`
`unsigned long`	`CUnsignedLong`
`long long`	`CLongLong`
`unsigned long long`	`CUnsignedLongLong`
`wchar_t`	`CWideChar`
`char16_t`	`CChar16`
`char32_t`	`CChar32`
`float`	`CFloat`
`double`	`CDouble`

Global Constants
グローバルな定数

Global constants defined in C and Objective-C source files are automatically imported by the Swift compiler as Swift global constants.
CとObjective-Cソース・ファイルにおいて定義されるグローバル定数は、スウィフトコンパイラによってスウィフトのグローバル定数として自動的にインポートされます。

Imported Constant Enumerations and Structures
インポートされる定数列挙と構造体

In Objective-C, constants are often used to provide a list of possible values for properties and method parameters. You can annotate an Objective-C typedef declaration with the NS_TYPED_ENUM or NS_TYPED_EXTENSIBLE_ENUM macro to have constants of that type imported by Swift as members of a common type. Use NS_TYPED_ENUM for sets of values that can’t logically have values added in a Swift extension. Use NS_TYPED_EXTENSIBLE_ENUM for sets of values that can be expanded in an extension.
Objective-Cでは、プロパティおよびメソッドパラメータに対する候補の値のリストを提供するためにしばしば定数が使われます。あなたは、Objective-Cのtypedef宣言にNS_TYPED_ENUMまたはNS_TYPED_EXTENSIBLE_ENUMマクロで注釈をつけることで、その型の定数をスウィフトによって普通の型のメンバとしてインポートされるようにします。NS_TYPED_ENUMを、一揃いの値で論理的に値を追加することがスウィフト拡張において不可能なものに対して使ってください。NS_TYPED_EXTENSIBLE_ENUMを、一揃いの値で拡張において拡張可能なものに使ってください。

Constants that represent a fixed set of possible values can be imported as a structure by adding the NS_TYPED_ENUM macro. For example, consider the following Objective-C declarations for integer constants of type TrafficLightColor:
ある固定された一揃いの候補の値を表す定数いくらかは、構造体としてインポートされることがNS_TYPED_ENUMマクロを加えることによって可能です。例えば、型TrafficLightColorの整数定数のための以下のObjective-C宣言を考えてみてください：

        // Store the three traffic light color options as 0, 1, and 2. （３つの交通信号色選択肢を0、1、および2として格納する。）

typedef long TrafficLightColor NS_TYPED_ENUM;
 
TrafficLightColor const TrafficLightColorRed;
TrafficLightColor const TrafficLightColorYellow;
TrafficLightColor const TrafficLightColorGreen;

Here’s how Swift imports them:
ここにどのようにスウィフトがそれらをインポートするかがあります：

        struct TrafficLightColor: RawRepresentable, Equatable, Hashable {
    typealias RawValue = Int
    
    init(rawValue: RawValue)
    var rawValue: RawValue { get }
    
    static var red: TrafficLightColor { get }
    static var yellow: TrafficLightColor { get }
    static var green: TrafficLightColor { get }
}

      

Constants that represent an extensible set of possible values can be imported as a structure by adding the NS_TYPED_EXTENSIBLE_ENUM macro. For example, consider the following Objective-C declarations that represent sets of actively illuminated colors on a traffic light:
ある拡張可能な一揃いの候補の値を表す定数いくらかは、NS_TYPED_EXTENSIBLE_ENUMマクロを加えることによって構造体としてインポートされることができます。例えば、信号機上で活発に変わる照明された色の一揃いを表す以下のObjective-C宣言を考えてみてください：

        typedef TrafficLightColor TrafficLightCombo [3] NS_TYPED_EXTENSIBLE_ENUM;
 
TrafficLightCombo const TrafficLightComboJustRed;
TrafficLightCombo const TrafficLightComboJustYellow;
TrafficLightCombo const TrafficLightComboJustGreen;
 
// Some places use a combination of lights to indicate a specific condition. （幾つかの場所は、照明の組み合わせを使うことで特定の状況を指し示します。）

TrafficLightCombo const TrafficLightComboRedYellow;

Here’s how Swift imports them:
ここにどのようにスウィフトがそれらをインポートするかがあります：

        struct TrafficLightCombo: RawRepresentable, Equatable, Hashable {
    typealias RawValue = (TrafficLightColor, TrafficLightColor, TrafficLightColor)
    
    init(_ rawValue: RawValue)
    init(rawValue: RawValue)
    var rawValue: RawValue { get }
    
    static var justRed: TrafficLightCombo { get }
    static var justYellow: TrafficLightCombo { get }
    static var justGreen: TrafficLightCombo { get }
    static var redYellow: TrafficLightCombo { get }
}

      

Constants using this extensible form are imported with an additional initializer that lets you omit the argument label when extending the set with new values.
この拡張可能な形式を使う定数は、追加的なイニシャライザ、集合を新しい値で拡張する時に引数ラベルをあなたに省略させるもの、でインポートされます。

Constants imported from a type declaration marked with the NS_TYPED_EXTENSIBLE_ENUM macro can be extended in Swift code to add new values.
NS_TYPED_EXTENSIBLE_ENUMマクロで印される型宣言からインポートされる定数は、スウィフトコードにおいて拡張されて新しい値を加えられることが可能です。

        extension TrafficLightCombo {
    static var all: TrafficLightCombo {
        return TrafficLightCombo((.red, .yellow, .green))
    }
}

      

Functions
関数

Swift imports any function declared in a C header as a Swift global function. For example, consider the following C function declarations:
スウィフトは、Cヘッダにおいて宣言されるどんな関数もスウィフトのグローバルな関数としてインポートします。例えば、以下のC関数定義を考えてみてください：

        int product(int multiplier, int multiplicand);
int quotient(int dividend, int divisor, int *remainder);
 
struct Point2D createPoint2D(float x, float y);
float distance(struct Point2D from, struct Point2D to);

Here’s how Swift imports them:
ここにどのようにスウィフトがそれらをインポートするかがあります：

        func product(_ multiplier: Int32, _ multiplicand: Int32) -> Int32
func quotient(_ dividend: Int32, _ divisor: Int32, _ remainder: UnsafeMutablePointer<Int32>) -> Int32
 
func createPoint2D(_ x: Float, _ y: Float) -> Point2D
func distance(_ from: Point2D, _ to: Point2D) -> Float

Variadic Functions
可変長引数関数

In Swift, you can call C variadic functions, such as vasprintf, using the getVaList(_:) or withVaList(_:_:) functions. The getVaList(_:) function takes an array of CVarArg values and returns a CVaListPointer value, whereas the withVaList(_:_:) provides this value within the body a closure parameter rather than returning it directly. The resulting CVaListPointer value is then passed to the va_list argument of the C variadic function.
スウィフトにおいて、あなたはCの可変長引数関数、例えばvasprintfなどを呼び出すことがgetVaList(_:)またはwithVaList(_:_:)関数を使って可能です。getVaList(_:)関数は、CVarArg値からなるひとつの配列をとってCVaListPointer値を返します、一方でwithVaList(_:_:)は、この値を本文内部でクロージャパラメータに提供します、それを直接返すのではなく。結果のCVaListPointer値は、それからC可変長引数関数のva_list引数に渡されます。

For example, here’s how to call the vasprintf function in Swift:
例えば、ここにvasprintf関数をスウィフトにおいて呼び出す方法があります：

        func swiftprintf(format: String, arguments: CVarArg...) -> String? {
    return withVaList(arguments) { va_list in
        var buffer: UnsafeMutablePointer<Int8>? = nil
        return format.withCString { cString in
            guard vasprintf(&buffer, cString, va_list) != 0 else {
                return nil
            }
            
            return String(validatingUTF8: buffer!)
        }
    }
}
print(swiftprintf(format: "√2 ≅ %g", arguments: sqrt(2.0))!)
// Prints "√2 ≅ 1.41421"

      

Structures
構造体

Swift imports any C structure declared in a C header as a Swift structure. The imported Swift structure contains a stored property for each C structure field and an initializer whose parameters correspond to the stored properties. If all of the imported members have default values, Swift also provides a default initializer that takes no arguments. For example, given the following C structure:
スウィフトは、Cヘッダにおいて宣言されるどんなC構造体もスウィフト構造体としてインポートします。インポートされたスウィフト構造体は、各C構造体フィールドに対してひとつの格納プロパティを、そしてそれのパラメータが格納プロパティと対応するひとつのイニシャライザを含みます。インポートされたメンバのすべてが省略時の値を持つならば、スウィフトもまた引数を取らない省略時のイニシャライザをひとつ提供します。例えば、以下のC構造体を与えられて：

        struct Color {
    float r, g, b;
};
typedef struct Color Color;

      

Here’s the corresponding Swift type:
ここに対応するスウィフト型があります：

        public struct Color {
    var r: Float
    var g: Float
    var b: Float
    
    init()
    init(r: Float, g: Float, b: Float)
}

      

Importing Functions as Type Members
関数を型メンバとしてインポートする

C APIs, such as the Core Foundation framework, often provide functions that create, access, or modify C structures. You can use the CF_SWIFT_NAME macro in your own code to have Swift import C functions as members of the imported structure type. For example, given the following C function declarations:
C API、例えばCore Foundationフレームワークは、C構造体の作成、アクセス、または修正をする関数をしばしば提供します。あなたは、CF_SWIFT_NAMEマクロをあなた自身のコードにおいて使うことで、スウィフトがC関数をインポートされた構造体型のメンバとしてインポートするようにします。例えば、以下のC関数定義を与えられて：

        Color ColorCreateWithCMYK(float c, float m, float y, float k) CF_SWIFT_NAME(Color.init(c:m:y:k:));
 
float ColorGetHue(Color color) CF_SWIFT_NAME(getter:Color.hue(self:));
void ColorSetHue(Color color, float hue) CF_SWIFT_NAME(setter:Color.hue(self:newValue:));
 
Color ColorDarkenColor(Color color, float amount) CF_SWIFT_NAME(Color.darken(self:amount:));
 
extern const Color ColorBondiBlue CF_SWIFT_NAME(Color.bondiBlue);
 
Color ColorGetCalibrationColor(void) CF_SWIFT_NAME(getter:Color.calibration());
Color ColorSetCalibrationColor(Color color) CF_SWIFT_NAME(setter:Color.calibration(newValue:));

Here’s how Swift imports them as type members:
ここにどのようにスウィフトがそれらを型メンバとしてインポートするかがあります：

        extension Color {
    init(c: Float, m: Float, y: Float, k: Float)
    
    var hue: Float { get set }
    
    func darken(amount: Float) -> Color
    
    static var bondiBlue: Color
    
    static var calibration: Color
}

The argument passed to the CF_SWIFT_NAME macro uses the same syntax as the #selector expression. The use of self in a CF_SWIFT_NAME argument is used for instance methods to refer to the method receiver.
CF_SWIFT_NAMEマクロに渡された引数は、#selector式と同じ構文を使います。CF_SWIFT_NAME引数におけるselfの使用は、インスタンスメソッドに対して使われてメソッドのレシーバを参照します。

Enumerations
列挙

Swift imports any C enumeration marked with the NS_ENUM macro as a Swift enumeration with an Int raw value type. The prefixes to C enumeration case names are removed when they are imported into Swift, whether they’re defined in system frameworks or in custom code.
スウィフトは、NS_ENUMマクロで印を付けられるどんなCの列挙でも、生の値型Intを持つスウィフト列挙としてインポートします。C列挙ケース節名への接頭辞は、それらがスウィフトにインポートされるとき削除されます、それらがシステムフレームワークでまたはあつらえのコードで定義されるかに関係なくです。

For example, the C enumeration below is declared using the NS_ENUM macro.
例えば、以下のC列挙はNS_ENUMマクロを使って宣言されます。

        typedef NS_ENUM(NSInteger, UITableViewCellStyle) {
   UITableViewCellStyleDefault,
   UITableViewCellStyleValue1,
   UITableViewCellStyleValue2,
   UITableViewCellStyleSubtitle
};

      

In Swift, it’s imported like this:
スウィフトでは、それはこのようにインポートされます：

        enum UITableViewCellStyle: Int {
    case `default`
    case value1
    case value2
    case subtitle
}

      

When you refer to an enumeration value, use the value name with a leading dot (.).
あなたが列挙値に言及するとき、前にドット（.）をつけた値名を使用してください。

        let cellStyle: UITableViewCellStyle = .default

      

A C enumeration that is not marked with the NS_ENUM or NS_OPTIONS macro is imported as a Swift structure. Each member of the C enumeration is imported as a global read-only computed property of the structure’s type—not as a member of the Swift structure itself.
NS_ENUMまたはNS_OPTIONSマクロで印されないC列挙は、スウィフト構造体としてインポートされます。C列挙の各メンバーは、その構造体の型のグローバルな読み出し専用の計算プロパティとしてインポートされます ― スウィフト構造体自身のメンバーとしてではなく。

For example, the following C enumeration is not declared using the NS_ENUM macro:
例えば、以下のC列挙はNS_ENUMマクロを使って宣言されません。

        typedef enum {
   MessageDispositionUnread = 0,
   MessageDispositionRead = 1,
   MessageDispositionDeleted = -1,
} MessageDisposition;

      

In Swift, it’s imported like this:
スウィフトでは、それはこのようにインポートされます：

        struct MessageDisposition: RawRepresentable, Equatable {}
 
var MessageDispositionUnread: MessageDisposition { get }
var MessageDispositionRead: MessageDisposition { get }
var MessageDispositionDeleted: MessageDisposition { get }

Swift automatically synthesizes conformance to the Equatable protocol for imported C enumeration types.
スウィフトは、インポートされたC列挙型に対して自動的にEquatableプロトコルへの準拠を合成します。

Option Sets
オプションセット

Swift also imports C enumerations marked with the NS_OPTIONS macro as a Swift option set. Option sets behave similarly to imported enumerations by truncating their prefixes to option value names.
スウィフトはまた、NS_OPTIONSマクロで印を付けられるCの列挙をスウィフトオプションセットとしてインポートします。オプションセットは、それらのオプション値名の接頭辞を切り取ることでインポートされた列挙と同じように振舞います。

For example, consider the following Objective-C options declaration:
例として、以下のObjective-Cオプション定義を考えてみてください。

        typedef NS_OPTIONS(NSUInteger, UIViewAutoresizing) {
        UIViewAutoresizingNone                 = 0,
        UIViewAutoresizingFlexibleLeftMargin   = 1 << 0,
        UIViewAutoresizingFlexibleWidth        = 1 << 1,
        UIViewAutoresizingFlexibleRightMargin  = 1 << 2,
        UIViewAutoresizingFlexibleTopMargin    = 1 << 3,
        UIViewAutoresizingFlexibleHeight       = 1 << 4,
        UIViewAutoresizingFlexibleBottomMargin = 1 << 5
};

      

In Swift, it’s imported like this:
スウィフトでは、それはこのようにインポートされます：

        public struct UIViewAutoresizing : OptionSet {
    public init(rawValue: UInt)
    
    public static var flexibleLeftMargin: UIViewAutoresizing { get }
    public static var flexibleWidth: UIViewAutoresizing { get }
    public static var flexibleRightMargin: UIViewAutoresizing { get }
    public static var flexibleTopMargin: UIViewAutoresizing { get }
    public static var flexibleHeight: UIViewAutoresizing { get }
    public static var flexibleBottomMargin: UIViewAutoresizing { get }
}

      

In Objective-C, an option set is a bit mask of integer values. You use the bitwise OR operator (|) to combine option values, and the bitwise AND operator (&) to check for option values. You create a new option set from a constant value or expression, An empty option set is represented by the constant zero (0).
Objective-Cでは、オプションセットは整数値のビットマスクです。あなたはビット単位OR演算子（|）をオプション値を結合するために、そしてビット単位AND演算子（&）をオプション値の確認に使います。あなたは、新しいオプションセットを定数値または式から作成します。空のオプションセットは定数ゼロ（0）で表現されます。

In Swift, option sets are represented by structures conforming to the OptionSet protocol, with static variables for each option value. You can create a new option set value using an array literal, and access option values with a leading dot (.), similar to an enumeration. An empty option set can be created from an empty array literal ([]) or by calling its default initializer.
スウィフトでは、オプションセットはOptionSetプロトコルに準拠している構造体によって表され、静的変数を各オプション値に対して持ちます。あなたは、新しいオプションセット値を配列リテラルを使って作成すること、そしてオプション値へ前に付けたドット（.）で、列挙のようにアクセスすることができます。空のオプションセットは、空の配列リテラル（[]）から、またはそれの省略時のイニシャライザを呼ぶことによって作成されることができます。

Option sets behave like Swift’s Set collection type. You use the insert(_:) or formUnion(_:) methods to add option values, the remove(_:) or subtract(_:) methods to remove option values, and the contains(_:) method to check for an option value.
オプションセットは、スウィフトのSetコレクション型に似た振る舞いをします。あなたはinsert(_:)またはformUnion(_:)メソッドを使ってオプション値を付け加え、remove(_:)またはsubtract(_:)メソッドを使ってオプション値を削除し、そしてcontains(_:)メソッドを使ってあるオプション値を調べます。

        let options: Data.Base64EncodingOptions = [
    .lineLength64Characters,
    .endLineWithLineFeed
]
let string = data.base64EncodedString(options: options)

      

Unions
共用体

Swift imports C unions as Swift structures. Although Swift doesn’t support unions, a C union imported as a Swift structure still behaves like a C union. For example, consider a C union named SchroedingersCat that has an isAlive and an isDead field:
スウィフトは、C共用体をスウィフト構造体としてインポートします。スウィフトは共用体をサポートしないにもかかわらず、スウィフト構造体としてインポートされたC共用体は依然としてC共用体のように振る舞います。例えば、SchroedingersCatと名前を付けられるC共用体を考えてください、それはisAliveとisDeadフィールドを持ちます：

        union SchroedingersCat {
    bool isAlive;
    bool isDead;
};

      

In Swift, it’s imported like this:
スウィフトでは、それはこのようにインポートされます：

        struct SchroedingersCat {
    var isAlive: Bool { get set }
    var isDead: Bool { get set }
    
    init(isAlive: Bool)
    init(isDead: Bool)
    
    init()
}

      

Because unions in C use the same base memory address for all of their fields, all of the computed properties in a union imported by Swift use the same underlying memory. As a result, changing the value of any computed property on an instance of the imported structure changes the value of all other properties defined by that structure.
Cでの共用体は同じ基盤メモリアドレスをすべてのそれのフィールドに対して使うことから、スウィフトによってインポートされる共用体の中の計算プロパティのすべては同じ基礎をなすメモリを使います。結果として、インポートされた構造体のインスタンス上で何らかの計算プロパティを変更することは、その構造体によって定義される他のプロパティすべての値を変更します。

In the example below, changing the value of the isAlive computed property on an instance of the SchroedingersCat structure also changes the value of the instance’s isDead computed property:
下の例において、isAlive計算プロパティの値をSchroedingersCat構造体のインスタンス上で変更することは、またそのインスタンスのisDead計算プロパティの値も変更します：

        var mittens = SchroedingersCat(isAlive: false)
 
print(mittens.isAlive, mittens.isDead)
// Prints "false false"
 
mittens.isAlive = true
print(mittens.isDead)
// Prints "true"

      

Bit Fields
ビットフィールド

Swift imports bit fields in structures, such those found in Foundation’s NSDecimal type, as computed properties. When accessing a computed property corresponding to a bit field, Swift automatically converts the value to and from compatible Swift types.
スウィフトは、構造体においてビットフィールド、FoundationのNSDecimal型において見つけられるものなどを、計算プロパティとしてインポートします。あるビットフィールドに対応している計算プロパティにアクセスするとき、スウィフトはその値を自動的に互換性のあるスウィフト型へと、またはそれから、変換します。

Unnamed Structure and Union Fields
無名の構造体と共用体フィールド

C struct and union types can define fields that have no name or that are of an unnamed type. Unnamed fields consist of a nested struct or union type with named fields.
Cのstructおよびunion型は、名前を持たないまたは無名型であるフィールドを定義できます。無名フィールドは、入れ子にされたstructまたはunionで名前付きフィールドを持つものから成ります。

For example, consider a C structure named Cake that contains the fields layers and height nested within an unnamed union type, and a field toppings of an unnamed struct type:
例えば、Cakeと名前を付けられるC構造体を考えてください、それはフィールドlayersおよびheightを無名のunion型内部に、そして無名struct型のフィールドtoppingsを含みます：

        struct Cake {
    union {
        int layers;
        double height;
    };
 
    struct {
        bool icing;
        bool sprinkles;
    } toppings;
};

      

After the Cake structure has been imported, you can initialize it and use it as follows:
Cake構造体がインポートされてしまった後、あなたはそれを初期化してそれを以下のように使うことができます：

        var simpleCake = Cake()
simpleCake.layers = 5
print(simpleCake.toppings.icing)
// Prints "false"

      

The Cake structure is imported with a memberwise initializer that you can use to initialize the structure with custom values for its fields, as seen below:
Cake構造体は、メンバー関連イニシャライザでインポートされます、それはあなたが構造体をそれのフィールドに誂えの値を使って初期化するのに使うことができるものです、下で見られるように：

        let cake = Cake(
    .init(layers: 2),
    toppings: .init(icing: true, sprinkles: false)
)
 
print("The cake has \(cake.layers) layers.")
// Prints "The cake has 2 layers."
print("Does it have sprinkles?", cake.toppings.sprinkles ? "Yes." : "No.")
// Prints "Does it have sprinkles? No."

      

Because the first field of the Cake structure is unnamed, its initializer’s first parameter does not have a label. Because the Cake structure has fields with unnamed types, you use the .init initializers, which are picked using type inference, to set the initial value for each of the structure’s unnamed fields.
Cake構造体の最初のフィールドが無名であるため、それのイニシャライザの最初のパラメータはラベルを持ちません。Cake構造体は無名型でのフィールドを持つことから、あなたは.initイニシャライザを使うことによって、それは型推論を使って選択されます、その構造体の持つ無名フィールドの各々に対して初期値を設定します。

Pointers
ポインター

Whenever possible, Swift avoids giving you direct access to pointers. There are, however, various pointer types available for your use when you need direct access to memory. The following tables use Type as a placeholder type name to indicate syntax for the mappings.
可能なときはいつでも、スウィフトはあなたにポインターへの直接のアクセスを与えることを避けます。しかし、あなたがメモリへの直接のアクセスを必要とするとき、あなたの利用に応じられるいろいろなポインター型があります。以下の表は、Typeをプレースホルダー型名として使ってマップのための構文を示します。

For return types, variables, and arguments, the following mappings apply:
戻り型、変数、そして引数のために、以下のマッピングが適用されます：


C Syntax C構文	Swift Syntax スウィフト構文
`const Type *`	`UnsafePointer<Type>`
`Type *`	`UnsafeMutablePointer<Type>`

For class types, the following mappings apply:
クラス型のために、以下のマッピングが適用されます：


C Syntax C構文	Swift Syntax スウィフト構文
`Type * const *`	`UnsafePointer<Type>`
`Type * __strong *`	`UnsafeMutablePointer<Type>`
`Type **`	`AutoreleasingUnsafeMutablePointer<Type>`

For pointers to untyped, raw memory, the following mappings apply:
型無しの、生のメモリへのポインタに対して、以下のマッピングを適用します：


C Syntax C構文	Swift Syntax スウィフト構文
`const void *`	`UnsafeRawPointer`
`void *`	`UnsafeMutableRawPointer`

Swift also provides pointer types for working with buffers, which are discussed in Buffer Pointers.
スウィフトはまたバッファを扱うためにいくつかのポインタ型を提供します、それらはバッファポインタにおいて解説されます。

If the type of the value pointed to by a C pointer cannot be represented by Swift, such as an incomplete struct type, the pointer is imported as an OpaquePointer.
Cポインタによって指し示される値の型がスウィフトによって表されることができないならば、たとえば不完全なstruct型など、そのポインタはOpaquePointerとしてインポートされます。

Constant Pointers
定数ポインター

When a function is declared as taking an UnsafePointer<Type> argument, it can accept any of the following:
ある関数がUnsafePointer<Type>引数を取るとして宣言されるとき、それは以下の何でも受け入れることができます：

An UnsafePointer<Type>, UnsafeMutablePointer<Type>, or AutoreleasingUnsafeMutablePointer<Type> value, which is converted to UnsafePointer<Type> if necessary.
ひとつのUnsafePointer<Type>、UnsafeMutablePointer<Type>、またはAutoreleasingUnsafeMutablePointer<Type>値、それは必要ならばUnsafePointer<Type>に変換されます。
A String value, if Type is Int8 or UInt8. The string will automatically be converted to UTF8 in a buffer, and a pointer to that buffer is passed to the function.
ひとつのString値、TypeがInt8またはUInt8であるならば。その文字列は、あるバッファにおいて自動的にUTF8に変換されます、そしてそのバッファへのポインタが関数へ渡されます。
An in-out expression that contains a mutable variable, property, or subscript reference of type Type, which is passed as a pointer to the address of the left-hand side identifier.
ひとつのin-out式で、それが型Typeの可変の変数、プロパティ、または添え字参照を含むもの、それは左手側識別子のアドレスへのポインタとして渡されます。
A [Type] value, which is passed as a pointer to the start of the array.
ひとつの[Type]値、それは配列の始まりへのポインターとして渡されます。

The pointer passed to the function is guaranteed to be valid only for the duration of the function call. Don’t try to persist the pointer and access it after the function has returned.
関数に渡されるポインタは、その関数呼び出しの継続期間に対してのみ有効であることを保証されます。そのポインタに固執すること、そして関数が帰った後でそれにアクセスすることを試みないでください

If you have declared a function like this one:
あなたがこのような関数を宣言したならば：

        func takesAPointer(_ p: UnsafePointer<Float>) {
    // ...
}

      

You can call it in any of the following ways:
あなたは、以下の方法の何ででもそれを呼ぶことができます：

        var x: Float = 0.0
takesAPointer(&x)
takesAPointer([1.0, 2.0, 3.0])

      

When a function is declared as taking an UnsafeRawPointer argument, it can accept the same operands as UnsafePointer<Type> for any type Type.
ある関数がUnsafeRawPointer引数を取るとして宣言されるとき、それは何らかの型Typeに対するUnsafePointer<Type>と同じ演算数を受け入れることができます。

If you have declared a function like this one:
あなたがこのような関数を宣言したならば：

        func takesARawPointer(_ p: UnsafeRawPointer?)  {
    // ...
}

      

You can call it in any of the following ways:
あなたは、以下の方法の何ででもそれを呼ぶことができます：

        var x: Float = 0.0, y: Int = 0
takesARawPointer(&x)
takesARawPointer(&y)
takesARawPointer([1.0, 2.0, 3.0] as [Float])
let intArray = [1, 2, 3]
takesARawPointer(intArray)

      

Mutable Pointers
可変ポインター

When a function is declared as taking an UnsafeMutablePointer<Type> argument, it can accept any of the following:
ある関数がUnsafeMutablePointer<Type>引数を取るとして宣言されるとき、それは以下の何でも受け入れることができます：

An UnsafeMutablePointer<Type> value
ひとつのUnsafeMutablePointer<Type>値
An in-out expression of type Type that contains a mutable variable, property, or subscript reference, which is passed as a pointer to the address of the mutable value.
１つの可変の変数、プロパティ、または添え字参照を含んでいる、型Typeの１つのin-out式、それは、ボインタとしてその可変値のアドレスへと渡されます。
An in-out expression of type [Type] that contains a mutable variable, property, or subscript reference, which is passed as a pointer to the start of the array, and is lifetime-extended for the duration of the call
可変の変数、プロパティ、または添え字参照を含んでいる、型[Type]のin-out式、それは、ポインタとしてその配列の始まりへと渡されます、そして呼び出しの持続期間は寿命延長されます

If you have declared a function like this one:
あなたがこのような関数を宣言したならば：

        func takesAMutablePointer(_ p: UnsafeMutablePointer<Float>) {
    // ...
}

      

You can call it in any of the following ways:
あなたは、以下の方法の何ででもそれを呼ぶことができます：

        var x: Float = 0.0
var a: [Float] = [1.0, 2.0, 3.0]
takesAMutablePointer(&x)
takesAMutablePointer(&a)

      

When a function is declared as taking an UnsafeMutableRawPointer argument, it can accept the same operands as UnsafeMutablePointer<Type> for any type Type.
ある関数がUnsafeMutableRawPointer引数を取るとして宣言されるとき、それは何らかの型Typeに対するUnsafeMutablePointer<Type>と同じ演算数を受け入れることができます。

If you have declared a function like this one:
あなたがこのような関数を宣言したならば：

        func takesAMutableRawPointer(_ p: UnsafeMutableRawPointer?)  {
    // ...
}

      

You can call it in any of the following ways:
あなたは、以下の方法の何ででもそれを呼ぶことができます：

        var x: Float = 0.0, y: Int = 0
var a: [Float] = [1.0, 2.0, 3.0], b: [Int] = [1, 2, 3]
takesAMutableRawPointer(&x)
takesAMutableRawPointer(&y)
takesAMutableRawPointer(&a)
takesAMutableRawPointer(&b)

      

Autoreleasing Pointers
自動解放ポインター

When a function is declared as taking an AutoreleasingUnsafeMutablePointer<Type>, it can accept any of the following:
ある関数がAutoreleasingUnsafeMutablePointer<Type>を取るとして宣言されるとき、それは以下の何でも受け入れることができます：

An AutoreleasingUnsafeMutablePointer<Type> value
ひとつのAutoreleasingUnsafeMutablePointer<Type>値
An in-out expression that contains a mutable variable, property, or subscript reference of type Type, which is copied bitwise into a temporary nonowning buffer. The address of that buffer is passed to the callee, and on return, the value in the buffer is loaded, retained, and reassigned into the operand.
ひとつのin-out式で、それが型Typeの可変の変数、プロパティ、または添え字参照を含むもの、それは一時的な非所有バッファにビット単位でコピーされるものです。そのバッファのアドレスは呼び出される側に渡されます、そして戻る時に、バッファの値はロードされ、保持され、演算数に再割り当てされます。

Note that this list does not include arrays.
このリストが配列を含まない点に注意してください。

If you have declared a function like this one:
あなたがこのような関数を宣言したならば：

        func takesAnAutoreleasingPointer(_ p: AutoreleasingUnsafeMutablePointer<NSDate?>) {
    // ...
}

      

You can call it in the following way:
あなたは、以下の方法でそれを呼ぶことができます：

        var x: NSDate? = nil
takesAnAutoreleasingPointer(&x)

Types that are pointed to are not bridged. For example, NSString ** comes over to Swift as AutoreleasingUnsafeMutablePointer<NSString?>, not AutoreleasingUnsafeMutablePointer<String?>.
ポインターで指される型は、橋渡しされません。例えば、NSString **はスウィフトにAutoreleasingUnsafeMutablePointer<NSString?>としてやってきます、AutoreleasingUnsafeMutablePointer<String?>ではなく。

Function Pointers
関数ポインター

C function pointers are imported into Swift as closures with C function pointer calling convention, denoted by the @convention(c) attribute. For example, a function pointer that has the type int (*)(void) in C is imported into Swift as @convention(c) () -> Int32.
C関数ポインターは、スウィフトにC関数呼出規約を持つクロージャとしてインポートされ、@convention(c)属性によって印を付けられます。例えば、Cにおけるint (*)(void)型をもつ関数ポインターは、スウィフトに@convention(c) () -> Int32としてインポートされます。

When calling a function that takes a function pointer argument, you can pass a top-level Swift function, a closure literal, or nil. You can also pass a closure property of a generic type or a generic method as long as no generic type parameters are referenced in the closure’s argument list or body. For example, consider Core Foundation’s CFArrayCreateMutable(_:_:_:) function. The CFArrayCreateMutable(_:_:_:) function takes a CFArrayCallBacks structure, which is initialized with function pointer callbacks:
関数ポインタ引数を取る関数を呼び出しているとき、あなたはトップレベルスウィフト関数、クロージャリテラル、またはnilを渡すことができます。あなたはまた、ひとつの総称体型のクロージャプロパティまたは総称体メソッドを渡すことが、いくつかの総称体型パラメータがクロージャの引数リストまたは本文において参照されるのでない限りは可能です。例えば、Core FoundationのCFArrayCreateMutable(_:_:_:)関数を考えてみてください。CFArrayCreateMutable(_:_:_:)関数は、ひとつのCFArrayCallBacks構造体を取ります、それは関数ポインタコールバックで初期化されます：

        func customCopyDescription(_ p: UnsafeRawPointer?) -> Unmanaged<CFString>? {
    // return an Unmanaged<CFString>? value
}
 
var callbacks = CFArrayCallBacks(
    version: 0,
    retain: nil,
    release: nil,
    copyDescription: customCopyDescription,
    equal: { (p1, p2) -> DarwinBoolean in
        // return Bool value
}
)
 
var mutableArray = CFArrayCreateMutable(nil, 0, &callbacks)

      

In the example above, the CFArrayCallBacks initializer uses nil values as arguments for the retain and release parameters, the customCopyDescription(_:) function as the argument for the customCopyDescription parameter, and a closure literal as the argument for the equal parameter.
上の例において、CFArrayCallBacksイニシャライザはnil値をretainとreleaseパラメーターに対する引数として、customCopyDescription(_:)関数をcustomCopyDescriptionパラメーターに対する引数として、そしてクロージャリテラルをequalパラメーターに対する引数として使います。

Note
注意

Only Swift function types with C function reference calling convention may be used for function pointer arguments. Like a C function pointer, a Swift function type with the @convention(c) attribute does not capture the context of its surrounding scope.
C関数参照呼出手法を持つスウィフト関数型だけが、関数ポインタ引数のために使われます。C関数ポインタのように、@convention(c)属性を持つスウィフト関数型は、それを取り囲んでいるスコープのコンテキストをキャプチャしません。

For more information, see Type Attributes in The Swift Programming Language (Swift 4.1).
更なる情報としては、型属性をスウィフトプログラミング言語（Swift 4.1）において見てください。

Buffer Pointers
バッファポインタ

A buffer pointer is used for low-level access to a region of memory. For example, you can use a buffer pointer for efficent processing and communication of data between apps and services.
バッファポインタは、メモリのある領域への低水準アクセスのために使われます。たとえば、あなたはアプリとサービス間での効率の良いデータの処理および通信のためにバッファポインタを使うことができます。

Swift has the following buffer pointer types:
スウィフトは、以下のバッファポインタ型を持ちます：

UnsafeBufferPointer
UnsafeMutableBufferPointer
UnsafeRawBufferPointer
UnsafeMutableRawBufferPointer

The typed buffer pointer types, UnsafeBufferPointer and UnsafeMutableBufferPointer, let you view or mutate a contiguous block of memory. These types let you access the memory as a collection, where each item is an instance of the buffer type’s Element generic type parameter.
型付きバッファポインタ型、UnsafeBufferPointerおよびUnsafeMutableBufferPointerは、あなたにメモリの隣接ブロックを眺めさせたり変化させたりします。これらの型は、あなたにコレクションとしてメモリにアクセスさせます、そこで各項目はそのバッファ型のもつElement総称体型パラメータのインスタンスです。

The raw buffer pointer types, UnsafeRawBufferPointer and UnsafeMutableRawBufferPointer, let you view or mutate a contiguous block of memory as a collection of UInt8 values, where each value corresponds to a byte of memory. These types let you use low-level programming patterns, such as operating on raw memory without compiler-checked type safety, or switching between several different typed interpretations of the same memory.
生のバッファポインタ型、UnsafeRawBufferPointerおよびUnsafeMutableRawBufferPointerは、あなたにメモリの隣接ブロックをUInt8値のコレクションとして眺めさせたり変化させたりします、そこで各値はメモリのあるバイトに対応します。これらの型はあなたに低水準プログラミングパターンを使用させます、たとえばコンパイラ確認の型安全なしの生の値上での演算など、または同じメモリのいくつかの異なる型での実装の間での切り替えなど。

Null Pointers
ヌルポインタ

In Objective-C, a pointer type declaration can use the _Nullable and _Nonnull annotations to specify whether or not that pointer may have a nil or NULL value. In Swift, a null pointer is represented by a nil value of an optional pointer type. Pointer initializers taking the integer representation of an address in memory are failable. A non-optional pointer type cannot be assigned a nil value.
Objective-Cでは、ボインタ型宣言は_Nullableおよび_Nonnull注釈を使うことで、そのポインタがnilまたはNULL値を持つかどうか指定できます。スウィフトでは、ヌルポインタはオプショナルポインタ型のnil値によって表されます。メモリ中のあるアドレスの整数表現をとるポインタイニシャライザは失敗可能です。非オプショナルポインタ型は、nil値を割り当てられることはできません。

The following mappings apply:
以下のマッピングを適用します：


Objective-C Syntax Objective-C構文	Swift Syntax スウィフト構文
`const Type * _Nonnull`	`UnsafePointer<Type>`
`const Type * _Nullable`	`UnsafePointer<Type>?`
`const Type * _Null_unspecified`	`UnsafePointer<Type>!`

Pointer Arithmetic
ポインタ算術

When working with opaque data types, you may need to perform unsafe pointer operations. You can use the arithmetic operators on Swift pointer values to create new pointers at a specified offset.
不透明データ型を扱うとき、あなたは非安全ポインタ演算を行う必要があるでしょう。あなたは算術演算子をスウィフトポインタ値上で使って、新しいポインタを指定されたオフセットで作成することができます。

        let pointer: UnsafePointer<Int8>
let offsetPointer = pointer + 24
// offsetPointer is 24 strides ahead of pointer （offsetPointerは、pointerの前方24ストライドです）

      

Data Type Size Calculation
データ型サイズ計算

In C, the sizeof and alignof operators return the size and alignment of any variable or data type, In Swift, you use MemoryLayout<T> to access the memory layout of the parameterized type T through the size, stride, and alignment properties. For example, the timeval structure in Darwin has a size and stride of 16 and an alignment of 8:
Cでは、sizeofおよびalignof演算子はあらゆる変数またはデータ型のサイズとアラインメントを返します、スウィフトでは、あなたはMemoryLayout<T>を使って、パラメータ化された型Tのメモリレイアウトにsize、stride、そしてalignmentプロパティを通してアクセスします。例えば、Darwinにおけるtimeval構造体は、16のサイズとストライドおよび8のアラインメントを持ちます：

        print(MemoryLayout<timeval>.size)
// Prints "16"
print(MemoryLayout<timeval>.stride)
// Prints "16"
print(MemoryLayout<timeval>.alignment)
// Prints "8"

      

You use this when calling C functions from Swift that take the size of a type or value as an argument. For example, the setsockopt(_:_:_:_:_:) function can specify a timeval value as a receive timeout option (SO_RCVTIMEO) for a socket by passing a pointer to that value and the length of that value:
あなたがこれを使うのは、ある型や値のサイズを引数としてとるC関数をスウィフトから呼び出している時です。例えば、setsockopt(_:_:_:_:_:)関数は、あるtimeval値を、受信時間切れオプション（SO_RCVTIMEO）としてあるソケットに対して指定することが、その値へのポインタとその値の長さを渡すことによって可能です：

        let sockfd = socket(AF_INET, SOCK_STREAM, 0)
var optval = timeval(tv_sec: 30, tv_usec: 0)
let optlen = socklen_t(MemoryLayout<timeval>.size)
if setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &optval, optlen) == 0 {
    // ...
}

      

For more information, see MemoryLayout.
詳細は、MemoryLayoutを見てください。

One-Time Initialization
ワンタイム初期化

In C, the pthread_once() function in POSIX and the dispatch_once() and dispatch_once_f() functions in Grand Central Dispatch provide mechanisms for executing initialization code exactly once. In Swift, global constants and stored type properties are guaranteed to be initialized only once, even when accessed across multiple threads simultaneously. Because this functionality is provided through language features, the corresponding POSIX and Grand Central Dispatch C function calls are not exposed by Swift.
Cでは、POSIXでのpthread_once()関数およびGrand Central Dispatchでのdispatch_once()とdispatch_once_f()関数は、厳密に一度だけ初期化コードを実行する仕組みを提供します。スウィフトでは、グローバル定数と格納型プロパティは、ただ一度だけ初期化されることを保証されます、複数のスレッドをまたいで同時にアクセスされた時でさえもです。この機能性は言語特徴によって提供されるので、相当するPOSIXおよびGrand Central DispatchのC関数呼び出しはスウィフトによって暴露されません。

Preprocessor Directives
プリプロセッサ指令

The Swift compiler does not include a preprocessor. Instead, it takes advantage of compile-time attributes, conditional compilation blocks, and language features to accomplish the same functionality. For this reason, preprocessor directives are not imported in Swift.
スウィフトコンパイラは、プリプロセッサを含みません。その代わりに、それは同じ機能性を達成するために、さまざまなコンパイル時属性、条件コンパイルブロック、そして言語機能を活用します。この理由のために、プリプロセッサ指令は、スウィフトにインポートされません。

Simple Macros
単純なマクロ

Where you typically used the #define directive to define a primitive constant in C and Objective-C, in Swift you use a global constant instead. For example, the constant definition #define FADE_ANIMATION_DURATION 0.35 can be better expressed in Swift with let FADE_ANIMATION_DURATION = 0.35. Because simple constant-like macros map directly to Swift global variables, the compiler automatically imports simple macros defined in C and Objective-C source files.
あなたがCとObjective-Cでプリミティブ定数を定義するために概して#define指令を使ったところを、スウィフトでは、あなたはその代わりにグローバル定数を使います。例えば、定数定義#define FADE_ANIMATION_DURATION 0.35は、スウィフトにおいてよりよく表されることがlet FADE_ANIMATION_DURATION = 0.35でできます。単純な定数的なマクロがスウィフトのグローバル変数に直接にマップするので、コンパイラは、CとObjective-Cソース・ファイルにおいて定義される単純なマクロを自動的にインポートします。

Complex Macros
複雑なマクロ

Complex macros are used in C and Objective-C but have no counterpart in Swift. Complex macros are macros that do not define constants, including parenthesized, function-like macros. You use complex macros in C and Objective-C to avoid type-checking constraints or to avoid retyping large amounts of boilerplate code. However, macros can make debugging and refactoring difficult. In Swift, you can use functions and generics to achieve the same results without any compromises. Therefore, the complex macros that are in C and Objective-C source files are not made available to your Swift code.
複雑なマクロがCとObjective-Cで使われますが、スウィフトにおいて対応するものがありません。複雑なマクロは、定数を定義するものではなく、括弧に入れられた、関数のようなマクロのことです。あなたは、複雑なマクロをCとObjective-Cにおいて型チェック制約を避けたり、常用文コードの大きな塊を繰り返しタイピングすることを避けるために使います。しかし、マクロはデバッグやリファクタリングを難しくすることがあります。スウィフトでは、あなたはどんな妥協もなしで同じ結果を成し遂げるために、関数と総称体を使用することができます。したがって、CとObjective-Cソース・ファイルの中にある複雑なマクロは、あなたのスウィフトコードで利用可能にされません。

Conditional Compilation Blocks
条件コンパイルブロック

Swift code and Objective-C code are conditionally compiled in different ways. Swift code can be conditionally compiled using conditional compilation blocks. For example, if you compile the code below using swift -D DEBUG_LOGGING to set the DEBUG_LOGGING conditional compilation flag, the compiler includes the code in the body of the conditional compilation block.
スウィフトコードとObjective-Cコードは、異なる方法で条件付きコンパイルされます。スウィフトコードは、条件コンパイルブロックを使って条件付きコンパイルされることができます。例えば、あなたが下記のコードをswift -D DEBUG_LOGGINGを使ってコンパイルしてDEBUG_LOGGING条件コンパイルフラグを設定するならば、コンパイラはそのコードを条件コンパイルブロックの本文の中に含めます。

        #if DEBUG_LOGGING
print("Flag enabled.")
#endif

      

A compilation condition can include the literal true and false values, custom conditional compilation flags (specified using -D <#flag#>), and the platform conditions listed in the table below.
コンパイル条件は、リテラルのtrueとfalse値、誂えの条件コンパイルフラグ（-D <#flag#>を使って指定される）、そして以下の表で一覧にされるプラットホーム条件を含むことができます、


Platform condition プラットホーム条件	Valid arguments 有効な引数
`os()`	`macOS`, `iOS`, `watchOS`, `tvOS`, `Linux`
`arch()`	`i386`, `x86_64`, `arm`, `arm64`
`swift()`	`>=` followed by a version number `>=`にバージョン番号が続きます
`canImport()`	A module name １つのモジュール名
`targetEnvironment()`	`simulator`

For information about platform conditions, see Conditional Compilation Block in The Swift Programming Language (Swift 4.1).
プラットホーム条件についての情報として、条件コンパイルブロックをスウィフトプログラミング言語 (Swift 4.1)で見てください。

You can combine compilation conditions using the && and || operators, negate them with the ! operator, and add branches with #elseif and #else compilation directives. You can also nest conditional compilation blocks within other conditional compilation blocks.
あなたは、コンパイル条件を&&と||を使って結合すること、!演算子でそれらを無効にすること、そして#elseifと#else条件指示子で分岐を加えることができます。あなたはまた、条件コンパイルブロックを他の条件コンパイルブロックの内部に入れ子にすることができます。

        #if arch(arm) || arch(arm64)
#if swift(>=3.0)
print("Using Swift 3 ARM code")
    #else
    print("Using Swift 2.2 ARM code")
#endif
#elseif arch(x86_64)
print("Using 64-bit x86 code.")
#else
print("Using general code.")
#endif

      

In contrast with condition compilation in the C preprocessor, conditional compilation blocks in Swift must completely surround blocks of code that are self-contained and syntactically valid. This is because all Swift code is syntax checked, even when it is not compiled. However, there is an exception if the compilation condition includes a swift() platform condition: The statements are parsed only if the compiler’s version of Swift matches what is specified in the platform condition. This exception ensures that an older compiler doesn’t attempt to parse syntax introduced in a newer version of Swift.
Cプリプロセッサでの条件コンパイルと対照的に、スウィフトでの条件コンパイルブロックは、自給自足で統語論的に有効であるコードのブロックを完全に伴っていなければなりません。これは全てのスウィフトコードが、それがコンパイルされないときでも、構文チェックされるからです。しかしながら、例外があります、それはコンパイル条件がswift()プラットホーム条件を含む場合です：文はスウィフトのコンパイラのバージョンがプラットホーム条件において指定されるものと合致する場合にのみ構文解析されます。この例外は、古いコンパイラがより新しいバージョンのスウィフトで導入される構文の解析を試みないことを確実にします。

Interacting with C APIs C APIとの相互作用

Primitive Types 基本の型

Global Constants グローバルな定数

Imported Constant Enumerations and Structures インポートされる定数列挙と構造体

Functions 関数

Variadic Functions 可変長引数関数

Structures 構造体

Importing Functions as Type Members 関数を型メンバとしてインポートする

Enumerations 列挙

Option Sets オプションセット

Unions 共用体

Bit Fields ビットフィールド

Unnamed Structure and Union Fields 無名の構造体と共用体フィールド

Pointers ポインター

Constant Pointers 定数ポインター

Mutable Pointers 可変ポインター

Autoreleasing Pointers 自動解放ポインター

Function Pointers 関数ポインター

Buffer Pointers バッファポインタ

Null Pointers ヌルポインタ

Pointer Arithmetic ポインタ算術

Data Type Size Calculation データ型サイズ計算

One-Time Initialization ワンタイム初期化

Preprocessor Directives プリプロセッサ指令

Simple Macros 単純なマクロ

Complex Macros 複雑なマクロ

Conditional Compilation Blocks 条件コンパイルブロック

Interacting with C APIs
C APIとの相互作用

Primitive Types
基本の型

Global Constants
グローバルな定数

Imported Constant Enumerations and Structures
インポートされる定数列挙と構造体

Functions
関数

Variadic Functions
可変長引数関数

Structures
構造体

Importing Functions as Type Members
関数を型メンバとしてインポートする

Enumerations
列挙

Option Sets
オプションセット

Unions
共用体

Bit Fields
ビットフィールド

Unnamed Structure and Union Fields
無名の構造体と共用体フィールド

Pointers
ポインター

Constant Pointers
定数ポインター

Mutable Pointers
可変ポインター

Autoreleasing Pointers
自動解放ポインター

Function Pointers
関数ポインター

Buffer Pointers
バッファポインタ

Null Pointers
ヌルポインタ

Pointer Arithmetic
ポインタ算術

Data Type Size Calculation
データ型サイズ計算

One-Time Initialization
ワンタイム初期化

Preprocessor Directives
プリプロセッサ指令

Simple Macros
単純なマクロ

Complex Macros
複雑なマクロ

Conditional Compilation Blocks
条件コンパイルブロック