Swiftで理解する!値渡しの方法15選

Swiftのロゴとコードのスクリーンショット。値渡しを学ぶ初心者向けの解説記事Swift
この記事は約23分で読めます。

 

【サイト内のコードはご自由に個人利用・商用利用いただけます】

この記事では、プログラムの基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

基本的な知識があればカスタムコードを使って機能追加、目的を達成できるように作ってあります。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を凌駕する現役のプログラマチームによって監修されています。

サイト内のコードを共有する場合は、参照元として引用して下さいますと幸いです

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

はじめに

Swiftのプログラミング言語を学び始めた際、多くの初心者が「値渡し」という概念に戸惑うことが少なくありません。

しかし、この概念はプログラムの動作を深く理解する上で非常に重要です。

この記事を読めば、Swiftでの値渡しを正確に理解し、実装することができるようになります。

値渡しは、変数やデータを関数やメソッドに渡す際の方法の一つです。

Swiftでは、この値渡しを効果的に使用することで、プログラムの動作を安定させ、バグの発生を防ぐことができます。

●Swiftと値渡しの基本

○値渡しとは

値渡しは、変数の実際の値をコピーして、そのコピーを関数やメソッドに渡す方法を指します。

これにより、関数やメソッド内で値が変更されても、元の変数の値は変わらないという特徴があります。

Swiftの基本的なデータ型であるInt、Double、Stringなどは、デフォルトで値渡しとなります。

これは、関数やメソッドにこれらのデータ型を渡した場合、元のデータには影響を与えず、関数内での操作が行われるということを意味します。

例えば、ある整数変数があり、その変数を関数に渡して、関数内でその変数の値を変更したとしても、関数外の変数の値は変わらないという特性があります。

○参照渡しとの違い

参照渡しは、変数のアドレスや参照を直接関数やメソッドに渡す方法を指します。

これにより、関数やメソッド内で値が変更されると、元の変数の値も変わってしまいます。

Swiftでは、クラスは参照型として扱われるため、クラスのインスタンスを関数やメソッドに渡すと、参照渡しとなります。

これは、関数内でクラスのインスタンスのプロパティを変更した場合、元のインスタンスのプロパティも変わってしまうことを意味します。

値渡しと参照渡しの違いを正確に理解することで、プログラムの動作やデータの扱いに関するミスを避けることができます。

特にSwiftでは、構造体(値型)とクラス(参照型)の使い分けが重要となるため、これらの違いをしっかりと把握しておくことが求められます。

●値渡しの使い方

Swiftでは、多くのデータ型がデフォルトで値渡しをサポートしています。

これにより、変数や定数の値を他の関数やメソッドに安全に渡すことができます。

ここでは、Swiftでの値渡しの基本的な使い方を、具体的なサンプルコードとともに解説します。

○サンプルコード1:基本的な値渡しの実装

Swiftの基本的なデータ型、例えばIntやStringは、関数やメソッドに渡される際、自動的にその値がコピーされます。

下記のサンプルコードは、整数を関数に渡し、関数内でその値を変更するシンプルな例です。

func modifyValue(_ x: Int) -> Int {
    return x + 10
}

var number = 5
let result = modifyValue(number)

print(number)  // 5
print(result)  // 15

このコードではmodifyValue関数を使ってnumberの値に10を加算しています。

しかし、関数内での変更はnumberの元の値に影響を与えません。

そのため、numberは5のままで、resultには15が格納される結果となります。

○サンプルコード2:関数の引数としての値渡し

Swiftの関数の引数はデフォルトで定数として扱われるため、関数内での変更は不可能です。

しかし、値渡しの性質を利用して、新しい値を返すことで間接的に値の変更を行うことができます。

ここでは、文字列を引数として受け取り、その文字列に特定の文字を追加して返す関数の例を紹介します。

func addHello(to name: String) -> String {
    return "Hello, \(name)!"
}

let originalName = "Taro"
let greetedName = addHello(to: originalName)

print(originalName)  // Taro
print(greetedName)   // Hello, Taro!

上記のコードを実行すると、originalNameの値は変更されず、greetedNameには新しい文字列が格納される結果となります。

これは、addHello関数が引数の値を直接変更せず、新しい値を生成して返しているためです。

○サンプルコード3:配列の中の要素を値渡しで変更

Swiftの配列も基本的には値渡しに基づいています。しかし、配列の要素を変更する場合、どのように動作するのでしょうか。

