Hallo en welkom.
In deze lezing wil ik het hebben over een paar operators die een beetje vreemd zijn in die zin dat
je niet per se zou denken dat ze operators zijn.
Omdat alle operatoren die we tot nu toe hebben geleerd er eigenlijk gewoon op wijzen dat je weet hoe
je het symbool gebruikt om berekeningen met getallen uit te voeren.
En deze operators zien er eigenlijk uit als functies.
Dus laten we het hebben over de cast in de groottevan de operator.
Om eerst over de cast-operator te praten,
moet ik je iets vertellen over typeconversies, hoe gegevens worden geconverteerd.
We hebben alles geleerd over gegevenstypen en verschillende gegevenstypen die er zijn.
Maar als u daadwerkelijk gegevens aan verschillende typen probeert toe te wijzen,
zijn er enkele impliciete conversies die plaatsvinden in de programmeertaal c.
Dus conversie van gegevens tussen verschillende typen kan automatisch gebeuren en dit
wordt impliciete conversie genoemd door de
taal of expliciet door het programma door het programma of.
De programmeur zelf de ontwikkelaar kan iets doen.
Ze kunnen in wezen een cast-operator gebruiken om een conversie uit te voeren.
De gegevens die impliciet worden geconverteerd, zijn erg
belangrijk omdat je dit moet begrijpen, want het meeste c-programma
dat je gaat ontwikkelen om ze effectief te ontwikkelen, moet je deze
regels voor deze conversies begrijpen.
Omdat je vaak gehele getallen en getallen met drijvende komma, decimale
getallen en gehele getallen zult hebben.
En je gaat ze gebruiken door ze soms een beetje te vermengen.
En als je dat doet, moet je weten hoe dingen worden omgezet.
Probeer dat nu zoveel mogelijk te vermijden door de cast-operator te gebruiken.
Maar als u de cast-operator niet gebruikt, moet u begrijpen wat er aan de hand is.
En wat gebeurt hier als je gegevens toewijst aan verschillende
typen floats en doubles,
de gegevens worden ofwel afgekapt of gepromoot.
Dit zijn twee termen die je gaat horen.
Afgeknotte middelen worden minder nauwkeurig
en gepromoveerd betekent dat het nauwkeuriger wordt.
Probeer deze soorten dus niet te mixen, maar ze kunnen nuttig zijn.
Het belangrijkste om te begrijpen is dat we uit eerdere colleges weten dat c erg flexibel is.
En dat is een bewuste keuze van de ontwerpers van de taal.
Als ze het flexibel wilden hebben, maar nogmaals als een compromis, omdat deze extra
vrijheid je wordt gegeven, kun je
er misbruik van maken. Maak dus geen misbruik
van dit idee van het mengen van soorten.
Probeer zoveel mogelijk dezelfde typen te gebruiken, gehele getallen met gehele getallen, floats met floats.
Maar als u
dat niet kunt, begrijp dan de impliciete conversies of voer de
expliciete conversies uit met behulp van de cast-operator.
Dus nogmaals, een ander probleem
of een ander concept waarbij c flexibel is, maar je moet het niet misbruiken.
Dus wanneer een drijvende-kommawaarde wordt toegewezen aan een integer-variabele in c, dus
je hebt int x, float y, x is
gelijk aan y.
Het decimale deel van het getal wordt afgekapt.
Dus als je een getal hebt dat int x gelijk is aan 0, is
float f gelijk aan 12. 125 en je wijst
f toe aan x, de waarde van x wordt 12.
Je gaat die precisie verliezen. De waarde wordt afgekapt omdat
je een float toewijst aan een int. Een int weet alleen hoe een geheel getal moet worden opgeslagen.
Dus het wordt automatisch geconverteerd door de programmeertaal, door de compiler naar 12.
Alleen de invoer wordt opgeslagen.
Als u nu een integer-variabele toewijst aan een variabele met drijvende komma, wat het tegenovergestelde is,
veroorzaakt dit geen verandering in de waarde van het getal.
De waarde wordt door het systeem geconverteerd en opgeslagen in de zwevende variabele.
Zodat u zich geen zorgen hoeft te maken over het toewijzen ervan in een stroom.
Als je 12 toewijst aan een stroom, wordt het nog steeds 12, slechts 12. 0.
Wanneer je rekenkunde uitvoert op gehele getallen en dit
dus anders is dan alleen het toewijzen van waarden aan een float of float aan int, dan
is dit wanneer je een uitdrukking
hebt, je doet wat optellen of aftrekken, wat het geval ook is.
Als je aftrekt of optelt, heb je twee operanden.
En dus kan één operator een int zijn, en één operand kan een float zijn.
Je moet weten hoe die conversie plaatsvindt.
Dus als je twee operanden in een uitdrukking hebt en het zijn
beide gehele getallen, dan wordt elk decimaal deel dat voortvloeit uit een delingsbewerking weggegooid.
Dus als je dat doet als je een geheel getal x hebt, is dat 20.
Je hebt een geheel getal y, het is 12. En je doet 20 gedeeld door 12.
Je krijgt niet 1 punt iets iets iets. Je krijgt er gewoon 1.
Het gaat alle resultaten weggooien en een nieuwe geven, want opnieuw slaat een int alleen een geheel getal op.
Dus twee getallen zijn ints en ze doen deling.
Je krijgt geen floating point getal. Je krijgt geen decimaal getal.
Als nu de ene operator een int is en de andere een float, dan
wordt de operatie gevormd als een drijvende-kommabewerking. Dus als je float hebt, is f 20. 0, float a is 10,
een int, en als je daar een deling
doet of 12, het spijt me dat dat meer van toepassing is, dan
zal het resultaat een floating point getal zijn en
het resultaat wordt 1 punt 8888 of wat het ook is, 1
punt, hoe dan ook.
Je wijst deze gegevens nergens aan toe. Dit is een uitdrukking wat het gaat teruggeven.
Dus twee ints in een divisie, het wordt een geheel getal.
Een int en double of float, het zal altijd een float zijn, het zal altijd
een decimale decimale drijvende-kommabewerking zijn.
En dit is de impliciete conversie. Dat is echt wat je nodig hebt om te
begrijpen wat er aan de hand is en voor je wordt gedaan door het programma als je niets doet.
U moet echter proberen enkele expliciete
conversies uit te voeren, wat u kunt doen met de cast-operator.
En dit wordt gewoon min of meer casten genoemd.
En je ziet casten in veel talen als je wilt converteren.
En het enige dat u doet, is expliciete
conversie, u zegt wat u wilt dat de gegevens zijn.
Dus je wilt dit doen als je kunt, want
anders kunnen gegevens worden gedegradeerd, waardoor ze verloren kunnen gaan.
Als je twee ints doet en je doet de verdeling
en ze zijn niet gelijk verdeeld, verlies je al die gegevens.
U kunt dus de precieze typeconversie eisen die u wilt
door deze expliciet te specificeren.
Dit wordt een cast genoemd en bestaat uit het voorafgaan van de
hoeveelheid met de naam van het gewenste type tussen haakjes.
Dus haakjes en
typenaam vormen de
cap-operator.
U maakt een linkerhaakje en vervolgens geeft u het gegevenstype op en schrijft u vervolgens haakjes.
En dat zal alles wat er rechts van staat,
wat de uitdrukking er ook is, of zelfs als het maar een enkele variabele
is, omzetten naar wat er ooit tussen de haakjes staat.
Dus het eigenlijke type is gewenst, zoals een lang, het wordt vervangen door dat woordtype.
Dus de type doorgegeven operator heeft een hogere prioriteit dan alle rekenkundige operatoren behalve de
unitaire min en unity plus. We hebben nog niet geleerd over voorrang.
Dat gaan we doen in de volgende lezing. Voorrang is in feite wat
er gebeurt, de volgorde van de bewerkingen die worden uitgevoerd.
Daarom geven we daar enkele voorbeelden van. Het enige dat u op dit punt moet
begrijpen, is dat de typecast-operator voorrang heeft op elke andere operator, behalve twee unaire min en unaire plus.
Dus hier hebben we een nummer 21. 51 en we hebben de
cast-operator omdat we weten dat het cast-operator is omdat het tussen haakjes
staat en het een type heeft. En wat we eigenlijk zeggen
is take 21. 51 converteer het naar een int.
Als je een getal met een drijvende komma erin
omzet, wordt het gewoon de int, het hele getal, 21.
Hetzelfde doet het aan de rechterkant, het converteert 26. 99 tot een int.
Dus wat zou hier eigenlijk gebeuren als je deze uitdrukking in een verklaring zou doen, het
zou worden geëvalueerd als 21 plus 26. Het zou de gegevens
van 0 afkappen. 51 tot een geheel getal en hetzelfde als 0. 99.
En dat is dus de cast-operator, alles tussen haakjes dat een gegevenstype bevat.
Dit zul je veel zien.
Als je 21 plus 26 zou zeggen en je werpt het in drijvers, dan zou het
gewoon een punt 0 toevoegen.
Meestal werp je niet naar een preciezer type omdat je
niet nauwkeuriger gaat worden.
Je werpt van een nauwkeuriger type naar een minder nauwkeurig type.
Dus meer van een float naar een int.
Je zult dit dus af en toe in sommige programma's zien
als je verschillende typen gebruikt. Je moet proberen om verschillende typen te vermijden
als je aan het rekenen bent. Maar als je dat doet, zul je dit zien.
De grootte van de operator, een andere operator die nogal vreemd is,
niet vergelijkbaar met veel van de andere. En dit ziet er eigenlijk uit als een functie.
Maar de sizeof is een operator. Het voert een actie uit.
Het doet niets functiegericht.
Wat het doet, is dat het je vertelt hoeveel bytes in het geheugen worden
ingenomen door een bepaald type. Het lijkt dus op een functie omdat er een argument voor nodig is.
En daar gaan we een voorbeeld van geven maar het gaat gewoon het aantal bytes in het geheugen teruggeven. Onthoud dat, afhankelijk van het
systeem dat u gebruikt, het platform
dat u gebruikt, het besturingssysteem, de architectuur van de computer,
de hardware, verschillende gegevenstypen geheugen met verschillende groottes zullen worden weergegeven.
Een int kan bijvoorbeeld 4 bytes zijn op het ene systeem 8 in het andere.
Dus wat je kunt doen, is dat je de operator sizeof als een speciaal sleutelwoord een operator in c kunt gebruiken en
je kunt een gegevenstype doorgeven en het zal je vertellen hoeveel bytes het in het geheugen gebruikt.
Dus sizeof is eigenlijk een operator, het is geen functie.
Het wordt geëvalueerd tijdens het compileren en niet tijdens runtime, tenzij een array met variabele lengte wordt gebruikt in het argument.
En dus vermelden we dat. Dit wil in feite zeggen dat als je
een variabele hebt die zich binnen de grootte
van een array bevindt, deze niet zal worden opgelost tijdens het compileren tijdens runtime, dus niet
zo belangrijk om te weten.
Het argument voor de operator sizeof kan een variabele zijn,
een arraynaam, de naam van een basisgegevenstype,
zoals int float, de naam van een afgeleid gegevenstype of een uitdrukking.
Dus je zou kunnen zeggen sizeof x plus y.
En dat is eigenlijk gewoon de grootte van x plus
de grootte van y of de resulterende getallen. Als x een int is, y een int en een grootte van 16, dan
zou dit zeggen dat dit een inch 4 bytes is.
Als het int one een float was en het resultaat een drijvende-kommaberekening was,
dan zou float 8 bytes zijn of zoiets.
Maar je kunt het voor veel dingen gebruiken, en je zou het voor veel dingen moeten gebruiken. Sizeof int, bijvoorbeeld, zal resulteren in het
aantal bytes dat wordt ingenomen door een variabele van het type int.
Dit zou dus 4 of 8 opleveren, afhankelijk van uw systeem.
Je kunt ook de operator sizeof toepassen op een uitdrukking, zoals ik al zei,
het resultaat is de grootte van de waarde.
Dat vloeit voort uit de gebiedsuitdrukking. Dus als twee ints samen zijn, zullen ze nog steeds een int zijn.
Het wordt dus nog een maat. Maar je zult zien dat de operator sizeof ook wordt gebruikt als we het over pointers hebben.
Ik wilde hier nu over praten omdat het een telefoniste is.
Maar we gaan hier nog veel meer voorbeelden van geven en casten tijdens de les
terwijl we over meer concepten praten.
In het bijzonder speelt de operator sizeof veel meer een
rol als we het over pointers
hebben, want als je berekent hoeveel geheugen je moet toewijzen, wat pointers zijn, gebruik
je sizeof omdat je precies wilt zijn.
Maar je kunt het ook voor andere dingen gebruiken.
Gebruik dus waar mogelijk de operator sizeof om te voorkomen dat u de grootte van harde codes in
uw programma moet berekenen.
Magische getallen in harde code zijn geen goede zaak, want nogmaals, als je op
een ander systeem zit, als je 4 op 1 systeem hard zou
coderen voor een int, kan het andere systeem een 8 zijn, dus gebruik sizeof
zoveel als dat kan en we zullen zien dat dit veel meer herkenbaar is
als we het over aanwijzingen hebben.
Andere operators die
een beetje vreemd zijn, zijn de asterisk-operator.
Je hebt misschien tegen jezelf gezegd asterisk, we hebben hier al in vermenigvuldiging over gesproken.
Maar voor dat sterretje zijn twee operanden nodig, een aan de linkerkant en een aan de rechterkant.
Als u de asterisk-operator op een variabele
toepast en u zegt de naam van de stervariabele met slechts één argument aan
de rechterkant, vertegenwoordigt dit iets anders. Het is eigenlijk een aanwijzer.
Het verwijst naar een pointer.
En nogmaals, ik ga hier nu niet op hameren, want we gaan dit doornemen
als we het over aanwijzingen hebben.
Maar als je iets als ster a ziet, schrik dan niet, dat is echt waar.
Dat is het sterretje van de aanwijzeroperator.
Mogelijk ziet u ook de dubbele punt met het vraagteken.
Dit is een operator die wordt gebruikt voor besluitvorming.
Als de voorwaarde waar is, als het ding aan de linkerkant waar
is, wordt de waarde rechts na de dubbele punt geëvalueerd, enzovoort.
Het is een verkorte notatie voor een if-else-statement.
Het is een ternaire operator, heet dat. Maar nogmaals, ik wil deze nu
niet echt in detail bespreken, want
we gaan erover praten als we het hebben over onze
specifieke onderwerpen.
We zullen het hebben over de draai-operator als we het hebben over beslissingsverklaringen. We zullen het hebben
over de asterisk-operator unary als we het hebben over pointers.
Maar als je dit nu ziet en ik wilde het nu noemen omdat het technisch gezien operators zijn, maar we
zullen hun gebruikssituaties begrijpen als we het over die concepten hebben. Dank u.