Wat is vroege en late binding?
Geplaatst op november 18, 2020 door adminIk hoor steeds over vroege en late binding, maar ik begrijp niet wat ze zijn. Ik vond de volgende uitleg die ik niet begrijp:
Vroege binding verwijst naar de toewijzing van waarden aan variabelen tijdens de ontwerptijd, terwijl late binding verwijst naar de toewijzing van waarden naar variabelen tijdens runtime.
Kan iemand de twee soorten binding definiëren en ze vergelijken?
Opmerkingen
- compileer tijd versus runtime.
- Hier is een goede lezing over het onderwerp: en.wikibooks.org/ wiki / Introduction_to_Programming_Languages / …
Antwoord
Er zijn twee belangrijke concepten die door elkaar worden gehaald: binden en laden. Het wordt samengevoegd door het concept van DataBinding, dat zich ergens in het midden bevindt en vaak beide doet. Nadat ik het heb overwogen, ga ik nog een concept toevoegen om de trifecta, dispatch te voltooien.
Typen
Late Binding : type is onbekend totdat de variabele wordt uitgeoefend tijdens runtime; meestal door toewijzing, maar er zijn andere middelen om een type te dwingen; dynamisch getypeerde talen noemen dit een onderliggend kenmerk, maar veel statisch getypeerde talen hebben een methode om late binding te bereiken
Vaak geïmplementeerd met behulp van [speciale] dynamische typen, introspectie / reflectie, vlaggen en compileropties, of via virtuele methoden door dynamische verzending te lenen en uit te breiden
Early Binding : type is bekend voordat de variabele wordt uitgeoefend tijdens runtime, meestal via statische, declaratieve middelen
Vaak geïmplementeerd met behulp van standaard primitieve typen
Functies
Static Dispatch : bekende, specifieke functie of subroutine tijdens het compileren; het is ondubbelzinnig en komt overeen met de handtekening
Geïmplementeerd als statische functies; geen enkele methode kan dezelfde handtekening hebben
Dynamic Dispatch : niet een specifieke functie of subroutine tijdens het compileren; bepaald door de context tijdens de uitvoering. Er zijn twee verschillende benaderingen voor “dynamische verzending”, die worden onderscheiden door welke contextuele informatie wordt gebruikt om de juiste functie-implementatie te selecteren.
In enkele [ dynamisch ] verzending , alleen het type instantie wordt gebruikt om de juiste functie-implementatie te bepalen. In statisch getypeerde talen betekent dit in de praktijk dat het instantietype beslist welke methode-implementatie wordt gebruikt, ongeacht het referentietype dat wordt aangegeven wanneer de variabele wordt gedeclareerd / toegewezen. Omdat slechts één type – het type van de objectinstantie – wordt gebruikt om de juiste implementatie af te leiden, wordt deze benadering “single dispatch” genoemd.
Er is ook meerdere [ dynamisch ] verzending , waarbij typen invoerparameters ook helpen bepalen welke functie-implementatie moet worden aangeroepen. Omdat meerdere typen – zowel het type instantie als het type (s) van de parameter (s) – beïnvloeden welke methode-implementatie is geselecteerd, deze benadering wordt “multiple dispatch” genoemd.
Geïmplementeerd als virtuele of abstracte functies; andere aanwijzingen zijn onder meer overschreven, verborgen of beschaduwde methoden.
NB: Of overbelasting van methoden dynamische verzending inhoudt, is taalspecifiek. In Java worden bijvoorbeeld overbelaste methoden statisch verzonden.
Waarden
Lazy Loading : objectinitialisatiestrategie die waardetoewijzing uitstelt tot nodig ; laat toe dat een object in een in wezen geldige maar bewust onvolledige staat verkeert en wacht tot de gegevens nodig zijn voordat het wordt geladen; vaak bijzonder nuttig gevonden voor het laden van grote datasets of het wachten op externe bronnen
Vaak geïmplementeerd door doelbewust geen verzameling of lijst in een samengesteld object te laden tijdens de constructor of initialisatieaanroepen totdat een downstream-beller vraagt om de inhoud van die verzameling (bijv. get_value_at, get_all_as, enz.).Variaties zijn onder meer het laden van meta-informatie over de verzameling (zoals grootte of sleutels), maar het weglaten van de feitelijke gegevens; biedt ook een mechanisme voor sommige runtimes om ontwikkelaars een redelijk veilig en efficiënt singleton-implementatieschema te bieden.
Eager Loading : objectinitialisatiestrategie die onmiddellijk alle waardetoewijzingen uitvoert om ervoor te zorgen dat alle gegevens compleet zijn voordat ze zichzelf als geldig beschouwen.
Vaak geïmplementeerd door zo snel mogelijk een samengesteld object voorzien van al hun bekende gegevens, zoals tijdens een constructoraanroep of initialisatie
Gegevensbinding : omvat vaak het creëren van een actieve link of kaart tussen twee compatibele informatiestromen zodat veranderingen in de ene worden teruggekaatst in de andere en vice versa; om compatibel te zijn, moeten ze vaak een gemeenschappelijk basistype of interface hebben.
Vaak geïmplementeerd als een poging om een schonere, consistente synchronisatie te bieden tussen verschillende toepassingsaspecten (bijv. view-model om te bekijken, model naar controller , etc.) en spreekt over concepten zoals bron en doel, eindpunten, binden / ontbinden, bijwerken en gebeurtenissen zoals on_bind, on_property_change, on_explicit, on_out_of_scope
EDIT OPMERKING: Laatste grote bewerking om beschrijving te geven voorbeelden van hoe deze vaak voorkomen. Bepaalde codevoorbeelden zijn volledig afhankelijk van de implementatie / runtime / platform.
Opmerkingen
- Dit antwoord lijkt te specifiek voor objectgeoriënteerde talen.
- @Jack Ik denk niet ‘ zo, ik denk dat dit een excellente is die vele aspecten omvat.
Antwoord
Alles dat door de compiler wordt beslist tijdens het compileren, kan worden verwezen naar VROEGE / COMPILETIJD Binding en alles waarover moet worden beslist op RUNTIME wordt LATE / RUNTIME binding.
Bijvoorbeeld,
Methode Overbelasting en methode Overschrijven .
1 ) In Overbelasting van methode roept uw methode de methoden ar e bepaald door de compiler in de zin dat welke functie wordt aangeroepen, wordt bepaald door uw compiler tijdens het compileren. Daarom VROEGE BINDING .
2) In methode Overriding wordt tijdens RUNTIME bepaald welke methode zal worden gebeld. Dus het wordt aangeduid als LATE BINDING .
Geprobeerd om het eenvoudig en gemakkelijk te verkrijgen te houden. Ik hoop dat dit helpt.
Antwoord
Late binding is wanneer het gedrag tijdens runtime wordt geëvalueerd. Het is nodig als je inderdaad wilt bepalen hoe je moet handelen op basis van informatie die je alleen hebt als het programma draait. Het duidelijkste voorbeeld is naar mijn mening het virtuele functiemechanisme, met name in C ++.
class A { public: void f() {} virtual void g() {} }; class B : public A { void f() {} virtual void g() {} }; int main() { A* a = new B; a->f(); a->g(); }
In dit voorbeeld zal a->f()
eigenlijk void A::f()
aanroepen, omdat het vroeg (of statisch ) gebonden, en dus denkt het programma tijdens runtime denkt dat het “slechts een verwijzing is naar een A
type variabele, terwijl a->g()
zal eigenlijk void B::g()
aanroepen, omdat de compiler, die ziet dat g()
virtueel is, code injecteert om het adres van de juiste functie op te zoeken om te bellen tijdens runtime.
Reacties
- ” De runtime “? U ‘ praat over C ++. C ++ compileert rechtstreeks naar machinecode, het heeft ‘ geen runtime nodig om op te lossen virtuele methoden.
- @tdammers C ++ heeft eigenlijk een runtime-bibliotheek nodig, maar niet voor virtuele oproepen. Als je zorgvuldig leest, ‘ zul je merken dat dit antwoord zegt dat de compiler ” code injecteert om het adres van de juiste functie [ …] op runtime “.
- Nou, maar die ” code het adres van de juiste functie opzoeken ” is eigenlijk gewoon een type-agnostische tweetraps pointer dereferentie gevolgd door een functieaanroep. Er is geen ” denkende ” betrokken; de enige reden waarom het betrouwbaar werkt, is omdat de compiler de typecontrole tijdens het compileren uitvoert; tijdens runtime vertrouwt de gegenereerde code de compiler om het huiswerk voor typecontrole te hebben gedaan. Als u onveilige casts gebruikt (bijv.C-style pointer casts), kan legaal C ++ objecten behandelen als object van de verkeerde klasse, maar hun vtables zullen volkomen in de war raken en de code breekt gewoon.
- @tdammers Ik probeerde weg te blijven van dat soort antwoorden, omdat het ‘ een implementatiedetail van compilers is, wat wel of niet waar kan zijn voor een of andere esoterische compiler. Waar het om gaat is het concept.
- @tdammers En door ” de runtime ” bedoel ik ” het programma tijdens runtime “. Het is duidelijk dat C ++ niet ‘ t beheerd wordt. Maar aangezien je me hebt laten zien dat het verwarring kan veroorzaken, ‘ verander ik het in de volledige bewoording.
Antwoord
als u bekend bent met functie-verwijzingen, zou dit een voorbeeld zijn. Functies die zijn gedefinieerd, kunnen als vroege binding worden beschouwd. terwijl als je functie-pointers gebruikt zijn late binding.
int add(int x,int y) { return x+y; } int sub(int x,int y) { return x-y; } int main() { //get user choice int(*fp)(int,int); //if add fp=add; //else if sub fp=sub; cout<<fp(2,2); }
hier zijn functies add en sub zijn functies (het adres is gebonden bij compilatietijdlinker)
maar de functieaanwijzer is laat binding van de fp kan ofwel add of sub aanroepen, afhankelijk van de keuze van de gebruiker [tijdens runtime].
Answer
Alleen vroege en late binding logisch zijn in de context van typen en niet de manier waarop u het beschrijft. Vrijwel alle moderne talen worden getypt in de zin dat alle waarden vaste typen hebben. Het verschil komt naar voren als we kijken naar dynamisch versus statisch getypeerde talen. In dynamisch getypeerde talen hebben variabelen geen typen, zodat ze kunnen verwijzen naar waarden van elk type en dit betekent dat wanneer u een methode aanroept voor een object waarnaar wordt verwezen door een variabele, de enige manier om te bepalen of die aanroep geldig is of niet zoek de klasse op voor het object en kijk of die methode echt bestaat. Dit maakt een aantal coole dingen mogelijk, zoals het toevoegen van nieuwe methoden aan klassen tijdens runtime, omdat het opzoeken van de methode wordt uitgesteld tot het allerlaatste moment. De meeste mensen noemen deze status van zaken late binding.
In een statisch getypeerde taal hebben variabelen typen en eenmaal gedeclareerd kunnen ze niet verwijzen naar een waarde die niet van hetzelfde type is. Dit is niet helemaal waar, maar laten we het voorlopig aannemen. Als u nu weet dat de variabele alleen ooit naar waarden van een specifiek type zal verwijzen, is er geen reden om erachter te komen of een methodeaanroep geldig is of niet tijdens runtime, omdat u de geldigheid kunt bepalen voordat de code ooit wordt uitgevoerd. Dit wordt vroege binding genoemd.
Een voorbeeld om late binding in ruby aan te tonen:
a = 1 # a is an integer at this point a.succ # asking for its successor is valid class A def method_a # some code end end a = A.new a.method_a # this is also valid a.succ # this is not valid class A # we can re-open the class and add a method def succ # some more code end end a.succ # now this is valid
De bovenstaande reeks acties is niet mogelijk in een taal als Java, waar alle typen tijdens runtime worden vastgesteld.
Answer
In plaats van je een academische definitie te geven, heb ik zal proberen om u enkele van de verschillen te laten zien aan de hand van een voorbeeld uit de echte wereld met behulp van VBA:
Vroege binding:
Dim x As FileSystemObject Set x = New FileSystemObject Debug.Print x.GetSpecialFolder(0)
Hiervoor moet een verwijzing worden ingesteld naar de “Microsoft Scripting Runtime” -component op ontwerptijd . Het heeft het voordeel dat je al tijdens het compileren een foutmelding krijgt als je een typefout hebt in FileSystemObject
of methodenamen zoals GetSpecialFolder
.
Late binding
Dim x As Object Set x = CreateObject("Scripting.FileSystemObject") Debug.Print x.GetSpecialFolder(0)
Dit vereist geen referentie om vooraf in te stellen, de aanmaak en het type van de instantie vastberadenheid gebeurt gewoon tijdens de uitvoering. De compiler “zal niet klagen tijdens het compileren wanneer je een niet-bestaande methode x
probeert aan te roepen, dit zal alleen leiden tot een run-time fout als de specifieke regel wordt uitgevoerd .
Het nadeel van late binding is dus dat je hier geen sterke typecontrole hebt. Maar dat is ook het voordeel – stel dat u een component heeft waar meerdere versies bestaan, en elke nieuwere versie biedt enkele extra functies. (Een realistisch voorbeeld zijn de MS Office-componenten, zoals de Excel COM-interface). je schrijft code die samenwerkt met al die versies – je kunt eerst de specifieke componentversie bepalen, en als je ontdekt dat je alleen een oudere versie beschikbaar hebt, vermijd dan om functieaanroepen uit te voeren die niet met die versie werken. / p>
Answer
Misschien wel het meest voorkomende voorbeeld van late binding is het oplossen van internet-URLs. Het ondersteunt dynamische systemen en grote systemen zonder te proberen elke site ter wereld te linken en te binden voordat je er een kunt bereiken, maar aan de andere kant veroorzaakt het wel wat overhead (DNS-lookup, veel minder IP-routing) tijdens runtime.
Door dat licht zijn de meeste soorten binding in taalomgevingen min of meer vroeg, tijdens het compileren of koppelen.
Elke soort heeft kosten en baten.
Opmerkingen
- Kunt u een referentie plaatsen voor deze definitie van bindend?Ik heb nog nooit gehoord van het omzetten van internetadressen als ” binding “, hoewel, aangezien bindend is het oplossen van namen, ik veronderstel dat iemand ruzie heeft gemaakt dat het concept van vroege / late binding kan worden toegepast op het oplossen van URI naar internetadressen. Maar dit is geen gebruikelijke interpretatie en het concept van vroege / late binding dateert van vóór de tijd dat computers gewoonlijk met internet waren verbonden.
Geef een reactie