下記のコードは、配列の特定の要素に対して変更を加えるシンプルな例です。

func modifyElement(of array: [Int], at index: Int) -> [Int] {
    var mutableArray = array
    mutableArray[index] += 5
    return mutableArray
}

let originalNumbers = [10, 20, 30, 40, 50]
let modifiedNumbers = modifyElement(of: originalNumbers, at: 2)

print(originalNumbers) // [10, 20, 30, 40, 50]
print(modifiedNumbers) // [10, 20, 35, 40, 50]

このコードを確認すると、modifyElement関数は与えられた配列の指定されたインデックスの要素を5増加させます。

しかし、関数内での変更はoriginalNumbers配列自体に影響を与えません。

これは、mutableArrayarrayのコピーとして作成されているためです。

したがって、originalNumbersは元の値のままで、modifiedNumbersには変更後の新しい配列が格納されます。

○サンプルコード4:構造体とクラスの比較

Swiftでは、構造体は値渡し、クラスは参照渡しで動作することが一般的に知られています。

では、この2つのデータ型を具体的に比較して、その違いを理解しましょう。

struct ValuePerson {
    var name: String
}

class ReferencePerson {
    var name: String

    init(name: String) {
        self.name = name
    }
}

var valueJohn = ValuePerson(name: "John")
var referenceJohn = ReferencePerson(name: "John")

let valueCopy = valueJohn
let referenceCopy = referenceJohn

valueCopy.name = "Johnny"
referenceCopy.name = "Johnny"

print(valueJohn.name)       // John
print(referenceJohn.name)  // Johnny

上記のコードでは、ValuePersonReferencePersonの2つのデータ型を定義しています。

valueJohnvalueCopyは同じValuePerson型のインスタンスを持っていますが、それぞれの名前を変更すると、それらは独立して変更されます。

一方で、referenceJohnreferenceCopyReferencePerson型の同じインスタンスを参照しているため、名前を変更すると、その変更は両方に影響します。

○サンプルコード5:コピーオンライトの動作確認

Swiftの配列や辞書などのコレクション型は、コピーオンライトという最適化技術を採用しています。

これは、データが変更されるまで実際のコピーが行われないという性質を持っています。

具体的にはどのように動作するのでしょうか。

var array1 = [1, 2, 3, 4, 5]
let array2 = array1

// この時点でのメモリアドレスの比較
print(array1 as AnyObject === array2 as AnyObject)  // true

array1[0] = 100

// ここでのメモリアドレスの比較
print(array1 as AnyObject === array2 as AnyObject)  // false

このコードでは、array1array2が同じメモリアドレスを参照していることが確認できます。

しかし、array1に変更を加えた際、新しいメモリアドレスにデータがコピーされ、それぞれの配列が異なるアドレスを参照するようになります。

これにより、効率的にメモリを使用しながら、期待通りの動作が得られるのです。

●値渡しの応用例

Swiftの値渡しは基礎的な使い方だけでなく、さまざまな応用例も存在します。

ここでは、構造体や配列、そして関数を使った値渡しの応用例を紹介します。

○サンプルコード6:構造体のメソッド内での値の変更

Swiftの構造体は値型であり、構造体のメソッド内でインスタンスのプロパティを変更することは基本的に許可されていません。

しかし、mutatingキーワードを使うことで、これを可能にすることができます。

struct Counter {
    var count = 0

    mutating func increment() {
        count += 1
    }
}

var myCounter = Counter()
myCounter.increment()
print(myCounter.count) // 1と表示される

このコードでは、Counterという構造体が定義されています。

incrementメソッドを使って、countプロパティの値を増やすことができます。

mutatingキーワードがあることで、構造体のメソッド内でプロパティの値を変更できるようになっています。

○サンプルコード7:複数の変数と配列の組み合わせ

複数の変数や配列を組み合わせて、値渡しの特性を活かす方法も考えられます。

ここでは、配列の中の特定の要素と他の変数との計算を行う例を紹介します。

func calculateTotal(scores: [Int], bonus: Int) -> [Int] {
    return scores.map { $0 + bonus }
}

let examScores = [70, 80, 90]
let bonusPoint = 5
let newScores = calculateTotal(scores: examScores, bonus: bonusPoint)

print(examScores) // [70, 80, 90]と表示される
print(newScores)  // [75, 85, 95]と表示される

