संरचना बनाम कक्षा तेज भाषा में

Question

Apple पुस्तक से "संरचनाओं और वर्गों के बीच सबसे महत्वपूर्ण अंतर यह है कि संरचनाओं को हमेशा तब कॉपी किया जाता है जब उन्हें आपके कोड में पास किया जाता है, लेकिन कक्षाओं को संदर्भ द्वारा पारित किया जाता है।"

क्या कोई मुझे यह समझने में मदद कर सकता है कि इसका क्या मतलब है? मेरे लिए, कक्षाएं और संरचनाएं समान हैं।

Comments

.NET में संरचना और वर्ग के बीच अंतर देखें: stackoverflow.com/a/13275/19100 , मैं अनुमान लगा रहा हूं कि स्विफ्ट एक ही शब्दार्थ का उपयोग करता है।

— dalle

@jonrsharpe आपके लिए आसान हो सकता है? क्या आप मुझे इसका उत्तर दे सकते हैं यदि आप यह जानते हैं

— मनीष अग्रवाल

मान बनाम संदर्भ OOP केवल अवधारणा नहीं है। यह सी में है, void my_func(int a)बनाम की तरह void my_func(int &a)। यह प्रोग्रामिंग का एक बहुत ही मौलिक प्रश्न है। और पढ़ें: stackoverflow.com/questions/373419/…

— superarts.org

Answer 1

यहाँ एक के साथ एक उदाहरण है class। ध्यान दें कि जब नाम बदला जाता है, तो दोनों चर द्वारा संदर्भित उदाहरण अपडेट किया जाता है। Bobअब Sue, हर जगह है Bobजिसे कभी संदर्भित किया गया था।

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

var aClass = SomeClass(name: "Bob")
var bClass = aClass // aClass and bClass now reference the same instance!
bClass.name = "Sue"

println(aClass.name) // "Sue"
println(bClass.name) // "Sue"

और अब structहम देखते हैं कि मूल्यों की नकल की जाती है और प्रत्येक चर मानों का अपना सेट रखता है। जब हम नाम को सेट करते हैं Sue, तो Bobसंरचना में aStructपरिवर्तन नहीं होता है।

struct SomeStruct {
    var name: String
    init(name: String) {
        self.name = name
    }
}

var aStruct = SomeStruct(name: "Bob")
var bStruct = aStruct // aStruct and bStruct are two structs with the same value!
bStruct.name = "Sue"

println(aStruct.name) // "Bob"
println(bStruct.name) // "Sue"

तो एक राज्य की जटिल इकाई का प्रतिनिधित्व करने के लिए, एक classबहुत बढ़िया है। लेकिन उन मूल्यों के लिए जो संबंधित डेटा के माप या बिट्स हैं, एक structअधिक समझ में आता है ताकि आप उन्हें आसानी से कॉपी कर सकें और उनके साथ गणना कर सकें या साइड इफेक्ट्स के डर के बिना मूल्यों को संशोधित कर सकें।

Comments

"लेकिन उन मूल्यों के लिए जो केवल एक संख्या से अधिक जटिल नहीं हैं ..." इस एलेक्स के लिए धन्यवाद

— माइक रैपादास

@MichaelRapadas संख्या वास्तव में कर रहे हैं स्विफ्ट में structs।

— निकोलाई रुहे

क्या आप इसे स्पष्ट कर सकते हैं aStruct and bStruct are two structs with the same value!क्योंकि यह मुझे भ्रमित करता है क्योंकि संरचना के अंदर चर के मूल्य अलग हैं।

— जूलियन क्राल

@ JulianKról एक पंक्ति aStructऔर bStructसमान मूल्य है। उन दोनों का एक ही nameक्षेत्र है जो निर्धारित है "Bob"। लेकिन वे दो अलग-अलग संरचनाएं हैं। यह अगली पंक्ति पर सिद्ध होता है जब आप किसी एक संरचना का नाम बदल सकते हैं, और दूसरा अपरिवर्तित रहता है।

— एलेक्स वेन

बस असाइनमेंट छूट गया। यह स्पष्ट है, धन्यवाद। शायद यह बाहर भी गर्म है :-)

— जूलियन क्राल

Answer 2

वर्ग और संरचना दोनों कर सकते हैं:

