Bună ziua și binevenită înapoi această prelegere vreau să vorbesc despre un concept numit treci prin referință.
Când am început să vorbim despre indicatori am menționat unul dintre avantajele este
că nu trebuie să folosiți variabile globale atât de mult pentru că atunci când treci un pointer la o funcție a funcției
este poate folosi acel parametru și când modifică acel parametru datele vor fi modificate în afara funcției.
Dreapta.
Deci, acesta este un concept valoroase valoroase.
Vom vorbi despre asta.
Acesta este mai mult un concept C de fapt, nu utilizează acest lucru și am să vă arăt cum și
să vă dau câteva exemple.
Practic, cum funcționează acest lucru.
Deci, există acest concept de trecere prin valoare.
Acest lucru are legătură cu funcțiile.
Am vorbit despre transmiterea datelor unei funcții, dar despre modul în care aceasta este trecută în termeni de
limbaj în compilator.
Deci, există un concept de trecere prin valoare și despre asta am vorbit până acum, de fiecare
dată când numim funcția.
În afară de funcția scanerului, suntem de altă dată când numim funcția pe care nu am mai fost-o Maatta.
Când modificați aceste date în interiorul funcției, nu a fost modificată în afara funcției.
In regula.
Am vorbit despre variabilele locale care sunt un fel de concept diferit, dar atunci când transmiteți datele unei funcții, există
două moduri în care puteți să le transmiteți.
Puteți să-l transmiteți prin valoarea poate trece prin referința K.
C trece exclusiv prin trimiteri sau trece prin valoare Îmi pare rău.
Și așa este Java tot prin trecere prin valoare, dar simulează treci prin referință pentru că copiați adresa.
Și așa că, chiar dacă acest lucru de a trece prin referință nu este folosit în mod specific de c simulează aceasta.
Și pentru a înțelege ce a trecut prin referință înseamnă și de ce este important.
Vom vorbi despre asta, dar trece prin valoare este o funcție care copiază valoarea reală a unui
argument în parametrul formal al funcției.
Și acesta este motivul pentru care dacă aveți un float întreg sau un dublu și îl transmiteți ca argument la
o funcție în care variabila actuală nu se modifică în afara funcției deoarece este copiată, astfel încât
modificările aduse parametrului din interiorul funcției nu au efect asupra argumentului variabilei.
Argumentul care este transmis nu se modifică corect, așa că acționează aproape ca o variabilă locală deoarece este
o copie.
Cum se întâmplă de fapt sub capotă este faptul că este copiată și transmisă funcției C care utilizează
apelul prin valoare pentru a transmite argumente.
Totul se numește prin valoare trecută prin valoare.
Acestea sunt folosite interschimbabil acești termeni.
Din nou, acest lucru înseamnă că codul din cadrul unei funcții nu poate modifica argumentele utilizate pentru a apela funcția.
Nu există modificări ale valorilor, deși au fost schimbate în interiorul funcției.
Se pare că există variabile locale și de aceea mai devreme până la acest punct, atunci când ați creat globale,
a trebuit să creați date globale dacă doriți să partajați datele de la o funcție la alta.
Și așa funcționează C.
Dar ce se întâmplă atunci când treci într-adevăr o copie a unei actrite Lana poate face ca mimează să treacă prin referință.
Dar aici este un exemplu despre modul în care am folosit trec prin valoare, a demonstrat foarte frumos aici.
Această rutină swap este un caz adesea folosit pentru a demonstra că trece prin valoare
deoarece ceea ce face este că creează un temp și schimba parametrii argumentele care sunt transmise.
Deci, dacă avem o funcție numită swap care are două numere întregi, vom crea o temp variabilă locală.
Dacă atribuim parametrului x temp temp va fi egal cu x.
Dacă spunem că x este egal cu y y acum va fi egal cu x vedem y temp y va fi egal cu temp.
Dreapta.
Dar când suntem de fapt numiți aceasta, numim această funcție că trec acele valori x și y va fi local
pentru această funcție.
Aceste variabile nu vor fi modificate în afara acestei funcții și această funcție
demonstrează că este foarte utilă deoarece atribuim vântului sau atribuirea lui X și X și Y este local pentru această
funcție deoarece trece prin valoare.
Ele nu se modifică în afara acestei funcții și de aceea trebuie să folosim variabile globale, dar ele
sunt întregi, sunt doi adolescenți.
X și y nu sunt adrese care sunt numere întregi și acest lucru este semnificativ.
Deci, dacă numim swap și vedem ce înseamnă asta, se pare că vei observa că valorile nu se
schimbă.
Deci, dacă vom crea o variabilă numită a 100 B cu două sute și vom apela.
Imprimăm variabilele înainte de a schimba 100 200.
Apoi vom apela swap variabilele nu vor fi schimbate după ce sunăm după ce le vom imprima din nou.
Deci, uita-te la acest lucru în blocuri de cod și acest lucru va demonstra treci de valoare.
OK, așa este exemplul nostru.
Avem rutina noastră de swap.
Vom schimba valorile datelor care sunt în trecut X și Y o numim cu 100 și 200.
Vom tipări înainte de a apela funcția pe care o vom pronunța după.
El observă, de asemenea, că variabilele AB nu se schimbă niciodată.
Iar motivul pentru asta este că facem trecere prin valoare.
Deci, dacă execut
acest program, putem vedea că înainte de a schimba valoarea de 100 după schimbare, valoarea a fost de 100 și aceeași
pentru B 200 și 200.
Iar motivul pentru aceasta este că pentru că trecem prin valoare dacă trecem prin referință acele
variabile AB s-ar schimba după apelul pentru a schimba.
Acum, ce zici daca folosim aceeasi tehnica trecuta prin valoare, dar copiem indicii Ce crezi ca se
va intampla?
Așadar indicii și funcțiile se descurcă destul de bine împreună.
Puteți să transmiteți un pointer ca argument la o funcție și puteți avea și o funcție de returnare a
unui pointer ca rezultat.
Și vom arăta cum să facem și asta.
Dar trecut prin referință copiază adresa unui argument în parametrul formal Adresa este utilizată pentru a
accesa argumentul real utilizat în apel.
Deci, ceea ce înseamnă că modificările aduse parametrului din interiorul funcției afectează argumentul variabilei care se află
în apel, chiar dacă nu este punct de vedere tehnic sub hood pass prin referință pe care o mimează
sau simulează trece prin referință în cazul în care copiați adresa dacă copiați adresa pe care ați știut-o vreodată
că aveți o adresă nouă și o memorie pentru valoarea respectivă.
Dar dacă încercați să atribuiți acelei adrese, aceasta va da adresa corectă.
Deci, chiar dacă a trecut prin valoare este copierea și dacă copiați un număr întreg normal nu faceți
modificări dacă copiați o adresă, adresa este în memorie, astfel încât
atunci când efectuați modificări veți schimba adresa respectivă.
Așadar, pentru a transmite o valoare prin argumentul referinței, indicatorii sunt transmiși la funcții ca orice altă valoare.
Trebuie să declarați parametrii funcției ca tipuri de indicatori, iar modificările asteriscului din interiorul funcției
sunt reflectate în afara funcției.
Nu este nevoie să utilizați variabile globale la fel de mult ca un apel prin valoare în cazul în care modificările
nu reflectă în afara funcției.
Încă am copiat că trecem încă prin valoare doar la valoarea unei copii a adresei.
OK, acest lucru este un concept important de înțeles.
Acum, atunci când creăm funcția de swap, o vom crea cu declarația din interiorul
funcției ca steluță și stea Asterix care spune că această funcție are indicii.
Acum, când atribuim în această funcție, trebuie să semnați actul.
Trebuie să folosim de fapt operatorul de indirecție pentru a dereferența pentru că vrem să semnem
valorile pe care le vom semna cu valoarea lui x pe care X indică pentru a tampa aloca valorile x valide la valoarea pe
care y dă spre și apoi mergi la găsiți valoarea pe care y indică la temp temp este un
număr întreg, deci nu trebuie să o dereferențăm.
Acum, atunci când o invocăm cu o depășire de 100 pentru a fi de 200, în a și b și b nu sunt
indicii, așa că trebuie să trecem la adresa corectă deoarece funcția ia indicii.
Ori de câte ori aveți o funcție care ia indicatori și nu declarați un pointer trebuie să utilizați
adresa operatorului și este același lucru cu modul în care folosim Scan f.
Dar acum veți observa când vom invoca acest lucru după chemarea de a schimba variabilele și b
vor fi schimbate.
Vor fi schimbate.
Va fi de 200, va fi 100.
Deci, haideți să ne uităm la acest exemplu prin schimbarea metodei swap la indicii din blocurile de coduri.
Blocurile actuale de coduri modificăm funcția swap pentru a lua indicii.
Deci, trebuie să dereference și apoi le atribuim.
De asemenea, trecem acum la adresa a și b deoarece acestea sunt acum întregi și este nevoie de o schimbare.
Acum ia indicii.
Așa că vom rula acest lucru, vom vedea că apelul după va fi acum schimbat.
Deci, acum când sunăm înainte de a apela swap ușor numit 100 după ce numim swap A's 200 înainte de a chema
swap pentru 200 de alte Bede este ulterior 100.
Așadar, putem modifica valorile variabilelor din interiorul funcției, deoarece facem o copie a
adresei.
Foarte important.
Și unul dintre marile avantaje ale pointerului este sintetizarea sintaxei.
Am făcut ceva, dar să trecem mai departe în detaliu.
Puteți comunica două tipuri de informații despre o variabilă unei funcții.
Puteți transmite valoarea lui x în funcție trebuie să fie declarată cu același tip ca X dreapta.
Știm că ori de câte ori transferăm datele unei funcții, trebuie să avem aceleași tipuri atunci când o numim.
Și aici avem o funcție care vrea să o invocăm.
Este definit ca nu.
Deci, atunci când transmitem valoarea lui x în funcție, ele trebuie declarate cu același tip.
Apoi, dacă doriți să invocați o adresă de x, este necesară definirea funcției pentru a
clona un indicator la tipul corect.
Deci, ori de câte ori utilizați indicii, trebuie să vă asigurați că dacă transmiteți date și aceste date nu sunt indicatoare,
trebuie să obțineți adresa acestora.
Din nou, ceea ce rezumă este dacă definiți o funcție care nu ia un pointer pe care
îl puteți numi și treceți în date.
Asigurați-vă că nu este un indicator.
Dacă aveți o funcție care are un pointer în loc de un pointer strict atunci când îl invoca,
trebuie să invocați cu adresa operatorului.
Trebuie să treci adresa în.
Aceasta este sintaxa acum, de asemenea, puteți califica un parametru de funcție utilizând cuvântul cheie constant.
Aceasta indică faptul că funcția va trata argumentul care este transmis pentru acest parametru ca o constantă.
Este utilă numai atunci când parametrul este un indicator.
Dreapta.
Deoarece dacă treceți prin valoare și nu treceți prin pointeri, nu contează pentru că schimbați că
nu va afecta schimbarea din exterior în afara funcției.
Deci, de ce ai face o constantă.
Cui îi pasă dacă schimbați Bolar este și faceți un punct sau un cones, deoarece nu doriți să aveți în
afara valorilor funcției modificarea acestuia, astfel încât să puteți aplica conceptul unui parametru care este un pointer pentru
a specifica că funcția nu se va schimba valoarea la care argumentele arată foarte importante.
Deci, în acest exemplu avem o funcție de trimitere a unui mesaj.
Este nevoie de un pointer de mesaj pe care l-am pus tastatura constanta inainte de steaua char.
Deci acest tip de mesaj de parametru p este un pointer la un caracter constant.
Este valoarea caracterului care nu este constantă decât adresa sa.
Deci, în acest caz, ceea ce facem este indicatorul la care se arată că nu se poate schimba.
Putem schimba adresa dar nu putem schimba ce indică valoarea.
Sintaxa este similară atunci când creăm constante pe alte pointeri.
Cuvântul constant este că este primul lucru care arată că nu poți schimba valoarea pe care ai putea să-l specifici
că pointerul este constant, dar acest lucru nu are sens deoarece adresa este trecută prin valoare.
Nu puteți schimba ordinea într-un pointer și nu apelați funcția de apelare.
Deci, este ca și cum ați încerca să faceți acest lucru pentru ca adresa să nu poată fi schimbată, care
este motivul pentru că a trecut prin valoare.
Deci, de fapt, faci o nouă locație de memorie pentru a ține acea adresă specifică.
Deci, dacă îl schimbați, cine îi pasă nu o va schimba pe partea laterală.
Doar doriți să puteți face parametrul constant, astfel încât să nu schimbați valoarea la care se
îndreaptă.
Nu puteți schimba oricând indicatorul original în funcția de apelare, deoarece este trecut prin
valoarea trecută prin copiere.
Compilatorul știe că un argument care este un indicator al datelor constante va fi sigur.
Deci, există avantaje în acest sens.
Puteți modifica accidental ce indică valoarea.
Deci, puteți face acest lucru din nou dacă nu doriți ca modificările să se reflecte în afara funcției.
Dacă treceți un indicator la date constante ca argument pentru un parametru, atunci parametrul trebuie
utilizat ca în cele de mai sus.
Deci, dacă, atunci când invocați funcția și o treceți într-o constantă, atunci trebuie
să aveți declarația funcției.
De asemenea, luați pointer de caractere constante la fel ca în mod normal.
Alți pointeri care sunt constanți pe care trebuie să fie definiți în definit
trebuie să se potrivească cu prototipul returnând pointerii dintr-o funcție care returnează un pointer dintr-o funcție este o capacitate deosebit de puternică.
Acesta vă oferă o cale de a vă întoarce nu doar o singură valoare, ci un întreg set de valori.
Deci, din nou, unul dintre celelalte avantaje pe care le-am menționat despre indicatori este că acum puteți
reveni la mai multe date dintr-o funcție în trecut.
Puteți numai să returnați o valoare, dar cu un pointer, deoarece un indicator ar putea să indice o structură despre
care nu am vorbit încă.
Comandă și alte lucruri.
Puteți reveni la mai multe valori, astfel încât să știm cum să trecem indicii la funcții.
Acum vrem să vorbim despre întoarcerea indicilor.
Va trebui să declarați o funcție returnând un pointer, astfel încât declarația funcției trebuie să se potrivească.
Este foarte ușor să faci asta spunând că folosiți asteriscul atunci când declarați funcția sau definiți-o și aveți tipul
de retur pentru acest indicator.
Ceea ce indică.
Așadar, aveți grijă dacă există riscuri specifice legate de returnarea unui indicator.
Utilizați variabile locale pentru a evita interferența cu variabila la care argumentul indică.
Este oarecum problematică atunci când vă întoarceți punctul este pentru că dacă modificați acest pointer în interiorul
funcției și apoi returnați-o, ar putea fi ceva pe care nu intenționați să o faceți.
Folosiți întotdeauna variabilele locale.
Dacă nu doriți să afectați o variabilă pe care argumentul dvs. o indică și astfel acest laxer a descris modul în
care puteți transmite pointerii funcțiilor și cum puteți să returnați indicii din funcții și utilizând aceste mecanisme de
trecere a pointerilor la o funcție pe care o demonstrează sau o imită prin referință
deoarece copiați într-o adresă și când copiați o adresă.
Dacă scrieți la acea adresă, veți actualiza ceea ce indică acea adresă, ceea ce înseamnă în mod
efectiv că modificați valoarea datelor din interiorul funcției pe care o va reflecta în
afara funcției.
Utilizăm rutina de swap pentru a demonstra că acesta este un concept foarte puternic și pe care doriți să-l
imitați treceți prin referință.
Puteți utiliza indicii pentru a face acest lucru și doriți să faceți acest lucru atunci când doriți să schimbați lucrurile în afara funcției.
Mulțumesc.