このコードでは、calculateTotal関数が配列scoresと整数bonusを受け取り、配列の各要素にボーナスポイントを加算して新しい配列を返しています。

関数内での変更は、元の配列examScoresには影響を与えず、新しい配列newScoresに変更後のデータが格納されます。

○サンプルコード8:クロージャとの組み合わせ

Swiftのクロージャは、関数のように動作するが、特定のコンテキストでキャプチャされた変数を保持する能力があります。

これにより、クロージャの中で値渡しの特性を活かす興味深い実装が可能となります。

例として、ある数値を増減させるクロージャを作成し、それを使用して値の変更を試みるシチュエーションを考えます。

func makeIncrementer(incrementAmount: Int) -> () -> Int {
    var total = 0
    return {
        total += incrementAmount
        return total
    }
}

let incrementByTwo = makeIncrementer(incrementAmount: 2)
print(incrementByTwo()) // 2と表示される
print(incrementByTwo()) // 4と表示される

このコードでは、makeIncrementer関数はクロージャを返しています。

返されるクロージャは、incrementAmountの量だけtotalを増やす動作を行います。

関数を実行するたびに、totalの値が更新され、その結果が返されるのです。

○サンプルコード9:値渡しと参照渡しの併用

Swiftでは、値渡しと参照渡しを適切に併用することで、より効果的なプログラムを構築することが可能です。

ここでは、構造体(値渡し)とクラス(参照渡し)を組み合わせて利用する例を紹介します。

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

struct Wallet {
    var owner: Person
    var amount: Int
}

let john = Person(name: "John")
let wallet = Wallet(owner: john, amount: 1000)

// クラスは参照渡し
john.name = "Johnny"

print(wallet.owner.name) // Johnnyと表示される

このコードでは、Personクラスが参照型として、Wallet構造体のプロパティとして利用されています。

johnインスタンスのnameプロパティを変更した後、walletownerプロパティを通じてその名前にアクセスすると、変更された名前が取得できることが確認できます。

これは、クラスが参照渡しであるため、そのインスタンスへの参照が共有されているからです。

○サンプルコード10:高階関数との連携

Swiftは関数型プログラミングの特性を持つため、高階関数の利用が可能です。

高階関数とは、関数を引数として受け取ったり、関数を結果として返したりする関数のことを指します。

これを値渡しと組み合わせることで、非常に強力なプログラミングが可能となります。

例として、配列の各要素に特定の操作を行いたい場合、map関数を使用することができます。

// 数値の配列を定義
let numbers = [1, 2, 3, 4, 5]

// 各要素を2倍にする
let doubledNumbers = numbers.map { $0 * 2 }

print(doubledNumbers) // [2, 4, 6, 8, 10] と表示される

このコードのmap関数は、与えられた配列numbersの各要素に対して、引数として与えられたクロージャを適用します。

この場合、各要素を2倍にするクロージャが適用され、結果として2倍された新しい配列が生成されます。

○サンプルコード11:メモリ効率を考慮した実装例

Swiftの値渡しは便利である一方、大きなデータを扱う場合、メモリの効率的な利用を考慮する必要があります。

特に、大量のデータをコピーする場面では、不必要なメモリの使用を避けるための工夫が求められます。

例として、大量のデータを持つ配列をコピーして操作する場面を考えます。

struct LargeData {
    var data: [Int] = Array(repeating: 0, count: 1000000)
}

var originalData = LargeData()
let copiedData = originalData  // 値渡しでデータがコピーされる

originalData.data[0] = 1

print(copiedData.data[0]) // 0 と表示される

このコードでは、LargeData構造体に大量のデータを持つ配列を定義しています。

この構造体のインスタンスをコピーすると、実際にはデータの実体はコピーされず、必要となるまでオリジナルのデータが参照されます(コピーオンライト)。

したがって、originalDataを変更しても、copiedDataは変更されていないことが確認できます。

これにより、大量のデータを効率的に扱うことが可能となります。

○サンプルコード12:ライブラリやフレームワークでの応用

Swiftでのプログラミングにおいて、多くのライブラリやフレームワークが提供されています。

これらのツールを使用する際にも、値渡しの概念は非常に重要です。

特に、データの安全性や効率的な処理のために、適切な渡し方を理解しておく必要があります。

例として、Swiftで人気のあるデータ処理ライブラリであるAlamofireを使用した際の応用例を見てみましょう。

import Alamofire

