Vad är tidig och sen bindning?
On november 18, 2020 by adminJag fortsätter att höra om tidig och sen bindning, men jag förstår inte vad de är. Jag hittade följande förklaring som jag inte förstår:
Tidig bindning avser tilldelning av värden till variabler under designtiden medan sen bindning avser tilldelning av värden till variabler under körtiden.
Kan någon definiera de två typerna av bindning och jämföra dem?
Kommentarer
- kompileringstid vs runtime.
- Här är en bra läsning om ämnet: en.wikibooks.org/ wiki / Introduction_to_Programming_Languages / …
Svar
Det finns två huvudbegrepp i förvirring: bindning och laddning. Det är sammansatt av begreppet DataBinding, som någonstans i mitten ofta gör båda. Efter att ha övervägt det ska jag lägga till ytterligare ett koncept, för att slutföra trifecta, skicka.
Typer
Sen bindning : typen är okänd tills variabeln utövas under körningstiden; vanligtvis genom uppdrag men det finns andra sätt att tvinga en typ; dynamiskt skrivna språk kallar detta en underliggande funktion, men många statiskt skrivna språk har någon metod för att uppnå sen bindning
Implementeras ofta med [speciella] dynamiska typer, introspektion / reflektion, flaggor och kompilatoralternativ eller genom virtuella metoder genom att låna och utvidga dynamisk leverans
Tidig bindning : typ är känd innan variabeln utövas under körningstiden, vanligtvis genom ett statiskt, deklarativt sätt
Implementeras ofta med primitiva standardtyper
Funktioner
Statisk sändning : känd, specifik funktion eller subrutin vid sammanställningstid; den är entydig och matchas av signaturen
Implementerad som statiska funktioner; ingen metod kan ha samma signatur
Dynamic Dispatch : inte en specifik funktion eller subrutin vid sammanställningstid; bestäms av sammanhanget under utförandet. Det finns två olika tillvägagångssätt för ”dynamisk utsändning”, som kännetecknas av vilken kontextuell information som används för att välja lämplig funktionimplementering.
I singel [ dynamisk ] skickar , endast instansens typ används för att bestämma lämplig funktionsimplementering. I statiskt skrivna språk betyder detta i praktiken att förekomsttypen bestämmer vilken metodimplementering som används oavsett vilken referens typ som anges när variabeln deklareras / tilldelas. Eftersom endast en enda typ – typen av objektinstansen – används för att dra slutsatsen om lämplig implementering, kallas denna metod för ”enkel leverans”.
Det finns också flera [ dynamiska ] skicka , där ingångsparametertyper också hjälper till att avgöra vilken funktionsimplementering som ska anropas. Eftersom flera typer – både typen av förekomsten och typ (er) av parametern / parametrarna – påverkar vilken metodimplementering som väljs, detta tillvägagångssätt kallas ”multipel sändning”.
Implementerad som virtuella eller abstrakta funktioner; Andra ledtrådar inkluderar åsidosatta, dolda eller skuggade metoder.
OBS: Huruvida metodöverbelastning innebär dynamisk leverans är språkspecifik. Till exempel skickas överbelastade metoder i Java statiskt.
Värden
Lazy Loading : strategi för objektinitiering som definierar värdetilldelning tills det behövs ; låter ett objekt vara i ett väsentligen giltigt men medvetet ofullständigt tillstånd och vänta tills data behövs innan det laddas; ofta funnit vara särskilt användbart för att ladda stora datamängder eller vänta på externa resurser
Implementeras ofta genom att målmedvetet inte ladda en samling eller en lista i ett sammansatt objekt under konstruktörs- eller initialiseringssamtal tills någon nedströms uppringare frågar att se den samlingen (t.ex. get_value_at, get_all_as, etc).Variationer inkluderar laddning av metainformation om samlingen (som storlek eller nycklar), men utelämnande av faktiska data; tillhandahåller också en mekanism för vissa driftstider för att ge utvecklare ett ganska säkert och effektivt implementeringsschema för singleton
Eager Loading : objektinitieringsstrategi som omedelbart utför alla värdetilldelningar för att ha alla data som behövs för att vara fullständiga innan de anser sig vara i ett giltigt tillstånd.
Implementeras ofta av tillhandahålla ett sammansatt objekt med alla sina kända data så snart som möjligt, som under ett konstruktionsanrop eller initialisering
Databindning : innebär ofta att man skapar en aktiv länk eller karta mellan två kompatibla informationsströmmar så att ändringar i den ena återspeglas i den andra och vice versa; För att vara kompatibla måste de ofta ha en gemensam bastyp eller gränssnitt
Implementeras ofta som ett försök att tillhandahålla renare, konsekvent synkronisering mellan olika applikationsaspekter (t.ex. visningsmodell att visa, modell till styrenhet , etc.) och talar om begrepp som källa och mål, slutpunkter, bind / binda, uppdatera och händelser som on_bind, on_property_change, on_explicit, on_out_of_scope
EDIT OBS: Senaste stora redigeringen för att ge beskrivning exempel på hur dessa ofta förekommer. Särskilda kodexempel beror helt på implementeringen / runtime / plattformen
Kommentarer
- Det här svaret verkar för specifikt för objektorienterade språk.
- @Jack Jag känner inte ’ Jag känner inte det här, jag tycker att det här är ett utmärkt som täcker många aspekter.
Svar
Allt som bestäms av kompilatorn under kompileringen kan hänvisas till TIDIGT / KOMPILERA TID Bindning och allt som ska bestämmas på RUNTIME kallas LATE / RUNTIME binding.
Till exempel
Metod Överbelastning och metod Åsidosättande .
1 ) I Metodöverbelastning din metod kallar till metoderna ar bestäms av kompilatorn i den meningen att vilken funktion som ska kallas bestäms av kompilatorn vid kompileringstidpunkten. Därför att vara TIDIG BINDNING .
2) I metod Åsidosättning bestäms det vid RUNTIME vilken metod som är kommer att kallas. Så det refereras till som SEN BINDNING .
Försökte hålla det enkelt och lätt att få. Hoppas det hjälper.
Svar
Sen bindning är när beteende utvärderas vid körning. Det är nödvändigt när du verkligen vill bestämma hur du ska agera utifrån information du bara har när programmet körs. Det tydligaste exemplet är enligt min mening den virtuella funktionsmekanismen, specifikt i 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(); }
I detta exempel kommer a->f()
faktiskt att ringa void A::f()
, eftersom det är tidigt (eller statiskt ) bunden, så programmet tänker att det bara är en pekare till en A
typvariabel, medan a->g()
kommer faktiskt att ringa void B::g()
, eftersom kompilatorn, eftersom g()
är virtuell, injicerar kod för att leta upp adressen till rätt funktion att ringa vid körning.
Kommentarer
- ” Runtime ”? Du ’ talar om C ++. C ++ kompilerar direkt till maskinkod, det behöver inte ’ för att lösa virtuella metoder.
- @tdammers C ++ behöver faktiskt ett körtidsbibliotek, men inte för virtuella samtal. Om du läser noggrant märker du ’ att detta svar säger att kompilatorn ” injicerar kod för att slå upp adressen till rätt funktion [ …] vid runtime ”.
- Tja, men den ” -koden att slå upp adressen till rätt funktion ” är i grund och botten bara en typ-agnostisk tvåstegs pekdereferens följt av ett funktionsanrop. Det finns ingen ” som tänker ”; den enda anledningen till att det fungerar tillförlitligt är att kompilatorn gör typkontrollen vid kompileringstidpunkten ; vid körning litar den genererade koden på att kompilatorn har gjort typkontrollläxorna. Om du använder osäkra avgjutningar (t.ex.C-stil pekare kastar), du kan lagligt behandla C ++ – objekt som objekt av fel klass, men deras vtabeller blir helt trassliga och koden bryts bara.
- @tdammers Jag försökte hålla mig borta från den typen av svar, eftersom det ’ är en implementeringsdetalj av kompilatorer, som kanske eller kanske inte är sant för någon esoterisk kompilator. Det som är viktigt är konceptet.
- @tdammers Och med ” körtiden ” menar jag ” programmet vid körning ”. Det är uppenbart att C ++ inte ’ t hanteras. Men eftersom du visade mig kan det orsaka förvirring, jag ’ ändrar det till den fullständiga formuleringen.
Svar
om du känner till funktionspekare är detta ett exempel. Definierade funktioner kan sägas vara tidig bindning. medan om du använder Funktionspekare är dess sena bindning.
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); }
här lägger till funktioner och sub är funktioner (dess adress är bunden vid kompileringstid-länkare)
men funktionspekaren är sen bindning av fp kan anropa antingen add eller sub beroende på användarval [vid körning].
Svar
Endast tidig och sen bindning vara vettigt i sammanhanget av typer och inte hur du beskriver det. Nästan alla moderna språk skrivs i den meningen att alla värden har fasta typer. Skillnaden kommer in när vi tittar på dynamiskt jämfört med statiskt skrivna språk. I dynamiskt skrivna språk har variabler inte typer så att de kan hänvisa till värden av vilken typ som helst och det betyder att när du ringer till en metod för ett objekt som hänvisas till av någon variabel är det enda sättet att avgöra om det samtalet är giltigt eller inte är att leta upp klassen för objektet och se om den metoden faktiskt existerar. Detta möjliggör några coola saker som att lägga till nya metoder i klasserna under körning eftersom den faktiska metoduppsökningen skjuts upp till sista stund. angelägenheter sent bindande.
I en statiskt skriven språk har variabler typer och en gång deklareras kan de inte hänvisa till något värde som inte är av samma typ. Detta är inte riktigt sant men kan anta det för tillfället. Om du nu vet att variabeln bara någonsin kommer att referera till värden av en viss typ, finns det ingen anledning att ta reda på om ett metodanrop är giltigt eller inte vid körningstid eftersom du kan bestämma giltigheten innan koden någonsin körs. Detta kallas tidig bindning.
Ett exempel för att visa sen bindning i rubin:
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
Ovanstående åtgärdssekvens är inte möjligt på ett språk som Java där alla typer är fixade vid körningstid.
Svar
Istället för att ge dig en akademisk definition I försöker visa dig några av skillnaderna med hjälp av ett verkligt exempel med hjälp av VBA:
Tidig bindning:
Dim x As FileSystemObject Set x = New FileSystemObject Debug.Print x.GetSpecialFolder(0)
Detta kräver att en referens ställs in till ”Microsoft Scripting Runtime” -komponenten vid designtid . Det har fördelen att du får ett felmeddelande redan vid kompileringen när du har ett skrivfel i FileSystemObject
eller metodnamn som GetSpecialFolder
.
Sen bindning
Dim x As Object Set x = CreateObject("Scripting.FileSystemObject") Debug.Print x.GetSpecialFolder(0)
Detta kräver inte att en referens ställs in i förväg, förekomst skapande och typ beslutsamhet kommer bara att ske vid körning. Kompilatorn klagar inte vid kompileringstid när du försöker anropa en icke-existerande metod för x
, detta leder till ett körtidsfel endast när den specifika raden körs .
Så nackdelen med sen bindning är att du inte har någon stark typ här. Men det är också fördelen – låt oss säga att du har en komponent där flera versioner finns, och varje nyare version har några ytterligare funktioner. (Ett verkligt exempel är MS Office-komponenter, som Excel COM-gränssnittet) Sen bindning tillåter du skriver kod som fungerar tillsammans med alla dessa versioner – du kan först bestämma den specifika komponentversionen, och om du upptäcker att du bara har en äldre version tillgänglig, undvik att utföra funktionsanrop som inte fungerar med den versionen.
Svar
Det kanske vanligaste exemplet på sen bindning är att lösa internet-URL: er. Den stöder dynamiska system och stora system utan att försöka länka och binda alla webbplatser i världen innan du kan nå någon, men å andra sidan medför det vissa omkostnader (DNS-sökning, mycket mindre IP-routing) vid körning.
På det viset är de flesta bindningsvarianter i språkmiljöer mer eller mindre tidiga, vid tidpunkten för sammanställning eller länkningstid.
Varje slag har kostnader och fördelar.
Kommentarer
- Kan du hitta en referens för denna definition av bindning?Jag har inte hört talas om att lösa internetadresser som ” bindande ”, men eftersom bindning är en lösning på namn, antar jag att någon har argumenterat att begreppet tidig / sen bindning kan tillämpas på att lösa URI till internetadresser. Men detta är inte en vanlig tolkning, och begreppet tidig / sen bindning föregår den tid då datorer vanligtvis var anslutna till internet.
Lämna ett svar