Hallo en welkom.
Laten we onze discussie over gegevenstypen voortzetten en er in deze lezing nog een paar
bespreken, we gaan het hebben over het Inam-gegevenstype en het auto-onderhoudsgegevenstype.
Dus items van vijanden zijn een gegevenstype waarmee een programmeur een variabele kan definiëren en de geldige waarden kan specificeren die
in die variabele kunnen worden opgeslagen.
Dus An is erg krachtig.
Het specificeert eigenlijk een gegevenstype.
Het is het sleutelwoord enum, maar u kunt in principe uw eigen gegevenstype hebben dat alleen bepaalde waarden bevat.
U kunt bijvoorbeeld een variabele maken met de naam mijn beller-ID.
Als het een bepaald enum-type is, kun je het zo instellen dat het alleen of alleen waarden van primaire kleuren
zoals rood, geel of blauw bevat, en dan kunnen er geen andere waarden aan worden toegewezen.
De compiler geeft je een foutmelding.
En dus is het een soort datatype dat je kunt specificeren dat je kunt creëren, maar je zult dus het
datatype moeten definiëren en dan zul je variabelen van dat type moeten creëren.
Een item is dus het sleutelwoord.
Dus het eerste dat u moet doen als u dit gegevenstype wilt gebruiken, is dat u dat in type moet definiëren en
het een naam moet geven, alleen een identifier, net als een variabelenaam.
En de manier waarop u het doet, is dat u het trefwoord gaat gebruiken.
En dan na het enoki-woord, ga je een naam geven zoals een identifier.
En dat je na de identifier de hele lijst met geldige waarden binnen accolades gaat halen, en
je zegt eigenlijk dat dit alleen deze waarden kunnen zijn, en als je later wilt gebruiken,
declareer je, je maakt een variabele van dat type enum.
Dus laten we dit hier in actie zien.
Ik definieer een opsommingstype dat primaire kleur wordt genoemd.
Dus ik heb het toetsenbord en dan heb ik mijn naam van mijn enum, die primaire kleur is, en dan
definieer ik alle geldige waarden voor dat type.
En je zult zien dat ze zijn ingesloten in accolades.
De linker accolade en de rechter accolade.
In dit geval hebben we een soort opsomming met de naam primaire kleur die alleen de waarden rood, geel en blauw kan
bevatten.
En het kan niets anders opslaan als u een waarde probeert toe te kennen aan de primaire kleur of als u het gegevenstype primaire kleur probeert
te gebruiken en u probeert een variabele waarde toe te wijzen, iets anders, het zal niet werken.
Dit is dus precies hoe we het definiëren.
We moeten eerst enum definiëren.
We hoefden het niet meer te gebruiken.
Definitie is gewoon zeggen dat dit is wat het is.
Dus wat we hier zeggen is dat we een primaire kleur hebben in wat het kan zijn, is rood, geel en blauw.
Dus variabelen die zijn gedeclareerd als het primaire kleurtype kunnen alleen de waarden rood, geel en blauw in het
programma worden toegewezen, andere waarden zullen niet werken.
Dus nogmaals, de eerste stap om het te vinden, de tweede stap is het gebruiken.
Dus nadat we het hebben gedefinieerd, kunnen we een variabele van dit type primaire kleur declareren en de manier waarop we de
variabele nu declareren is dat we nog steeds het enoki-woord gebruiken.
We hebben dan eigenlijk de naam van de opsomming die we hebben opgegeven toen we deze definieerden.
En dan helemaal aan het einde, volgen we dat met een verbaal.
Dus hier is een voorbeeld: we hebben energie, we gebruiken het toetsenbord, we hebben de naam van de opsomming die we willen gebruiken,
die we zojuist hebben gemaakt, primaire kleur genoemd, en dan hebben we alleen maar namen.
Dus hier hebben we er twee in termen van type primaire kleur, mijn kleur in de kleur van Greig.
Dus nogmaals, dit is waar we de ENIM gebruiken, we hebben al gedefinieerd wat
het genoom kan zijn, alleen rood, geel of blauw, en nu zeggen we dat we twee variabelen hebben genaamd mijn kleur
en Greig's kleur die kunnen slechts één van die drie waarden bevatten, kan niets anders bevatten.
Dus hier declareren we een variabele van primaire kleur.
En nogmaals, dit is het definiëren van twee variabelen.
Mijn kleur en geweldige kleur om van het type primaire kleur te zijn.
Wat een itemtype is, de enige toegestane waarden die aan deze variabelen kunnen worden toegewezen, deze twee variabelen
zijn rood, geel en blauw.
Dus we zouden kunnen zeggen dat mijn kleur gelijk is aan rood en dat is volkomen terecht.
We konden niet zien dat mijn kleur gelijk is aan groen.
Dat werkt niet omdat die waarden niet geldig zijn voor dat itemtype.
We kunnen niet zeggen dat mijn kleur gelijk is aan Jason, omdat mijn kleur maar drie waarden van het type primaire
kleur enum kan bevatten.
Dit is dus een zeer krachtig gegevenstype, omdat u in wezen uw eigen gegevenstypen definieert die alleen
bepaalde waarden kunnen bevatten.
Een ander voorbeeld zou zijn als we een opsomming maken van het type maand en hier zeggen we dat de maand alleen gelijk
kan zijn aan januari, februari, maart, april, mei, juni, juli, augustus, tambour,
oktober, november, December.
Nogmaals, dit is de definitie.
Dit is waar we zeggen wat de geldige waarden zijn.
Als we maand zouden gaan gebruiken, zouden we een variabele maken met de naam in een maand en dan welke naam je het ook
wilt geven.
En dan kunnen we aan die naam elk van deze geldige maanden toewijzen, van januari tot december.
En zo gebruik je Anina.
Nu onder de motorkap, voor zover items worden geïmplementeerd in een afzonderlijke programmeertaal, wordt dit echt
weergegeven door cijfers?
Dus de compiler behandelt enumeratie-ID's eigenlijk als integer-constanten.
Dus de eerste naam in de lijst die u definieert, als u zou proberen de waarde af te drukken, zou een
nul zijn.
Dit alles zegt weer, hoe worden ze gedefinieerd?
Als u de Alpe zou weergeven, wat zijn dan de werkelijke waarden?
Dus wat dit betekent is dat als we deze maand een maand hebben, we een nieuwe variabele van het type in een maand hebben gemaakt en
dan zeggen we dat deze maand gelijk is aan februari.
Deze maand is eigenlijk gelijk aan een geheel getal.
Maar we kunnen het nog steeds vergelijken en gebruiken om het te vergelijken met februari, maar als je deze maand
zou uitprinten voor de gemeente, zou deze maand eigenlijk een geheel getal zijn dat overeenkomt met wat het in de lijst
was gedefinieerd.
Dus in dit geval zou februari er een zijn, omdat de opsomming van deze maand februari is.
Rechts.
Dus als we teruggaan, als je je herinnert wanneer we het definieerden, de tweede is februari en je zou moeten opmerken dat het één
is, ook al is het de tweede, want wat dat betekent is dat de lijst bij nul begint.
Dus januari zou nul zijn, februari één, maart zou twee zijn, enzovoort.
En dit is belangrijk omdat u het dan kunt vergelijken met en vergelijken met werkelijke waarden
zoals februari.
Als u nu een specifieke integerwaarde wilt koppelen aan de nummerings-ID, kunt
u expliciet iets toewijzen met behulp van de toewijzingsoperator wanneer u het type definieert.
Dus, hier, bijvoorbeeld, als we een nieuwe opsomming van type richting definiëren en we zeggen dat de waardewaarden voor
richting omhoog, omlaag, links en rechts zijn, dan zul je zien dat de derde waarde links eigenlijk gelijk
is aan dat zeggen dat links gelijk zal zijn aan 10.
Dus in dit geval wordt onze richting van het type enum gedefinieerd met de waarden omhoog, omlaag, links en rechts.
Dat zijn de enige geldige waarden die u kunt toewijzen.
Variabelen van dit type up zullen gelijk zijn aan nul omdat dit het eerste element in de lijstdefinitie is.
Eén wordt gelijk naar beneden omdat het het tweede element is.
Nogmaals, het begint bij nul.
Tien wordt gelijk, links wordt niet gelijk aan twee omdat we het expliciet gelijk aan
10 toekennen.
Dus veel wordt 10, want dat is wat we in onze definitie zetten en dan goed.
Zal gelijk zijn aan 11 omdat het de onmiddellijk volgende zal zijn.
Het is de volgende, dus als we een andere waarde hadden en er zouden 12 zijn, dan kun je expliciet waarden
toewijzen als je wilt.
Maar nogmaals, dit is belangrijk, want als je vergelijkingen maakt of als je de waarden uitprint, moet je weten
dat de vijanden in feite worden weergegeven als gehele getallen in het systeem.
Maar je kunt februari, maart, januari nog steeds gebruiken wanneer je je bij je vijand aanmeldt, wanneer je die waarden
daadwerkelijk vergelijkt met een andere waarde die je kunt gebruiken.
Januari, februari, maart, je kunt nog steeds die mooie namen gebruiken.
Dus we gaan een leuke kleine opdracht of uitdaging voor items hebben, zodat je er wat meer vertrouwd mee kunt
raken, maar het punt hier is hoe je een itemtype kunt maken en hoe je dan variabelen van dat type
kunt behouden en toewijzen waarden?
En nogmaals, het is leuk omdat je kunt bepalen wat er wordt toegewezen.
Als je niet wilt dat de richting wordt toegewezen, weet je, de rechterhoek, definieer gewoon omhoog, omlaag, links en
rechts.
Een ander belangrijk datatype dat ik wil bespreken is CHA of care, afhankelijk van hoe je het uitspreekt, hebben
we het vooral gehad over numerieke datatypes.
We hebben het nu gehad over de Inam Cha die een enkel karakter vertegenwoordigt, zoals de Lettow A.
De cijferkenmerken of puntkomma en wat je hier ziet zijn de enkele aanhalingstekens, de reden dat we hun karakters kennen,
ook al is één een getal, is omdat het tussen enkele aanhalingstekens staat.
Dus alles tussen enkele aanhalingstekens in een programma wordt een karaktergegevenstype genoemd.
En meestal zijn de tekens alfanumerieke tekens zoals ABCDE, cfg, maar het kunnen nog steeds
echte cijfers of andere tekens op het toetsenbord zijn.
En u kunt tekenvariabelen ook als niet-ondertekend declareren, niet-ondertekend betekent alleen dat ze niet negatief kunnen
zijn.
Dus het maakt niet uit, het heeft niet echt veel zin.
Maar wat het de compiler vertelt als je een niet-ondertekend teken hebt, is dat het slechts een positief
getal is, want onthoud, tekens kunnen ook worden weergegeven als getallen in de ASCII-tabel.
En daar hebben we het straks over.
Maar we zullen het erover hebben dat je het karaktergegevenstype ook niet wilt verwarren met tekenreeksen, een
karaktergegevenstype is slechts een enkel teken tussen enkele aanhalingstekens.
We hebben een heel ander gedeelte waar we het over snaren gaan hebben.
Dit zou een reeks karakters zijn, een aantal karakters.
Dus verwar karakter of char niet met karakter, string of string.
Als u karakter wilt declareren en gebruiken, kunt u eenvoudig het datatype care specificeren en vervolgens de
identifier.
Dus in dit voorbeeld hebben we charbroiled.
Dat is het declareren van een variabele met de naam broiled van het type char, wanneer we die variabele toewijzen, zetten
we de waarde tussen enkele aanhalingstekens.
Dus gekookt is gelijk aan thee is prima.
Als we gekookte gelijken proberen te zeggen, zit TNT niet in Quartz.
Dat is niet oké, want thee is een variabele.
En dat is pas geldig als hij ook een type CHA is.
Hier hebben we broiled is gelijk aan dubbele aanhalingstekens T. Nogmaals, dat is niet geldig omdat dubbele potentie betekent dat het
een string is, waar we meer over zullen praten, maar dat is niet geldig.
Dus als je momentos bent, enkele aanhalingstekens, zal de compiler gewoon denken dat T de naam van
een variabele is en dat het niet gaat werken.
Als je dubbele aanhalingstekens gebruikt, zal het denken dat je een string gebruikt, zoals ik al zei.
U kunt ook numerieke codes gebruiken om waarden voor tekens toe te kennen en het zal alleen de ASCII-tabel gebruiken.
Dus de ASCII-tabel is hoe tekens worden weergegeven als getallen in de computer.
Dus er is deze hele tafel.
En eigenlijk, als je een nummer toewijst aan een tekentype, gaat het denken dat je de ASCII-waarde
toewijst.
Dus wat het gaat doen, als je vijfenzestig aan cijfer toewijst, zal het 65
opzoeken in de ASCII-tabel en het zal het equivalent zijn van welk personage dan ook.
En je zou in de ASCII-tabel moeten kijken om te zien wat dat karakter is.
Maar weet je, NLB is als 48.
Nogmaals, dit is de manier waarop de computer bepaalde tekens door cijfers weergeeft.
U kunt dus geen cijfers toewijzen aan tekens.
Ze worden gewoon geconverteerd naar enkele tekens op basis van wat ze in de ASCII-tabel zijn.
Escape-tekens, dit is een specifieke term die je zult horen over waar het in feite een speciaal teken
is.
Dat vertegenwoordigt een actie in de programmeertaal C, dus je kunt bijvoorbeeld een speciaal teken hebben
dat een backspace vertegenwoordigt of een speciaal teken dat de nieuwe regel vertegenwoordigt.
Of speciaal teken dat de terminal vertegenwoordigt, Bellary.
En je kunt zijn acties weergeven door in feite een onhandig symbool te gebruiken, zoals een personage tussen enkele aanhalingstekens, en ik ga
je enkele voorbeelden geven.
Dit worden ook wel ontsnappingsreeksen genoemd.
Dit zijn speciale tekens die acties vertegenwoordigen.
Dus escape-reeksen worden ook tussen enkele aanhalingstekens geplaatst wanneer ze worden toegewezen aan een
tekenvariabele. Je ziet deze escape-reeksen ook vaak binnen tekenreeksen om een actie weer te geven.
Dus hier hebben we bijvoorbeeld teken X gelijk aan enkel aanhalingsteken, backslash N.
En je zult merken dat veel van de escape-personages beginnen met een backslash, maar een backslash en is een enkel teken en het
ziet er een beetje vreemd uit.
Wat het in een programma vertegenwoordigt, is dat het een nieuwe regel vertegenwoordigt.
Dus als je zou proberen om dat teken af te drukken, zou het geen backslash afdrukken
en een nieuwe regel afdrukken.
Je zou een nieuwe regel zien, print hem uit.
Dus haaien vertegenwoordigen dit teken, en als je variabele X zou afdrukken, zou het gewoon naar de volgende regel
gaan.
En er zijn een aantal verschillende ontsnappingsreeksen, hier is een leuke kleine tabel die ik uit het Sea Primer plus-boek heb
gehaald en die alle ontsnappingspersonages vertegenwoordigen die je kunt gebruiken om acties weer te geven.
Dus we noemden de backslash en dat is een nieuwe regel.
Backslash R is een regelterugloop.
Backslash V is een verticaal tabblad.
Backslash T, ik denk dat het een horizontaal tabblad is.
Dus laat me je enkele voorbeelden hiervan geven en je ook enkele voorbeelden geven van een opsomming in onze mooie
codeblokken-editor.
Dus we zijn hier, we hebben ons vertrouwde programma met onze hoofdmethode en een in opnieuw in Inam is leuk omdat
je kunt bepalen welke waarden eraan worden toegekend.
Maar er zijn twee stappen.
Wanneer u een enum maakt, moet u het type definiëren en vervolgens moet u de variabele
van dat type maken en u gebruikt het trefwoord voor beide.
Dus als ik een nieuw type enum wil maken en ik wil een naam, dan laat ik deze vijand enkele waarden noemen.
Ik zou bijvoorbeeld een soort vijand kunnen creëren, laten we zeggen.
Elk type geslacht dat we in geslacht zien, en dan gebruiken we alleen de achterkant, het kronkelige haakje, niet te verwarren met
de vierkante haken, het kronkelige haakje, en we definiëren vervolgens de lijst met waarden die geslacht in
principe kan zijn. een man zijn.
En toen scheidden we met komma's en toen een vrouw.
En dan eindigen we het met een puntkomma en wat dit zegt is dat we een nieuw type hebben genaamd
geslacht, het is een type-enum, en de enige waarden die kunnen worden toegewezen aan variabelen van dit type zijn mannelijk en vrouwelijk.
Als we deze opsomming willen gebruiken, kunnen we een nieuwe variabele maken.
We hoeven alleen maar de naam van het type gender op te sommen, en dan kunnen we gewoon mijn mijn geslacht zeggen.
Rechts.
En zo declareren we de variabele.
We verklaren variabele mijn geslacht, maar we hebben een toegewezen of geïnitialiseerde waarde, alleen waarden die we
aan onze mannelijke vrouw kunnen toewijzen.
Dus we zouden kunnen zeggen dat mijn geslacht gelijk is aan man en dat klopt.
En als we zouden gaan compileren.
Dit zou goed zijn, er is geen airs.
En als we probeerden iets anders toe te wijzen, zoals laten we zeggen dat we het willen toewijzen en laten we proberen te
zeggen dat we nu een nummer vierenveertig willen aanmelden als we dit proberen te bouwen.
Je zult zien dat het goed is gebouwd zonder een fout omdat het een KNO-arts was, maar als we zouden proberen het in een string
te stoppen, zou iets waardevoller zijn.
Het gaat om incompatibele typen te zeggen bij het toewijzen, dus daar is een fout.
Het is vrij moeilijk te zien, maar in principe mogen we hier geen string toewijzen.
Omdat het niet het juiste type 44 is, kun je alleen een man of een vrouw ondertekenen, en
nogmaals, als we zouden proberen te zien wat dit vertegenwoordigt in termen van gehele getallen, zodat we kunnen typen, kunnen
we man zeggen, we kunnen het dan daadwerkelijk vergelijken naar andere variabelen, zodat we een ander geslachtstype van een ander geslacht kunnen creëren.
U wilt hier altijd goede naamgevingsconventies gebruiken.
Zorg ervoor dat we correct spellen.
Dat is wanneer we vrouwelijke God kunnen zeggen en dan kunnen we eigenlijk zeggen maak een booleaanse waarde om
waar of onwaar te zien, zou kunnen zeggen dat Boulle mannelijk is en we zouden kunnen zeggen dat het gelijk zal zijn aan mannelijk gelijk aan vrouwelijk.
Het spijt me, geen mannelijk casino, maar mijn geslacht is gelijk.
Een ander geslacht, en dit zou eigenlijk onwaar retourneren, omdat mijn geslacht niet gelijk is aan een ander geslacht, mijn geslacht is gelijk aan
mannelijk, een ander geslacht is gelijk aan falen.
Vrouw sorry en is mannelijk zou een valse waarde of nulwaarde zijn.
We kunnen echter ook de waarden van Venom's zien door ze aan te wijzen.
En wat zal opvallen is dat als we de waarde van de enum gender zouden afdrukken, waarvan we nog niet hebben geleerd
hoe we variabelen moeten afdrukken, maar we kunnen zoiets doen als print f, we dat geslacht, mijn geslacht, zouden
opmerken
is eigenlijk gelijk aan nul, want dat is de eerste in de lijst.
Een ander geslacht wordt gelijk aan één.
Dus dat is best netjes.
Ik wil ook een beetje over Chass praten. Onthoud dat we Chass losse karakters
kunnen maken met variabele namen.
We gebruiken gewoon het Charr-type.
En dan zeggen we iets als, Char, mijn karakter, en we kunnen gelijk zijn aan alles tussen enkele aanhalingstekens.
Het kan JMF zijn, wat we ook kunnen, zelfs PSINet-variabelen die ASCII-nummers in de tabel vertegenwoordigen.
Maar wat dit leuk is, is dat je het escape-tekens kunt toewijzen die
specifieke
acties vertegenwoordigen, zoals een backslash n. zou kunnen zeggen print F, we
moeten zoiets doen als oh procent C, waarover we het hebben over onze volgende
lezing en dan mijn karakter uitprinten.
En dat zou eigenlijk een nieuwe regel op het scherm weergeven, alleen een regelinvoer.
Dus als we dit zouden bouwen.
En we zouden het moeten runnen.
Wat we eigenlijk zouden zien, is dat de output slechts een nieuwe regel is.
Dus je ziet het daar een beetje, er is daar een nieuwe regel, dus het is een specifieke actie waar je
niet op wijst in het album, maar we zullen meer voorbeelden hiervan doornemen.
Wat ik hier probeerde aan te tonen, is dit mooie concept van een opsomming en karakters en ontsnappingsreeksen.
SCAP-personages zijn een geweldige manier om te leren.
Veel van dit soort dingen zijn gewoon spelen met typecode in de ID en kijken wat het doet.
Maar om dit aan te vullen, zal ik u enkele uitdagingen geven om u ook bij uw beoordeling te helpen.
Hoop dat dit heeft geholpen.
Dank u.