>> LUIDSPREKER 1: Het blijkt dat we kunnen de waarden succes ruilen tegen twee
variabelen door ze in een functioneren niet via waarde of via kopiëren, maar
hand of adressen.
Met andere woorden, we moeten benutten iets bekend als een aanwijzer.
Een wijzer, echt, is gewoon de adres van enkele variabele.
En dus als we bieden een functie genaamd, zeg, ruilen met het adres van
een variabele en het adres van een andere variabele, moet swap worden gemachtigd om
naar elk van deze adressen en eigenlijk veranderen de
waarden zijn.
>> Laten we zien dit in context.
Laten we herimplementeren swap als volgt.
Laten we eerst eens veranderen een een int niet te zijn maar met een pointer naar een int of zijn de
adres van een int.
Laten we dan hetzelfde doen voor b, het veranderen het van een int een pointer naar een te
int of het adres van een int.
>> Dan binnenkant van swap, laten we nog verklaren tmp zodat we een
tijdelijke plek voor een waardeketen.
Maar de waarde niet een zelf, omdat Weer een nu dit adres
sommige int.
Dus als we willen gaan naar dat adres en krijgen int op dat adres, wij hebben
dereferentie deze pointer, ook door middel van de ster operator, het schrijven van een ster.
>> Vervolgens wil ik niet veranderen de waarde van een.
Ik wil de waarde moment veranderen een, rekening houdend met, opnieuw,
dat is een adres.
Dus om dat te doen, ik weer nodig Zeg ster een krijgt.
En nu wil ik in de waarde te zetten dat bij b, niet de waarde van b, waarvan
Ook is een adres.
>> Dus ik zeg nogmaals, ster b.
Dan in mijn laatste regel, ik moet overschrijven wat er op het adres b met
wat er op een originele locatie.
Om dat te doen, ik doe ster b krijgt tmp.
>> Nu aan het eind van de dag, deze functie is nog net
drie regels code.
Maar omdat het manipuleren van waarden via hun adres en niet de
onbewerkte waarden die werden doorgegeven aan de functie, ik beweer dat swap is nu
bevoegd is om de waarden te wijzigen dat worden doorgegeven via hun adressen.
>> Maar ik moet een keer overstappen nog steeds.
Ik kan niet meer passeren x en y zelf.
Ik moet pas in de adressen van x en y.
En om dat te doen, moet ik een iets verschillende notatie boven.
Ik wil x en y wisselen door passeren het adres x, aangegeven met
ampersand x, en het adres van y, aangegeven door ampersand y.
>> Evenzo up top nu moet ik prototype van de functie veranderen
overeenkomen met de verandering die ik heb gemaakt, zodat a is, wederom, een pointer naar een int.
b is, wederom, een pointer naar een int.
En nu kan ik mijn bestand op te slaan.
En laten we opnieuw compileren en draaien.
>> Maak swap dot slash swap.
En deze keer, x en y zijn nu inderdaad verwisseld dat hun waarden niet
1 en 2, maar 2 en 1.