DOUG LLOYD: När du börjar arbeta med funktioner
en annan sak kommer att bli verkligen viktigt att förstå,
vilket är begreppet variabel omfattning.
Så räckvidd är en kännetecknande för en variabel
som definierar från vilka funktioner denna variabel kan nås.
>> Det finns två huvudsakliga omfattningar i C, lokala variabler och globala variabler.
Nu, lokala variabler kan endast nås inom de funktioner
i vilket de är skapade.
De kan inte nås av alla andra funktion som finns i ditt program,
endast funktionen i där det skapades.
Globala variabler, på andra sidan kan nås
av någon funktion i programmet.
Och anledningen till det är eftersom de inte är skapade inne
av någon särskild funktion.
Vi förklarar dem utanför alla de funktioner, som
innebär att varje funktion vet var det är och kan komma åt och manipulera det.
>> Hittills under du har ganska mycket arbetat uteslutande
med lokala variabler.
Här är ett exempel på en mycket, mycket enkel huvudfunktion och en mycket enkel
extra funktion som vi har skrivit.
I detta fall, x, som Jag har färgat grönt bara
för att markera orten eller omfattningen av den variabeln,
är lokal funktionen tredubbla.
Huvud kan inte hänvisa till x alls.
Det vet inte vad det är.
Ingen annan funktion, i själva verket, om vi hade ytterligare funktioner här,
skulle kunna hänvisa till x.
>> På liknande sätt resulterar som jag har blåfärgad, är endast lokalt till huvud.
Endast huvud vet vad den variabla resultat är.
trippel kan inte använda den.
>> Nu som jag nämnde, existerar globala variabler.
Om du deklarerar den variabeln utanför en funktion,
alla funktioner i Programmet kan hänvisa till den.
Så i det här fallet jag har markerat i green en global variabel deklaration.
I detta fall, den variabel som deklareras
kallas globala, bara för att vara mycket tydliga med det.
Det är av typen float.
Och jag tilldela det värdet 0,5050.
>> Du kommer att märka att i main och trippel, kan jag hänvisa till den globala.
Och faktiskt, om jag går igenom programmet såsom angivits, huvud första samtal trippel,
trippel multiplicerar globala med 3, som sätter dess värde till 1,5-någonting,
1,51 eller något liknande, och då huvud också skriver ut värdet
av den globala.
Så huvud kommer inte att skriva ut 0,5050, det kommer att skriva ut Global Times 3, 1,51.
Så du har fått vara försiktig när du arbetar med globala variabler.
Medan de är mycket flexibel att kunna överföra information
runt så att varje Funktionen kan använda den,
den kan också ha viss farliga konsekvenser
Om en funktion ändras värdet av en variabel
innan du förväntar dig att ändras.
>> Varför denna skillnad roll?
Varför bryr vi oss om vissa variabler är lokala och andra är globala?
Tja, för det mesta, lokala variabler i C är vad som kallas passerade värde
när vi gör ett funktionsanrop.
Vad betyder det?
>> Jo, när en variabel passeras av värdet, den uppringda, som
är ett annat sätt att säga funktionen som tar emot den variabel som
blir gått in som en ingång, det faktiskt inte får den variabeln själv.
Den tar emot sin egen kopia av den att arbeta med.
Detta är en mycket viktig skillnad.
Vi såg bara en sekund sedan att med globala variabler,
om vi manipulera den globala variabel i en funktion, effekten
att en funktion bär fram till alla andra funktioner.
>> Men med lokala variabler, det är inte sant.
Varje funktion när det mottar variabler som indata
få kopior av dessa variabler, inte de variabler själva.
Så vad är det bieffekt av det?
Detta innebär att variabeln i den som ringer, den funktion som
är att göra funktionsanrop, är oförändrad om du inte åsidosätta den.
>> Till exempel, i denna kod foo ändras inte alls.
Int foo är lika med 4, ring trippel av foo, insidan av trippel,
Vi förväntar mig att foo skulle multipliceras med 3 och återvände,
men det finns faktiskt ingen effekt.
>> Här dock en mycket subtil skillnad.
Detta har den effekten vi vill ha.
Ser du varför?
Vi tvingande foo i huvud den här gången.
>> Så int foo är lika med 4, lika foo trippel foo, när vi gör det samtalet,
trippel får sin egen kopia av foo, sin egen kopia av fyra.
Den säger tillbaka 4 gånger 3, eller vad variabel får passera i tider 3.
Och sedan vi tilldelar avkastningen Värdet av triple att foo igen.
Så detta faktiskt skulle skriva foo.
Detta är det enda sättet att göra detta med lokal variabel.
Så nu om vi lägga till ytterligare kodrad här
i slutet av huvud till skriva ut värdet av foo,
Det skulle i själva verket skriva ut 12.
>> Variabel räckvidd är i allmänhet inte alltför mycket av ett problem
Om du namnge alla dina variabler olika saker.
Men det kan bli slags otäck om samma variabelnamn
visas i flera funktioner, som kommer att hända en hel del.
Om du någonsin arbetar i den verkliga världen där
du arbetar på samarbete program och människor i olika grupper
samarbetar för att skriva samma program eller samma uppsättning program,
de kommer ofta åter variabel namn, särskilt vanligaste
som x, y, i, j, och så vidare.
>> Men när variabler har samma namn, omfattning frågor
kan få lite svårare att tolka.
Till exempel, vet du vad som skulle skrivas ut
vid slutet av detta program?
Ta en minut.
Pausa video och läsa genom detta program.
Du kan se på toppen vi har en funktionsdeklaration
för en funktion som kallas inkrement.
Denna funktion tar en enda parametern, ett heltal, vilket vi kallar x.
Och det skriver ut ett heltal.
Det är returtypen i början.
>> Sedan har vi huvud, ett par rader kod i huvudsak varav den sista
är ett tryck uttalande.
Och kom ihåg, det är frågan här.
Vad är det egentligen kommer att bli tryckt i slutet av denna funktion?
Och då vi faktiskt har definition av inkrement nedan.
>> Så ta en minut, gå igenom koden, spåra ut saker.
Vet du vad som ska skrivas ut I slutet av detta program?
>> Okej.
Förhoppningsvis har du tagit några sekunder att försöka tolka detta ett ut.
Låt oss göra det tillsammans.
>> Så jag har överstruken ökning på deklaration högst upp där.
Det var lite av en distraktion.
Det är inte en egen variabel.
Det har inte egen räckvidd.
Det är bara en funktion deklaration, så för ändamål
att försöka tolka vad som är händer i det här programmet,
Vi kan lika gärna bara undvika det.
>> Nu har vi i detta fall Anledningen till att detta problem är knepigt
är att vi har lokala variabler i både huvud- och ökning, som var och en
är kallade x.
Och naturligtvis den springande punkten i den här frågan är försöker reda ut vilka x får ändras
och hur det ã¤ndras.
Så jag har färgat varje instans x som är lokal till huvud rött.
Och jag har färgat varje instans av x som är lokalt för att öka blå.
>> Observera att tredje raden av huvud, lika y ökning
x, är att ökningen inte är passerade huvud x-, eller den röda x.
Det börjar bli passerade en kopia av den.
Och det är bara att jobba med Denna kopia av den, den blå x.
Om du är matematiskt lutande, kanske du
har i stället tänkt på detta som x sub m för huvud och x sub i för steg.
Men det är samma idé.
x sub m, eller röda kryssen i föregående bild,
är de variabler som är local-- är exempel på x snarare att
är lokal till huvud, och x sub i, eller blå variabler i föregående bild,
är exempel på x som är lokal mot öka.
>> Så, har du kunnat räkna ut vad denna funktion skrivs i slutet?
Jag är Doug Lloyd, och detta är CS50.