struct UserData {
    var name: String
    var age: Int
}

func fetchUserData(completion: @escaping (UserData) -> Void) {
    AF.request("https://api.example.com/user").responseJSON { response in
        if let data = response.data {
            let json = try? JSON(data: data)
            let user = UserData(name: json?["name"].string ?? "", age: json?["age"].int ?? 0)
            completion(user)  // 値渡しでデータを返す
        }
    }
}

fetchUserData { user in
    print(user.name)
    print(user.age)
}

このコードでは、ネットワークリクエストを行い、取得したJSONデータをUserData構造体に変換しています。

そして、そのデータをクロージャを通じて値渡しで返しています。

このように、ライブラリやフレームワークを使用する際にも、データを安全に、そして効率的に扱うために、値渡しの方法を適切に適用することが重要です。

○サンプルコード13:デザインパターンとの組み合わせ

デザインパターンは、ソフトウェア設計において再利用可能な解決策を提供するものです。

Swiftでも、多くのデザインパターンが利用されています。

ここでは、値渡しを活用したデザインパターンの一例として、Prototypeパターンを紹介します。

Prototypeパターンは、オブジェクトのコピーを生成するためのパターンです。

Swiftの値型を利用することで、このパターンは非常に簡単に実装することができます。

struct Car {
    var make: String
    var model: String
    var year: Int

    func clone() -> Car {
        return self  // 値渡しで自身のコピーを返す
    }
}

let originalCar = Car(make: "Toyota", model: "Corolla", year: 2020)
let clonedCar = originalCar.clone()

print(clonedCar.make)  // Toyota
print(clonedCar.model) // Corolla
print(clonedCar.year)  // 2020

上記のコードでは、Car構造体にcloneメソッドを実装し、その中で自身のコピーを値渡しで返しています。

このように、Swiftの値型を活用することで、デザインパターンの中でも簡潔に、そして効率的に実装を行うことができます。

○サンプルコード14:非同期処理との連携

Swiftにおいて非同期処理は、ユーザー体験を向上させるために重要な役割を果たしています。

特に、重いタスクやネットワークリクエストをバックグラウンドで実行し、UIをブロックすることなくタスクを完了することが求められます。

ここでは、非同期処理と値渡しの連携について考察します。

例えば、非同期的にデータを取得し、その結果をメインスレッドで取り扱うシチュエーションを想定します。

このとき、非同期タスクが完了したら、その結果をメインスレッドに値渡しで返す方法を学びましょう。

import Foundation

struct WeatherData {
    var temperature: Double
    var condition: String
}

func fetchWeatherData(completion: @escaping (WeatherData) -> Void) {
    DispatchQueue.global().async {
        // ここでネットワークリクエストやデータベース処理を想定
        let data = WeatherData(temperature: 23.5, condition: "晴れ")

        DispatchQueue.main.async {
            completion(data)  // 主要なスレッドで値渡しを行う
        }
    }
}

fetchWeatherData { weather in
    print("気温: \(weather.temperature)℃")
    print("天気: \(weather.condition)")
}

このコードでは、fetchWeatherData関数を用いて非同期的にWeatherDataを取得しています。

取得したデータは、メインスレッドにて値渡しの方法で受け取られ、その後UIの更新などの処理が行われることを想定しています。

○サンプルコード15:エラーハンドリングを組み込んだ実例

Swiftでは、エラーハンドリングのための特別な機能が提供されています。

この機能を利用することで、値渡しと組み合わせたエラー処理を効率的に行うことができます。

例として、ネットワークリクエストを行い、その結果を取得する関数を考えます。

この関数は成功時にはデータを、失敗時にはエラーを返すとします。

enum NetworkError: Error {
    case urlError
    case dataError
}

func requestData(url: String, completion: @escaping (Result<String, NetworkError>) -> Void) {
    // ネットワークリクエストを模倣
    if url == "validURL" {
        completion(.success("取得したデータ"))
    } else {
        completion(.failure(.urlError))
    }
}

requestData(url: "invalidURL") { result in
    switch result {
    case .success(let data):
        print(data)
    case .failure(let error):
        switch error {
        case .urlError:
            print("URLが不正です。")
        case .dataError:
            print("データの取得に失敗しました。")
        }
    }
}

このコードを実行すると、”URLが不正です。”というメッセージが出力されることを期待しています。

ここでは、Result型を利用して、成功したデータやエラー情報を値渡しの形式で返しています。

