प्रारंभिक और देर बाध्यकारी के बीच क्या अंतर है?

प्रारंभिक और देर से बाध्यकारी के बीच क्या अंतर है?

0
ro fr bn
जोड़ा लेखक jfs, स्रोत
प्रारंभिक और देर से बाध्यकारी का संभावित डुप्लिकेट
जोड़ा लेखक berkay, स्रोत
क्या मैं जल्दी = प्रत्यक्ष फ़ंक्शन कॉल कहने में गलत हूं, जबकि देर से = फ़ंक्शन पॉइंटर के माध्यम से कार्य करने के लिए कॉल करें? यह मुझे आश्चर्यचकित नहीं करता कि प्रोग्रामर के पास सरल अवधारणाएं लेने का तरीका होता है और उन्हें उनके मुकाबले ज्यादा जटिल लग रहा है (खुफिया कार्यक्रम के रूप में?)। प्रोग्रामिंग स्वाभाविक रूप से अध्ययन का एक बहुत ही आसान क्षेत्र है जब तक कि आप एक फ्लोट प्रकार कैसे बनाते हैं या कंपाइलर्स के विकास की तरह चीजों तक पहुंच जाते हैं।
जोड़ा लेखक Bob Blogge, स्रोत

7 उत्तर

संकलित भाषाओं में, अंतर स्थिर है।

जावा:

//early binding:
public create_a_foo(*args) {
 return new Foo(args)
}
my_foo = create_a_foo();

//late binding:
public create_something(Class klass, *args) {
  klass.new_instance(args)
}
my_foo = create_something(Foo);

In the first example, the compiler can do all sorts of neat stuff at compile time. In the second, you just have to hope that whoever uses the method does so responsibly. (Of course, newer JVMs support the Class<? extends Foo> klass structure, which can greatly reduce this risk.)

एक अन्य लाभ यह है कि आईडीई कक्षा परिभाषा को हॉटलिंक कर सकते हैं, क्योंकि इसे विधि में सही घोषित किया गया है। Create_something (Foo) के लिए कॉल विधि परिभाषा से बहुत दूर बहुत हो सकता है, और यदि आप विधि परिभाषा को देख रहे हैं, तो कार्यान्वयन को देखना अच्छा लगेगा।

देर से बाध्यकारी का मुख्य लाभ यह है कि यह चीजों को नियंत्रण में आसान बनाता है, साथ ही पॉलिमॉर्फिज्म और बतख-टाइपिंग के कुछ अन्य उपयोग (यदि आपकी भाषा ऐसी चीजों का समर्थन करती है) बनाता है।

0
जोड़ा

व्याख्या की गई भाषाओं में, अंतर थोड़ा और सूक्ष्म है।

माणिक:

# early binding:
def create_a_foo(*args)
  Foo.new(*args)
end
my_foo = create_a_foo

# late binding:
def create_something(klass, *args)
  klass.new(*args)
end
my_foo = create_something(Foo)

चूंकि रूबी (आमतौर पर) संकलित नहीं होती है, इसलिए निफ्टी अप-फ्रंट सामान करने के लिए एक कंपाइलर नहीं होता है। JRuby की वृद्धि का मतलब है कि इन दिनों अधिक रूबी संकलित किया गया है, हालांकि, यह ऊपर जावा की तरह अधिक कार्य करता है।

आईडीई के साथ समस्या अभी भी खड़ी है: ग्रहण की तरह एक प्लेटफॉर्म क्लास परिभाषाओं को देख सकता है यदि आप उन्हें हार्ड-कोड करते हैं, लेकिन यदि आप उन्हें कॉलर तक नहीं छोड़ सकते हैं।

रूबी में उलटा नियंत्रण बहुत लोकप्रिय नहीं है, संभवतः इसकी अत्यधिक रनटाइम लचीलापन के कारण, लेकिन रेल आपके आवेदन को प्राप्त करने के लिए आवश्यक कॉन्फ़िगरेशन की मात्रा को कम करने के लिए देर से बाध्यकारी का बहुत अच्छा उपयोग करता है।

0
जोड़ा
यह बिंदु संकलित भाषाओं पर भी लागू होता है जिसमें जेआईटी संकलित घटकों को शामिल किया जा सकता है और प्लगइन्स या गतिशील ढांचे को लागू करने के लिए रनटाइम पर शामिल किया जा सकता है। इसका कुछ कैनोलिक उदाहरण जावा में मौजूद हैं, और निश्चित रूप से रूबी और पायथन भी हैं। एक चरम उदाहरण एरलांग है, जहां रनटाइम किसी भी मॉड्यूल के दो संस्करणों को लाइव अपग्रेड/डाउनग्रेड के लिए लोड कर सकता है। तो हालांकि बहुत सारे एरलांग कोड (अधिकांश?) को स्थाई रूप से टाइप किए गए शुद्ध कार्यों के रूप में लिखा गया है, रनटाइम आवश्यकताएं हुड के नीचे देर से बाध्यकारी और गतिशील प्रकारों को अनिवार्य करती हैं।
जोड़ा लेखक zxq9, स्रोत

