Hallo en welkom. In deze video wil ik
de oplossing voor onze oefening voor het gebruik van enum-typen demonstreren.
Dus ik ga ervoor. U herinnert zich deze oplossing.
Het komt erop neer dat u een enum met de naam bedrijf maakt,
er enkele waarden voor definieert en deze uitprint. Dus ik ga codeblokken uitvoeren.
Ik ga een nieuw project aanmaken. Ik ga dit project een voorbeeld noemen,
want dat is er goed voor. Het gaat omhoog naar het bestand, zeg maar
een nieuw, nieuw project.
We zouden hier redelijk goed in moeten worden door nu consoletoepassing c te selecteren.
En we gaan deze opsomming een voorbeeld noemen en het zal
alles op onze gebruikelijke plek zetten.
Ik ga de volgende raken en afmaken.
En dit zal onze belangrijkste creëren. c-bestand, wat goed is. We gaan aan
de slag, verwijder gewoon een deel van de gegevens.
Nogmaals, we kunnen bovenaan opmerkingen toevoegen voor de auteur en de bron.
We zouden dat moeten doen voor een goede oefening.
Voor demonstratiedoeleinden en alleen efficiëntie, laat ik
dat blanco. Maar u zou opmerkingen in uw broncode moeten toevoegen.
Dus de vereisten voor deze uitdaging waren om
in feite een opsomming te maken met
de naam bedrijf. En dan het bedrijf, ze
kan alleen geldige waarden hebben van Google, Facebook, Xerox, Yahoo
eBay en Microsoft en dan
drie variabelen maken en ze enkele waarden toewijzen en die
waarden vervolgens uitprinten.
Dus als we een enum-type willen maken, moeten we het sleutelwoord enum gebruiken.
Dus zeggen we enum.
En dan willen we de naam van de opsomming specificeren. In dit geval gaan we het bedrijf noemen.
En om geldige waarden van dit enum-type te specificeren, moeten we
het kronkelige haakje gebruiken, dat zich direct boven de puntkomma op het toetsenbord bevindt,
en dan kunnen we gewoon onze namen intypen.
Hier, ik ga Google zeggen, ik ga alles in hoofdletters zetten, gewoon
omdat het gemakkelijker te zien is. Facebook wordt onze tweede.
Xerox, onze derde.
Yahoo, onze vierde.
eBay en vervolgens Microsoft.
En dat is het. Dit is hoe u een nieuw enum-type met de naam bedrijf kunt maken.
En dit zijn de enige waarden die voor deze opsomming kunnen worden toegepast.
Dus alle variabelen die u van dit type maakt, kunnen geen andere waarden bevatten.
Dus het eerste deel van opsommingen is ze te definiëren, te definiëren wat ze zijn en ze
vervolgens te gebruiken.
In regel 6 definiëren we het. We zeggen dat een bedrijf
alleen waarden van Google, Facebook, Xerox, Yahoo, eBay en Microsoft kan hebben.
Het volgende onderdeel van de opdracht was het maken van een aantal variabelen.
Drie variabelen met waarden van Xerox, Google en eBay in zich.
Om een enum-variabele van het type bedrijf te maken, hoeft u alleen maar enum te zeggen.
De naam van de naam van het type dat bedrijf is en vervolgens de naam van de variabele.
Hier kunnen we gewoon zeggen, laten we het Xerox noemen.
En we gaan die declaratie op dezelfde regel initialiseren,
dus we gaan de equals-operator gebruiken, en we gaan zeggen
dat dat gelijk is aan Xerox.
Dus onthoud, de naam bedrijf, er kan geen waarde aan worden toegekend.
Als ik dit zou doen en het zou bouwen, zou het goed
compileren omdat
we die variabele daadwerkelijk kunnen toewijzen. Maar als ik iets anders zou proberen te ondertekenen,
zoals mijn naam, zou
je een compilerfout krijgen omdat dat niet geldig is.
Mijn build-bericht hier zegt incompatibele typen bij het initialiseren van type
enum company met een teken.
Er is dus een fout opgetreden en ik kan die niet uitvoeren.
Dus de compiler beschermt je eigenlijk tegen wat je aan de opsomming kunt toewijzen.
Dus nogmaals, we gaan gewoon zeggen Xerox.
We hoeven dat niet tussen dubbele aanhalingstekens te zetten.
We hoeven niets te doen omdat het de werkelijke waarde is.
We willen er nog een paar maken. Een voor Google en een voor eBay.
Dus hier ga ik zeggen bedrijf Google.
Ik ga dat allemaal in hoofdletters GOOGLE toewijzen.
En dan heet de derde die ik ga maken eBay.
Alle kleine letters zijn de naam van de variabele.
De waarde van die variabele wordt enumwaarde eBay.
En wat je zou moeten doen als je deze code schrijft
in alle voorbeelden die ik heb gegeven. Je moet kleine stukjes schrijven.
Schrijf een paar regels compileertest.
Schrijf niet veel code en voer het uit. En sommige van de voorbeelden die ik
hier demonstraties doorloop, verzamel ik aan het einde omwille van de efficiëntie.
Maar als nieuwe ontwikkelaar en nieuwe programmeur
zou je na een paar regels code en testen moeten compileren.
Dus nadat ik mijn enum-type op regel 6 had gemaakt, zou ik dat moeten compileren en testen.
Je kunt niet veel testen, maar je kunt het in ieder geval compileren.
Regels 8, 9 en 10, ik zou moeten compileren en zo verder gaan.
Nadat we de opsommingen hebben gemaakt, kunnen we
hun waarden afdrukken. We weten hoe we waarden moeten afdrukken met behulp
van de functie printf. Alles tussen de dubbele aanhalingstekens voor de printf wordt weergegeven als uitvoer.
Dus ik ga gewoon zeggen dat de waarde van Xerox is, zet er
een dubbele punt in, ik moet een formaatspecificatie gebruiken.
Onthoud dat opsommingen echte gehele getallen zijn onder de motorkap.
Dus we kunnen hier een procent d doen.
En dan doen we een komma voor onze mapping.
Dus na de komma zou de naam van de variabele komen.
Hier zouden we de variabelenaam moeten opgeven, namelijk Xerox.
En dan willen we hetzelfde doen voor de andere.
Wat ik hier in regel 12 ben vergeten, is dat we ervoor willen zorgen dat het formaat gemakkelijk te lezen is, dus
ik wil een nieuwe regel toevoegen. Dus ik ga backslash n zeggen.
Dit is een escape-reeks, een speciaal teken dat wordt geïnterpreteerd door de printf.
Dus we gaan ook een printf doen, en we gaan zeggen dat de waarde van Google is.
We gaan procent d backslash n zeggen en hier
gaan we de
waarde van de google-variabele afdrukken, wat allemaal google
in kleine letters is.
En als laatste gaan we de waarde van eBay afdrukken.
En dit wordt ook een geheel getal procent d met de regelinvoer.
Ook al heb ik het niet nodig omdat er hierna niets meer is. Het is een goede gewoonte, we gebruiken
de komma voor het argument en dan zeggen we eBay-variabele.
En we eindigen al die uitspraken met een puntkomma. En dat is het.
Dus nu moeten we compileren en uitvoeren.
En de verwachte output hier zal gehele getallen
zijn die worden weergegeven in de volgorde van deze waarden in de lijst.
Dus zoals je merkt dat de lijst is gedefinieerd op regel 6.
De lijst is Google, Facebook, Xerox, Yahoo, eBay en Microsoft.
In de in c-compiler worden die weergegeven als gehele getallen.
Dus Google is 0. Facebook is 1. Xerox is 2.
Dus wat ik hier als output zou moeten zien, is dat
ik zijn output 2 0 zou moeten zien en dan eBay, dat is 4.
Dus eens kijken of dat overeenkomt. Laten we doorgaan en bouwen.
Ik heb geen waarschuwingen, geen fouten. Laten we doorgaan en het uitvoeren.
En wat ik zie is dat de waarde van Xerox 2 is.
De waarde van Google is 0. En de waarde van eBay is 4, dus het ziet er goed
uit, best netjes.
Onthoud nu van sommige lezingen dat je de waarde van de gehele getallen kunt veranderen.
Wanneer je de opsomming definieert, stuur je een opdracht.
Dus als ik de volgorde echt zou willen
veranderen, zou ik kunnen zeggen dat Yahoo gelijk is aan
10 en dan zou dat betekenen dat eBay 11 zou zijn en Microsoft 12.
Dus laten we doorgaan en dat redden. Nu zou de output moeten zijn,
Xerox zal nog steeds gelijk zijn aan 2.
Google wordt 0, maar eBay wordt 11.
Dus we doen het nog een keer, en we zouden die 2 0 11 moeten zien.
U kunt die gehele waarden dus wijzigen als u dat om de een of andere reden zou willen.
Anders wordt het de volgorde waarin ze in de lijst zijn gedefinieerd.
En nogmaals, we kunnen hier wat mee spelen.
We zouden eigenlijk andere variabelen kunnen maken om te zien
of Xerox gelijk is aan Google, enzovoort.
Enums zijn echt cool, en je zult ze waarschijnlijk behoorlijk wat gebruiken.
Ze kunnen beperken wat geldig is voor een variabele, wat
prettig is omdat het een soort validatie biedt.
Echt gemakkelijk te gebruiken, en
het is ook heel gemakkelijk te lezen. Het maakt je code leesbaarder.
Nu hebben we een Xerox-variabele en de werkelijke waarde is Xerox.
Dus we kunnen andere voorwaardelijke uitspraken en dingen geven en het maakt de code gemakkelijker leesbaar.
Dit was dus een snelle kleine oefening die je helpt om opsommingen te begrijpen.
Kortom, hoe u een enum-type definieert en vervolgens hoe u dat type gebruikt.
Ook hebben we printf opnieuw behandeld. We hebben de specificaties van het afdrukformaat behandeld.
We hebben ontsnappingssequenties behandeld en een redelijk goed
voorbeeld.
Ik geef dit voorbeeld als een zip-bestand, zodat je het kunt downloaden. Dank u.