●注意点と対処法

Swiftのプログラミングにおいて、特に値渡しを使用する際にはいくつかの注意点が存在します。

適切に対処しなければ、予期せぬエラーやパフォーマンスの低下を引き起こす可能性があるため、注意深く取り扱いを行うことが求められます。

○変数のオーバーヘッドとは

Swiftにおける変数の使用は非常に便利ですが、過度な使用や不適切な管理はオーバーヘッドを引き起こす可能性があります。

具体的には、不必要に多くの変数を生成することで、メモリ使用量が増加したり、CPUリソースを浪費することが考えられます。

func calculateSum(numbers: [Int]) -> Int {
    var total = 0  // 必要な変数のみを使用
    for number in numbers {
        total += number
    }
    return total
}

let result = calculateSum(numbers: [1, 2, 3, 4, 5])
print("合計値は \(result) です。")

上記のコードは、calculateSum関数を用いて配列内の数字の合計を計算しています。

この関数内で必要な変数のみを使用しているため、オーバーヘッドのリスクは低いです。

○コピーオンライトの落とし穴

Swiftにおいて、コピーオンライトは大変便利な機能ですが、不適切な使用は性能問題を引き起こす可能性があります。

特に、大量のデータを持つ配列や辞書などのコレクションに対して、頻繁にコピー操作を行う場合、予期せぬパフォーマンスの低下を引き起こすことがあります。

var numbers = [Int](repeating: 0, count: 10000)

func modifyArray(array: inout [Int]) {
    for i in 0..<array.count {
        array[i] = i
    }
}

modifyArray(array: &numbers)

上記のコードは、modifyArray関数を使用して10,000要素の配列を更新しています。

このような大量のデータを頻繁に更新する場合、コピーオンライトの性質上、予期せぬオーバーヘッドが発生することが考えられます。

○パフォーマンスへの影響

Swiftのコードを記述する際、特に高負荷な処理や頻繁に実行される部分では、パフォーマンスへの影響を常に意識する必要があります。

特に、値渡しを行う場面で大量のデータを頻繁にコピーすると、メモリの使用量やCPUリソースの消費が増大する恐れがあります。

適切な最適化や工夫を行うことで、これらの問題を避けることが可能です。

例えば、不要な変数の削除や適切なデータ構造の選択、メモリキャッシュの使用などが考えられます。

●カスタマイズ方法

Swiftにおける値渡しの実装は非常に柔軟で、多岐にわたるカスタマイズが可能です。

特に、構造体や拡張機能を駆使することで、より効率的でわかりやすいコードを書くことができます。

○構造体のカスタムイニシャライザ

構造体のイニシャライザをカスタマイズすることで、特定の初期化方法や条件を設定することが可能です。

例えば、特定の範囲の値のみを受け入れるようなイニシャライザを設定することが考えられます。

struct Point {
    var x: Int
    var y: Int

    init?(x: Int, y: Int) {
        if x < 0 || y < 0 {
            return nil  // 負の値は受け入れない
        }
        self.x = x
        self.y = y
    }
}

if let validPoint = Point(x: 5, y: 3) {
    print("有効なポイント: (\(validPoint.x), \(validPoint.y))")
}

このコードでは、Pointという構造体のイニシャライザをカスタマイズして、xやyの値が負の場合は無効としています。

このように、特定の条件下でのみ構造体を初期化することが可能となります。

○拡張機能を活用した値渡しのカスタマイズ

Swiftの拡張機能を活用することで、既存の型に新しいメソッドやプロパティを追加することができます。

これにより、特定の値渡しの処理を簡単に実装することが可能となります。

extension Int {
    func squared() -> Int {
        return self * self
    }
}

let number = 5
print("5の二乗は \(number.squared()) です。")

このコードでは、整数型にsquaredという新しいメソッドを追加しています。

このメソッドを使用すると、数字の二乗を簡単に計算することができます。

まとめ

Swiftでの値渡しは、初心者から上級者まで幅広く学ぶことができるトピックの一つです。

本記事を通して、その基本的な振る舞いから、より高度なカスタマイズ方法までを深堀りしました。

これらの知識は、Swiftでのプログラミングをより効果的かつ効率的に行うための鍵となります。

特に、構造体や拡張機能の活用は、Swiftの強力な特性を最大限に引き出す手段です。

これらを使いこなすことで、コードの可読性やメンテナンス性を高めることができます。