फंक्शन ओवरलोडिंग में

फंक्शन ओवरलोडिंग के बारे में

Swift में, आप एक ही नाम के कई फंक्शन बना सकते हैं, बशर्ते उनके सिग्नेचर अलग हों। इस तरीके को फंक्शन ओवरलोडिंग कहा जाता है।

नीचे दिए गए बेस फंक्शन को देखिए:

func add(_ x: Int, and y: Int, doubleResult: Bool) -> Int {
    let sum = x + y
    return doubleResult ? sum * 2 : sum
}

let twentySix = add(6, and: 7, doubleResult: true)
// => 26

Swift में, एक ही नाम के दो फंक्शन तब अलग माने जाते हैं जब इनमें से कोई एक शर्त पूरी हो:

• उनके पैरामीटर की संख्या अलग हो।
• उनके बाहरी आर्गुमेंट लेबल अलग हों।
• उनके पैरामीटर टाइप अलग हों।
• उनके रिटर्न टाइप अलग हों (बशर्ते कॉल करने का संदर्भ स्पष्ट कर दे कि किसका उपयोग करना है)।

ऊपर दिए गए मूल add फंक्शन को ध्यान में रखते हुए, नीचे दिए गए हर ओवरलोड अलग हैं और एक ही प्रोग्राम में मान्य हैं:

// 1. Different number of parameters
func add(_ x: Int, and y: Int) -> Int {
    x + y
}

let eleven = add(5, and: 6)
// => 11

// 2. Different parameter type (Double instead of Int)
func add(_ x: Double, and y: Int, doubleResult: Bool) -> Double {
    let sum = x + Double(y)
    return doubleResult ? sum * 2 : sum
}

let twentySeven = add(6.5, and: 7, doubleResult: true)
// => 27.0

// 3. Different argument label (doubleThat instead of doubleResult)
func add(_ x: Int, and y: Int, doubleThat: Bool) -> Int {
    let sum = x + y
    return doubleThat ? sum * 2 : sum
}

let thirteen = add(6, and: 7, doubleThat: false)
// => 13

रिटर्न टाइप के आधार पर ओवरलोडिंग

फंक्शन को केवल उनके रिटर्न टाइप के आधार पर भी ओवरलोड किया जा सकता है। लेकिन ऐसे फंक्शन को कॉल करते समय आपको टाइप एनोटेशन या संदर्भ देना होगा ताकि कंपाइलर जान सके कि आप कौन सा ओवरलोड चाहते थे:

func add(_ x: Int, and y: Int, doubleResult: Bool) -> Double {
    let sum = Double(x + y)
    return doubleResult ? sum * 2 : sum
}

// Ambiguous call (compiler cannot decide whether you want Int or Double):
// let thirty = add(6, and: 9, doubleResult: true)

// Resolved with an explicit type annotation:
let thirty: Double = add(6, and: 9, doubleResult: true)
// => 30.0

ओवरलोड को क्या अलग नहीं बनाता

सिर्फ आंतरिक पैरामीटर नाम बदलने से, बिना आर्गुमेंट लेबल, पैरामीटर टाइप या पैरामीटर संख्या बदले, कोई अलग फंक्शन नहीं बनता। कंपाइलर इसे अमान्य डुप्लिकेट घोषणा मानता है:

func add(_ w: Int, and y: Int, doubleResult: Bool) -> Int {
    let sum = w + y
    return doubleResult ? sum * 2 : sum
}
// Error: Invalid redeclaration of 'add(_:and:doubleResult:)'