• मूल्यों को संग्रहीत करने के लिए गुणों को परिभाषित करें
• कार्यक्षमता प्रदान करने के तरीकों को परिभाषित करें
• विस्तार किया
• प्रोटोकॉल के अनुरूप
• इंटेलीजेंस को परिभाषित करें
• अपने चर तक पहुँच प्रदान करने के लिए सदस्यता को परिभाषित करें

केवल वर्ग ही कर सकता है:

• विरासत
• कास्टिंग टाइप करें
• डिनायस्टाइज़र को परिभाषित करें
• एकाधिक संदर्भों के लिए संदर्भ गिनती की अनुमति दें।

Answer 3

structमूल्य प्रकार हैं। इसका मतलब है कि यदि आप संरचना के उदाहरण को किसी अन्य चर में कॉपी करते हैं, तो यह सिर्फ चर की नकल है।

मूल्य प्रकार के लिए उदाहरण

struct Resolution {
    var width = 2
    var height = 3
}

let hd = Resolution(width: 1920, height: 1080)
var cinema = hd //assigning struct instance  to variable
println("Width of cinema instance is \(cinema.width)")//result is 1920
println("Width of hd instance is \(hd.width)")//result is 1920

cinema.width = 2048

println("Width of cinema instance is \(cinema.width)")//result is 2048
println("Width of hd instance is \(hd.width)")//result is 1920

कक्षाएं संदर्भ प्रकार हैं। इसका अर्थ है कि यदि आप वर्ग के एक उदाहरण को एक चर में निर्दिष्ट करते हैं, तो यह केवल उदाहरण के संदर्भ में होगा और प्रतिलिपि नहीं ।

Comments

+1 के लिए "यदि आप किसी अन्य चर के लिए कक्षा का एक उदाहरण निर्दिष्ट करते हैं, तो यह केवल उस उदाहरण का संदर्भ रखेगा जो प्रतिलिपि नहीं है।"

— सैफ

Answer 4

उपरोक्त उत्तर सही हैं, मुझे आशा है कि मेरा उत्तर किसी ऐसे व्यक्ति की मदद करेगा जो उत्तर के ऊपर नहीं समझता है।

वैसे स्विफ्ट में दो तरह की वस्तुएं होती हैं

1. struct
2. कक्षा

उनके बीच मुख्य अंतर है

• संरचना मूल्य प्रकार है
• क्लास रेफरेंस टाइप है

उदाहरण के लिए यहाँ कोड को अच्छी तरह से समझना है।

struct SomeStruct {
var a : Int;

init(_ a : Int) {
    self.a = a
}
}

class SomeClass {
var a: Int;

init(_ a: Int) {
    self.a = a
}

}
var x = 11

var someStruct1 = SomeStruct(x)
var someClass1 = SomeClass(x)

var someStruct2 = someStruct1
var someClass2 = someClass1

someClass1.a = 12
someClass2.a // answer is 12 because it is referencing to class 1     property a

someStruct1.a = 14
someStruct2.a // answer is 11 because it is just copying it not referencing it

यह मुख्य अंतर था लेकिन हमारे पास उप अंतर भी हैं।

कक्षा

1. आरंभिक (निर्माणकर्ता) घोषित करना चाहिए
2. डिनायस्टिलेटर हैं
3. अन्य वर्गों से विरासत में मिल सकता है

struct

1. यह आपके लिए मुफ्त इनिलाइज़र है, आपको न तो इनिलाइज़र की घोषणा करनी है, यदि आप निशुल्क ऐनिलाइज़र को अपने घोषित सलाहकार द्वारा अधिलेखित कर देंगे
2. न ही डेनिएशिटाइज़र है
3. अन्य संरचना से विरासत में नहीं मिल सकता है

Answer 5

यह प्रश्न डुप्लिकेट प्रतीत होता है, लेकिन इसकी परवाह किए बिना, निम्नलिखित उपयोग के अधिकांश मामलों का जवाब देगा:

1. संरचनाओं और वर्गों के बीच सबसे महत्वपूर्ण अंतर यह है कि संरचनाएं मूल्य प्रकार हैं और हमेशा तब कॉपी की जाती हैं जब उन्हें आपके कोड में पास किया जाता है, और कक्षाएं संदर्भ प्रकार होती हैं और संदर्भ द्वारा पारित की जाती हैं।

2. इसके अलावा, कक्षाओं में वंशानुक्रम होता है जो एक वर्ग को दूसरे की विशेषताओं को प्राप्त करने की अनुमति देता है।