Taken directly from http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

स्वचालन (या ओएलई स्वचालन) का उपयोग करने के दो तरीके हैं   प्रोग्रामेटिक रूप से दूसरे एप्लिकेशन को नियंत्रित करें।

     

लेट बाध्यकारी CreateObject का निर्माण और उदाहरण बनाने के लिए उपयोग करता है   एप्लिकेशन ऑब्जेक्ट, जिसे आप तब नियंत्रित कर सकते हैं। उदाहरण के लिए, बनाने के लिए   देर से बाध्यकारी का उपयोग कर एक्सेल का एक नया उदाहरण:

ऑब्जेक्ट के रूप में
  Dim oXL
 ओएक्सएल = CreateObject सेट करें ("एक्सेल। अनुप्रयोग")
 
     

दूसरी ओर, एक्सेल के मौजूदा उदाहरण में हस्तक्षेप करने के लिए (यदि   एक्सेल पहले से ही खुला है) आप GetObject का उपयोग करेंगे (भले ही   आप जल्दी या देर से बाइंडिंग का उपयोग कर रहे हैं):

ऑब्जेक्ट के रूप में
  Dim oXL
 ओएक्सएल = GetObject सेट करें (, "एक्सेल। आवेदन")
 
     

प्रारंभिक बाध्यकारी का उपयोग करने के लिए, आपको पहले अपने संदर्भ में एक सेट सेट करने की आवश्यकता है   उस एप्लिकेशन को प्रोजेक्ट करें जिसमें आप हेरफेर करना चाहते हैं। वीबी संपादक में   कोई भी कार्यालय अनुप्रयोग, या वीबी में, आप इसे चुनकर ऐसा करते हैं   उपकरण + संदर्भ, और उस एप्लिकेशन का चयन करना जिसे आप चाहते हैं   सूची (उदा।? माइक्रोसॉफ्ट एक्सेल 8.0 ऑब्जेक्ट लाइब्रेरी?)।

     

प्रारंभिक बाध्यकारी का उपयोग करके एक्सेल का नया उदाहरण बनाने के लिए:

  Dim oXL Excel के रूप में। अनुप्रयोग
 ओएक्सएल = नया एक्सेल सेट करें। आवेदन
 
     

किसी भी मामले में, आकस्मिक रूप से, आप पहले एक मौजूदा प्राप्त करने का प्रयास कर सकते हैं   एक्सेल का उदाहरण, और यदि यह कोई त्रुटि देता है, तो आप एक नया बना सकते हैं   उदाहरण आपके त्रुटि हैंडलर में।

0
जोड़ा
मुझे पता है कि यह जवाब पुराना है, और यह कहीं और से सोर्स किया गया है, लेकिन यह सटीक नहीं है। देर बाध्यकारी CreateObject का उपयोग इंगित करता है, लेकिन CreateObject जरूरी नहीं है कि देर से बाध्यकारी हो। बाइंडिंग किसी ऑब्जेक्ट को तुरंत चालू करने की विधि पर लागू नहीं होती है, केवल यह कैसे घोषित की जाती है। यदि आप अपनी ऑब्जेक्ट को "एक्सेल के रूप में घोषित करते हैं। एप्लिकेशन" इससे कोई फर्क नहीं पड़ता कि आप इसे कैसे चालू करते हैं। मैं बाहरी पुस्तकालयों के ऑब्जेक्ट संदर्भों को तुरंत चालू करने के लिए CreateObject का उपयोग करता हूं, इस तरह मैं जल्दी और देर से बाध्यकारी के बीच स्विच कर सकता हूं और केवल
जोड़ा लेखक JimmyPena, स्रोत

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

0
जोड़ा
लेकिन देर से बाइंडिंग पर विकिपीडिया लेख ( en.wikipedia.org/wiki/Late_binding ) कहता है कि "देर बाध्यकारी अक्सर गतिशील प्रेषण के साथ उलझन में है, लेकिन महत्वपूर्ण मतभेद हैं"। तो क्या वे वही हैं या नहीं? यदि वे वही हैं, तो उस विकिपीडिया पेज को बदलने की जरूरत है।
जोड़ा लेखक Alexander Bird, स्रोत
बेहतर स्टैक ओवरफ्लो उत्तर यहां stackoverflow.com/questions/484214/early-and-late- बाइंडिंग
जोड़ा लेखक Baggers, स्रोत