3. स्टैक पर संरचना गुण संग्रहीत किए जाते हैं और वर्ग उदाहरण हीप पर संग्रहीत होते हैं, इसलिए कभी-कभी स्टैक एक वर्ग की तुलना में तेजी से होता है।

4. संरचना को स्वचालित रूप से एक डिफ़ॉल्ट इनिशियलाइज़र मिल जाता है जबकि कक्षा में, हमें इनिशियलाइज़ करना होता है।

5. संरचना किसी भी समय थ्रेड सेफ या सिंगलटन है।

और साथ ही, संरचना और वर्गों के बीच अंतर को संक्षेप में प्रस्तुत करने के लिए, मूल्य और संदर्भ प्रकारों के बीच के अंतर को समझना आवश्यक है।

1. जब आप एक मूल्य प्रकार की एक प्रतिलिपि बनाते हैं, तो यह उस चीज़ से सभी डेटा की प्रतिलिपि बनाता है जिसे आप नए चर में कॉपी कर रहे हैं। वे 2 अलग चीजें हैं और एक को बदलना दूसरे को प्रभावित नहीं करता है।
2. जब आप किसी संदर्भ प्रकार की प्रतिलिपि बनाते हैं, तो नया चर उसी मेमोरी लोकेशन को संदर्भित करता है जिस चीज को आप कॉपी कर रहे हैं। इसका मतलब है कि एक को बदलने से दूसरे में बदलाव आएगा क्योंकि वे दोनों एक ही मेमोरी लोकेशन को संदर्भित करते हैं। नीचे दिए गए नमूना कोड को संदर्भ के रूप में लिया जा सकता है।

// sampleplayground.playground

  class MyClass {
        var myName: String
        init(myName: String){
            self.myName = myName;
        }
    }

    var myClassExistingName = MyClass(myName: "DILIP")
    var myClassNewName = myClassExistingName
    myClassNewName.myName = "John"


    print("Current Name: ",myClassExistingName.myName)
    print("Modified Name", myClassNewName.myName)

    print("*************************")

    struct myStruct {
        var programmeType: String
        init(programmeType: String){
            self.programmeType = programmeType
        }
    }

    var myStructExistingValue = myStruct(programmeType: "Animation")
    var myStructNewValue = myStructExistingValue
    myStructNewValue.programmeType = "Thriller"

    print("myStructExistingValue: ", myStructExistingValue.programmeType)
    print("myStructNewValue: ", myStructNewValue.programmeType)

आउटपुट:

Current Name:  John
Modified Name John
*************************
myStructExistingValue:  Animation
myStructNewValue:  Thriller

Comments

हाय दिलीप, क्या आप किसी भी समय "स्ट्रक्चर थ्रेड सेफ या सिंगलटन के लिए एक उदाहरण दे सकते हैं।" अग्रिम में धन्यवाद।

— नरसिम्हा नल्लमसेट्टी

Answer 6

यदि आप सेब हैंडबुक में आगे देखते हैं, तो आप इस खंड को देखेंगे: "संरचनाएं और गणना मूल्य प्रकार हैं"

इस भाग में आप इसे देखेंगे:

"चलो HD = रिज़ॉल्यूशन (चौड़ाई: 1920, ऊंचाई: 1080) var सिनेमा = एचडी यह उदाहरण एक निरंतर एचडी घोषित करता है और इसे रिज़ॉल्यूशन पर सेट करता है। उदाहरण पूर्ण HD वीडियो की चौड़ाई और ऊंचाई (1080 पिक्सेल उच्च द्वारा 1920 पिक्सेल चौड़ा) के साथ आरंभीकृत।

यह तब सिनेमा नामक एक चर घोषित करता है और इसे एचडी के वर्तमान मूल्य पर सेट करता है। क्योंकि रिज़ॉल्यूशन एक संरचना है, मौजूदा उदाहरण की एक प्रति बनाई गई है, और यह नई प्रतिलिपि सिनेमा को दी गई है। भले ही एचडी और सिनेमा की अब एक ही चौड़ाई और ऊंचाई है, लेकिन वे पर्दे के पीछे दो पूरी तरह से अलग उदाहरण हैं।

इसके बाद, सिनेमा की चौड़ाई संपत्ति को डिजिटल सिनेमा प्रक्षेपण (2048 पिक्सेल चौड़ा और 1080 पिक्सेल उच्च) के लिए उपयोग किए जाने वाले थोड़े-चौड़े 2K मानक की चौड़ाई में संशोधन किया गया है:

सिनेमा। चौड़ाई = 2048 सिनेमा की चौड़ाई की संपत्ति की जाँच से पता चलता है कि यह वास्तव में 2048 में बदल गया है:

Println ("सिनेमा अब है (सिनेमा। चौड़ाई) पिक्सेल चौड़ा") // प्रिंट "सिनेमा अब 2048 पिक्सेल चौड़ा है, हालांकि, मूल HD उदाहरण की चौड़ाई संपत्ति अभी भी पुरानी है 1920 का मूल्य:

Println ("HD अभी भी (एचडी। चौड़ाई) पिक्सेल चौड़ा है") // प्रिंट "HD अभी भी 1920 पिक्सेल चौड़ा है"

जब सिनेमा को एचडी का वर्तमान मूल्य दिया गया था, तो एचडी में संग्रहीत मूल्यों को नए सिनेमा उदाहरण में कॉपी किया गया था। अंतिम परिणाम दो पूरी तरह से अलग उदाहरण हैं, जो सिर्फ एक ही संख्यात्मक मानों के लिए हुआ है। क्योंकि वे अलग-अलग उदाहरण हैं, सिनेमा की चौड़ाई 2048 तक सेट करने से HD में संग्रहीत चौड़ाई प्रभावित नहीं होती है। ”

इसके अंश: Apple Inc. "स्विफ्ट प्रोग्रामिंग लैंग्वेज।" iBooks। https://itun.es/us/jEUH0.l

यह संरचना और वर्गों के बीच सबसे बड़ा अंतर है। संरचनाओं की नकल की जाती है और कक्षाओं को संदर्भित किया जाता है।

Answer 7

आमतौर पर (अधिकांश प्रोग्रामिंग भाषाओं में), ऑब्जेक्ट डेटा के ब्लॉक होते हैं जो ढेर पर संग्रहीत होते हैं, और फिर इन ब्लॉकों के लिए एक संदर्भ (सामान्य रूप से एक पॉइंटर) होता है, जिसमें nameडेटा के इन ब्लॉकों को एक्सेस करने के लिए उपयोग किया जाता है। यह तंत्र उनके संदर्भों (पॉइंटर्स) के मूल्य को कॉपी करके ढेर में वस्तुओं को साझा करने की अनुमति देता है। यह मूल डेटा प्रकार जैसे कि इंटेगर के मामले में नहीं है, और ऐसा इसलिए है क्योंकि संदर्भ बनाने के लिए आवश्यक मेमोरी लगभग ऑब्जेक्ट (इस मामले में पूर्णांक मान) के समान है। इस प्रकार, उन्हें बड़ी वस्तुओं के मामले में संदर्भ के रूप में नहीं मूल्यों के रूप में पारित किया जाएगा।

String और Array ऑब्जेक्ट्स के साथ भी प्रदर्शन को बेहतर बनाने के लिए Swift संरचना का उपयोग करता है।

वास्तव में यहाँ अच्छा पढ़ना

Answer 8

संरचना और वर्गों के बीच के अंतर को समझने के लिए, हमें मूल्य और संदर्भ प्रकारों के बीच मुख्य अंतर को जानना होगा। संरचनाएं मूल्य प्रकार हैं और इसका मतलब है कि उन पर हर परिवर्तन बस उस मूल्य को संशोधित करेगा, कक्षाएं संदर्भ प्रकार हैं और संदर्भ प्रकार में हर परिवर्तन स्मृति या संदर्भ के उस स्थान में आवंटित मूल्य को संशोधित करेगा। उदाहरण के लिए:

चलिए एक कक्षा से शुरू करते हैं, यह वर्ग इक्विटेबल के अनुरूप है बस उदाहरणों की तुलना करने में सक्षम होने के लिए, हम एक उदाहरण बनाते हैं जिसे pointClassInstanceAअन्य कहा जाता है जिसे pointClassInstanceBहम कक्षा A से कक्षा B में असाइन करते हैं, अब यह कहता है कि वे समान हैं ...

class PointClass: Equatable {
    var x: Double
    var y: Double

    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }

    static func == (lhs: PointClass, rhs: PointClass) -> Bool {
        return lhs.x == rhs.x && lhs.y == rhs.y
    }
}

var pointClassInstanceA = PointClass(x: 0, y: 0)
var pointClassInstanceB = pointClassInstanceA

assert(pointClassInstanceA==pointClassInstanceB) 