हर्बर्ट शिलल्ट सी ++ पुस्तक से समान लेकिन अधिक विस्तृत उत्तर: -

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

प्रारंभिक बाध्यकारी के विपरीत देर से बाध्यकारी है। देर बाध्यकारी संदर्भित करता है कॉल करने के लिए जिन्हें रन टाइम तक हल नहीं किया जाता है। वर्चुअल फ़ंक्शन का उपयोग देर से बाध्यकारी प्राप्त करने के लिए किया जाता है। जैसा कि आप जानते हैं, जब पहुंच मूल सूचक या संदर्भ के माध्यम से होती है, तो वास्तव में वर्चुअल फ़ंक्शन को पॉइंटर द्वारा इंगित ऑब्जेक्ट के प्रकार द्वारा निर्धारित किया जाता है। क्योंकि ज्यादातर मामलों में इसे संकलित समय पर निर्धारित नहीं किया जा सकता है, ऑब्जेक्ट और फ़ंक्शन रन टाइम तक लिंक नहीं होते हैं। देर से बाध्यकारी का मुख्य लाभ लचीलापन है। शुरुआती बाध्यकारी के विपरीत, देर से बाध्यकारी आपको ऐसे प्रोग्राम बनाने की अनुमति देता है जो प्रोग्राम बनाने के बिना निष्पादित घटनाओं का जवाब दे सकते हैं बड़ी संख्या में "आकस्मिकता कोड"। ध्यान रखें कि रन टाइम तक फ़ंक्शन कॉल को हल नहीं किया जाता है, देर से बाध्यकारी कुछ हद तक निष्पादन के समय के लिए बना सकता है। हालांकि आज, तेजी से कंप्यूटरों ने देर से बाध्यकारी से संबंधित निष्पादन के समय में काफी कमी आई है।

0
जोड़ा
"ऑब्जेक्ट और फ़ंक्शन रन टाइम तक लिंक नहीं होते हैं" यह कथन यह इंगित करता है कि रन टाइम से पहले कोई ऑब्जेक्ट मौजूद है। ऑब्जेक्ट्स पूरी तरह से समय इकाइयों को चलाने नहीं हैं? यह उस वस्तु का वर्ग है जो संकलन समय पर मौजूद है। यह बेहतर कहा जा सकता है "फंक्शन कॉल और इसके कार्यान्वयन रन टाइम तक जुड़े नहीं हैं"
जोड़ा लेखक programmerravi, स्रोत
public class child()
{    public void method1()
     {     System.out.println("child1");
     }
    public void method2()
     {     System.out.println("child2");
     }

}
public class teenager extends child()
{    public void method3()
     {      System.out.println("teenager3");
     }
}
public class adult extends teenager()
{     
    public void method1()
    {    System.out.println("adult1);
         super.method1();
     }
}


//In java
public static void main(String []args)
{    ((teenager)var).method1();
}

यह प्रिंट करेगा

adult1
child1

प्रारंभिक बाध्यकारी में कंपाइलर के पास सभी विधियों तक पहुंच होगी बच्चे और किशोरी में लेकिन देर से बाध्यकारी (रनटाइम पर) में, यह उन तरीकों की जांच करेगा जो ओवरराइड हैं चलने के समय पर।

इसलिए विधि 1 (बच्चे से - प्रारंभिक बाध्यकारी) रनटाइम पर वयस्क से विधि 1 द्वारा ओवरराइड किया जाएगा (देर से बाध्यकारी) फिर यह बच्चे से विधि 1 को लागू करेगा क्योंकि किशोरी में विधि 1 में कोई विधि 1 नहीं है।

ध्यान दें कि अगर बच्चे के पास कोई विधि नहीं है तो मुख्य में कोड संकलित नहीं होगा।

0
जोड़ा

संकलन समय polymorphism को ओवरलोडिंग या प्रारंभिक बाध्यकारी या स्थैतिक बाध्यकारी भी कहा जाता है जब हमारे पास अलग-अलग व्यवहार के साथ एक ही विधि का नाम होता है। उसी विधि के एकाधिक प्रोटोटाइप को लागू करके और इसमें विभिन्न व्यवहार होते हैं। प्रारंभिक बाध्यकारी कार्यक्रम के पहले संकलन को संदर्भित करता है। लेकिन देर से बाइंडिंग ऑब्जेक्ट में रनटाइम प्रोग्राम में होता है। इसे गतिशील बाध्यकारी या ओवरराइडिंग या रनटाइम पॉलीमोर्फिज्म भी कहा जाता है।

0
जोड़ा