pointClassInstanceB.x = 10
print(pointClassInstanceA.x)
//this prints 10

ठीक है, यहाँ क्या हुआ क्यों अगर हमने बस पॉइंट्स के x मान को बदल दिया। ठीक है, यह दिखाता है कि संदर्भ ए कैसे काम करता है, जब हम उदाहरण ए को असाइन करते हैं, उदाहरण बी के मूल्य के रूप में और फिर हम उनमें से एक एक्स को संशोधित करते हैं यह दोनों एक्स को बदल देगा क्योंकि वे एक ही संदर्भ साझा करते हैं और जो बदल गया था, उसका मूल्य था संदर्भ।

चलो एक ही करते हैं लेकिन एक संरचना के साथ

struct PointStruct: Equatable {
    var x: Double
    var y: Double

    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }

    static func == (lhs: PointStruct, rhs: PointStruct) -> Bool {
        return lhs.x == rhs.x && lhs.y == rhs.y
    }
}
var pointStructInstanceA = PointStruct(x: 0, y: 0)
var pointStructInstanceB = pointStructInstanceA

assert(pointStructInstanceA==pointStructInstanceB)
pointStructInstanceB.x = 100
print(pointStructInstanceA.x)
//this will print 0

हमारे पास मूल रूप से हमारी कक्षा के समान संरचना है, लेकिन अब आप देख सकते हैं कि जब आप पॉइंटस्ट्रोक्टइनस्टेंस ए के एक्स मान को प्रिंट करते हैं तो यह मामला नहीं बदला, और इसका कारण यह है कि मूल्य प्रकार अलग-अलग तरीके से काम करते हैं और उनके प्रत्येक उदाहरण पर प्रत्येक परिवर्तन होगा " स्वतंत्र "और दूसरे को प्रभावित नहीं करेगा।

स्विफ्ट अधिक मूल्य प्रकारों का उपयोग करने का सुझाव देता है और आप बता सकते हैं कि उनके पुस्तकालय उन मुद्दों से बचने के लिए संरचनाओं पर आधारित हैं जो संदर्भ प्रकार लाते हैं, जैसे अनजाने में एक मूल्य आदि को संशोधित करना। संरचना स्विफ्ट पर जाने का तरीका है। आशा करता हूँ की ये काम करेगा।

Answer 9

यहाँ एक उदाहरण है जो संरचना और वर्ग के बीच के अंतर को ठीक दिखाता है।

खेल के मैदान में लिखित कोड का स्क्रीनशॉट

struct Radio1{
    var name:String
    //    init(name:String) {
    //        self.name = name
    //    }
}

struct Car1{
    var radio:Radio1?
    var model:String

}

var i1 = Car1(radio: Radio1(name:"murphy"),model:"sedan")
var i2 = i1
//since car instance i1 is a struct and 
//this car has every member as struct ,
//all values are copied into i2

i2.radio?.name //murphy
i2.radio = Radio1(name: "alpha")
i2.radio?.name //alpha

i1.radio?.name //murphy

//since Radio1 was struct , 
//values were copied and thus
// changing name  of instance of Radio1 in i2 
//did not bring change in i1

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

struct Car2{
    var radio:Radio2?
    var model:String

}
var i3 = Car2(radio: Radio2(name:"murphy"),model:"sedan")
//var radioInstance = Radio2(name: "murphy")
//var i3 = Car2(radio: radioInstance,model:"sedan")

var i4 = i3
//since i3 is instance of struct
//everything is copied to i4 including reference of instance of Radio2
//because Radio2 is a class



i4.radio?.name //murphy
i4.radio?.name="alpha"
i4.radio?.name //alpha

i3.radio?.name //alpha

//since Radio2 was class, 
//reference was copied and 
//thus changing name of instance 
//of Radio2 in i4 did  bring change in i3 too


//i4.radio?.name
//i4.radio = Radio2(name: "alpha")
//i4.radio?.name
//
//i3.radio?.name

Answer 10

1.structure is value type.
   = > when we assign structure variable to other variable or pass as parameter to function, it creates separate/new copy => so that changes made on one variable does not  reflect on another.[We can say like **call by value** concept] 
Example :

    struct DemoStruct 
    { 
        var value: String 
        init(inValue: String) 
        { 
            self.value = inValue 
        } 
    } 


var aStruct = DemoStruct(inValue: "original") 
var bStruct = aStruct // aStruct and bStruct are two structs with the same value! but references to diff location`enter code here`
bStruct.value = "modified" 

print(aStruct.value) // "original" 
print(bStruct.value) // "modified"


2.class is reference type.
 = > when we assign structure variable to other variable or pass as parameter to function, it **does not** creates separate/new copy => so that changes made on one variable does not  reflect on another.[We can say like **call by reference** concept] 
Example:
class DemoClass 
{   
    var value: String 
    init(inValue: String) 
    {
        self.value = inValue 
    } 
} 

var aClass = DemoClass(inName: "original") 
var bClass = aClass // aClass and bClass now reference the same instance! 
bClass.value = "modified" 

print(aClass.value) // "modified" 
print(bClass.value) // "modified"

Answer 11

स्विफ्ट प्रकार

Value type एक प्रकार है जिसका मान किसी वैरिएबल या कंटीन्यू को असाइन किए जाने पर, या जब इसे किसी फंक्शन में पास किया जाता है, तब कॉपी किया जाता है

Reference types जब वे एक चर या स्थिर करने के लिए असाइन किए गए हैं, या जब वे एक समारोह में पारित कर रहे हैं नकल नहीं कर रहे हैं

मूल्य प्रकार :
Struct, Enum, Tuple
struct String, struct Array( Set, Dictionary)

• जब आप डेटा की एक नई प्रतिलिपि बनाते या पास करते हैं, तो वह बनाई जाती है। वास्तव में - तंत्र का उपयोग कुछ अनुकूलन के साथ किया जाता है, उदाहरण के लिए प्रतिलिपि बनाई जाती है जब ऑब्जेक्ट को संशोधित किया जाता हैvalue typecopy on writeCOW
• जब आप एक उदाहरण को संशोधित करते हैं तो इसका केवल स्थानीय प्रभाव होता है।
• ढेर मेमोरी प्रयोग किया जाता है।

संदर्भ प्रकार :
Class,Function

• जब आप reference typeएक नया संदर्भ देते हैं या पास करते हैं तो मूल उदाहरण बनाया जाएगा (उदाहरण का पता कॉपी किया गया है)।
• जब आप एक उदाहरण को संशोधित करते हैं तो इसका वैश्विक प्रभाव पड़ता है क्योंकि यह उदाहरण किसी भी संदर्भ द्वारा साझा और सुलभ है जो उस पर इंगित करता है।
• ढेर मेमोरी प्रयोग किया जाता है।

Value typeडिफ़ॉल्ट रूप से उपयोग करने की अनुशंसा की जाती है । इसका सबसे बड़ा फायदा Value typeयह है कि आमतौर पर वे होते हैंthread safe

Reference type पेशेवरों:

• उन्हें विरासत में मिला जा सकता है,
• deinit() इस्तेमाल किया जा सकता है,
• संदर्भ द्वारा उदाहरणों की तुलना करें ===,
• Objective-Cअंतरप्रवाह क्योंकि Value Typeस्विफ्ट में पेश किया गया था।

[अधिक के बारे में अस्थिरता]
संरचनाएं और वर्गों के बीच चयन
प्रकार
वर्ग और संरचनाएं

Answer 12

इसके बारे में बहुत कुछ लिखा है, मैं वहां एक सादृश्य जोड़ना चाहूंगा। आशा है कि इसके बाद आपके मन में कभी संदेह नहीं होगा: निचला रेखा: कक्षाएं संदर्भ द्वारा पारित की जाती हैं, जबकि संरचना मूल्य द्वारा पारित की जाती हैं।

मान लीजिए आप अपने दोस्त के साथ एक Google डॉक्स शीट साझा कर रहे हैं। अब यदि वह इसमें कुछ भी बदलता है, तो आप यह भी देखेंगे कि आपके Google डॉक्स पर परिवर्तन का मतलब है कि आपकी कॉपी भी प्रभावित है। यह मूल रूप से " संदर्भ द्वारा पारित " है।

लेकिन मान लीजिए, अगर आपके पास .XLS fie आपकी मशीन में सेव है। आप अपने मित्र को वह फ़ाइल दें। अब अगर वह उस फाइल में कोई बदलाव कर रहा है, तो आपकी फाइल गड़बड़ / प्रभावित नहीं होगी क्योंकि आपके पास अपनी कॉपी है। यह मूल रूप से " मूल्य से पारित " है। स्विफ्ट खेल के मैदानों में इस सादृश्य की जांच के लिए आपके पास पहले से ही कई सरल कार्यक्रम हैं।