>> [Speel van musiek]
Spreker: Alle reg.
So laat ons praat oor 'n ander ding wat soort van uniek aan C,
wat is datatipes en veranderlikes.
Wanneer ek sê uniek aan C, Ek het regtig net beteken in die konteks van,
as jy 'n programmeerder gewees het vir 'n baie lang tyd,
Jy het waarskynlik nie saam met datatipes
as jy die moderne gebruik het programmeertale.
Moderne tale soos PHP en JavaScript,
wat ons ook sal sien 'n bietjie later in die kursus,
jy nie eintlik om te spesifiseer die data tipe van 'n veranderlike
wanneer jy dit gebruik.
>> Jy verklaar dat dit net en begin om dit te gebruik.
As dit is 'n heelgetal is, is dit weet dit is 'n heelgetal.
As dit is 'n karakter, dit is weet dit is 'n karakter.
As dit is 'n woord nie, weet dit is 'n string, die sogenaamde.
>> Maar in C, wat 'n ouer taal, moet ons
om die data spesifiseer tipe elke veranderlike
dat ons die skep van die eerste keer wat ons gebruik wat veranderlike.
So C kom met 'n paar ingeboude data tipes.
En laat ons kry vertroud met 'n paar van daardie.
En dan daarna sal ons ook praat bietjie oor 'n paar van die data tipes
wat ons het vir jou geskryf, sodat jy kan dit gebruik in CS50.
>> Die eerste is int.
Die tipe int data word gebruik vir veranderlikes wat sal heelgetalwaardes te stoor.
So 1, 2, 3, negatiewe 1, 2, 3, en so aan.
Heelgetalle, wat is iets wat jy moet in gedagte hou vir die quiz,
neem altyd vier grepe geheue, wat is 32 stukkies.
Daar is agt stukkies in 'n greep.
>> So dit beteken dat die omvang van die waardes wat 'n heelgetal kan stoor
is beperk deur wat binne kan inpas 32 stukkies werd van inligting.
Nou as dit blyk, dit is lank gelede besluit
dat ons sou verdeel daardie reeks van 32 stukkies
in negatiewe heelgetalle en positiewe heelgetalle,
elke kry die helfte van die reeks.
So het die omvang van die waardes wat ons verteenwoordig met 'n heeltallige wissel van negatiewe 2
die 31 mag om 2 tot die 31 mag minus 1,
veroorsaak dat jy ook 'n plek vir 0.
>> So basies die helfte van die moontlike waardes jy kan inpas in 'n int negatief is,
en die helfte is positief.
En rofweg hier, dit is oor die negatiewe 2000000000 om positiewe 2000000000.
Gee of neem 'n paar honderd miljoen.
So dit is wat jy kan inpas in 'n heelgetal veranderlike.
Nou het ons ook iets genoem 'n ongetekende heelgetal.
Nou unsigned SY is nie 'n aparte tipe veranderlike.
Inteendeel, unsigned is wat genoem word 'n kwalifiseerder.
Dit verander die data tipe integer effens.
>> En in hierdie geval, wat unsigned means-- en jy kan ook
gebruik unsigned ander tipes data, heelgetal is nie die enigste een nie.
Wat dit doen, is effektief dubbelspel die positiewe reeks waardes
dat 'n heelgetal op kan neem by die koste van nie meer toelaat
jy op negatiewe waardes aan te neem.
So as jy die getalle wat jy weet sal hoër as 2 biljoen maar minder kry
as 4 miljard vir example-- wat is 2 tot die 32 power--
jy dalk wil om te gebruik 'n ongetekende int as jy
weet wat jou waarde sal nooit negatief wees.
>> Jy sal soms het gebruik word vir ongetekende veranderlikes
in CS50, wat is die rede waarom ek noem dit hier.
Maar weereens, die omvang van die waardes wat jy kan verteenwoordig met 'n ongetekende heelgetal
as om gereelde heelgetal T, is 0 2 tot die mag 32 minus 1,
of ongeveer 0-4000000000.
So jy het effektief verdubbel die positiewe reeks wat jy kan inpas,
maar jy het al opgegee die negatiewe waardes.
>> Nou as 'n eenkant, unsigned is nie die enigste kwalifiseerder
dat ons kan sien veranderlike tipes data.
Daar is ook dinge genoem kort en lang en konst.
Konst ons sal sien 'n bietjie bietjie later in die kursus.
Kort en lang, sal ons waarskynlik nie.
>> Maar net weet dat daar is ander kwalifiseerders.
Unsigned is nie die enigste een nie.
Maar dit is die enigste een wat ons is gaan om te praat oor nou.
So alles reg.
Dus het ons gedek heelgetalle.
Wat is volgende?
>> Karakters.
So karakters word gebruik vir veranderlikes wat sal enkele karakters te stoor.
Char is kort vir karakter.
En soms kan jy hoor mense spreek dit as motor.
>> So karakters neem mens altyd byte van die geheue, wat net 8 stukkies.
So dit beteken dat hulle net kan inpas waardes in die reeks van negatiewe 2
om die sewende krag, of negatief 128, 2 tot die mag 7 minus 1, of 127.
>> Danksy ASCII, dit was lank gelede besluit 'n manier
aan diegene positiewe nommers kaart by 0-127 verskeie karakters
dat alle bestaan ​​op ons sleutelbord.
So as ons sal later in te sien die kursus, en jy sal waarskynlik
kom om te onthou op 'n sekere punt, kapitaal A, vir example--
die karakter kapitaal A-- kaarte om die nommer 65.
En die rede daarvoor is want dit is wat is dit
toegeken deur die ASCII standaard.
>> Kleinletters A is 97.
Die karakter 0 vir wanneer jy eintlik tik die karakter, nie
verteenwoordig die aantal nul, is 48.
Jy sal 'n paar leer van hierdie as jy gaan.
En jy sal beslis kom nodig hulle 'n bietjie later in CS50.
>> Die volgende groot tipe data dryf punt getalle.
So swaai punt nommers is ook bekend as die reële getalle.
Hulle is basies getalle wat 'n desimale punt in hulle nie.
Drywende punt waardes soos heelgetalle is ook
vervat in 4 grepe van die geheue.
Nou is daar geen grafiek hier.
Daar is geen getallelyn, want die beskrywing van die omvang van 'n float
is nie presies duidelik of intuïtief.
>> Dit is voldoende om te sê jy het 32 ​​stukkies om te werk met.
En as jy het 'n aantal soos pi, wat het
'n heeltallige deel 3, en 'n drywende punt gedeelte of desimale deel 0,14159,
en so aan, moet jy wees in staat wees om al it-- verteenwoordig
die heeltallige deel en die desimale deel.
>> So, wat dink jy dat kan beteken?
Een ding is dat indien die desimale deel kry langer,
as ek 'n baie groot heeltallige deel, kan ek nie
in staat wees om presies te wees as met die desimale deel.
En dit is werklik die beperking van 'n float.
>> Dryf 'n presisie probleem.
Ons het net 32 ​​stukkies werk, sodat ons kan net
wees so akkuraat met ons desimale deel.
Ons kan nie noodwendig 'n desimale deel presiese 100 of 200 syfers,
want ons het net 32 stukkies om te werk met.
So dit is 'n beperking van 'n float.
>> Nou gelukkig is daar 'n ander tipe data genoem
dubbel, wat ietwat handel met hierdie probleem.
Dubbelspel, soos dryf, word ook gebruik om stoor reële getalle, of swaai punt
waardes.
Die verskil is dat dubbelspel is dubbel presisie.
Hulle kan inpas 64 stukkies data, of agt grepe.
Wat beteken dit?
Wel, dit beteken dat ons 'n baie meer presiese met die desimale punt.
In plaas van om pi tot sewe plekke dalk met 'n float,
ons kan dit dalk moet 30 plekke.
As dit is belangrik, wil jy dalk om 'n dubbele gebruik in plaas van 'n float.
Basies, as jy werk op enigiets waar
'n baie lang desimale plek en 'n baie van presisie is belangrik,
jy waarskynlik wil gebruik 'n dubbele overfloat.
Nou vir die meeste van jou werk in CS50, 'n float moet volstaan.
Maar weet dat dubbelspel bestaan ​​as 'n manier om 'n bietjie te gaan met die presisie
probleem deur jou 'n ekstra 32 stukkies om te werk met jou nommers.
>> Nou is dit nie 'n tipe data.
Dit is 'n tipe.
En dit is nietig genoem.
En ek praat oor dit hier, want ons het waarskynlik
'n paar keer al in CS50 dit gesien.
En jy mag dalk wonder wat dit gaan alles oor.
>> So leemte is 'n tipe.
Dit bestaan ​​nie.
Maar dit is nie 'n tipe data.
>> Ons kan nie 'n veranderlike van tipe skep nie nietig en ken 'n waarde om dit te.
Maar funksies, byvoorbeeld, kan 'n tipe leemte terugkeer het.
Basies, as jy 'n funksie te sien wat 'n tipe leemte terugkeer,
dit beteken dat dit nie 'n waarde terug te keer.
Kan jy dink aan 'n gemeenskaplike funksie wat ons tot dusver gebruik het
in CS50 dit beteken 'n waarde nie weer terugkom nie?
>> Printf is een.
Printf nie eintlik vir julle iets terug te keer.
Dit druk iets doen om die skerm, en dit is basies
'n newe-effek van wat printf doen.
Maar dit gee jou nie 'n waarde terug.
Jy hoef nie die gevolg en die winkel op te vang dit in sommige veranderlike om dit later op te gebruik.
Dit druk net iets om die skerm en jy klaar.
>> So ons dat printf sê is 'n leemte funksie.
Dit gee niks.
>> Die omtrek van 'n lys funksie kan ook nietig wees.
En jy het ook gesien dat nogal 'n bietjie in CS50 ook.
Int belangrikste leemte.
Is dit 'n klokkie?
Basies wat dit beteken, is dat hoof geen parameters neem.
Daar is geen argument dat kry geslaag in hoof-.
Nou later sal ons sien dat daar 'n manier om argumente slaag in hoof,
maar tot dusver wat ons gesien is int main nietig.
Main net nie enige argumente te neem.
En so het ons spesifiseer dat deur te sê leeg.
Ons is net dat dit baie eksplisiete oor die feit
dat dit nie enige argumente neem nie.
>> So vir nou, is dit voldoende om sê dat leemte basies
moet net dien as 'n plekhouer vir jou as dink oor as niks.
Dit is nie regtig iets te doen.
Daar is geen terugkeer waarde hier.
Daar is geen parameters hier.
Dit is nietig.
Dit is 'n bietjie meer kompleks as dit.
Maar dit moet genoeg wees vir die beter deel van die kursus.
En hopelik jy nou 'n bietjie het bietjie meer van 'n konsep van wat nietig is.
>> So dit is die vyf tipes wat jy sal ontmoeting wat gebou-in C.
Maar in CS50 ons het ook 'n biblioteek.
CS50.h, wat jy kan in te sluit.
En wat sal u voorsien met twee bykomende tipes
dat jy waarskynlik in staat sal wees te gebruik op jou opdragte,
of net werk oor die algemeen programmering.
>> Die eerste van hierdie is Bool.
So die Boole tipe data, Bool, word gebruik vir veranderlikes
wat sal 'n Boolese waarde te stoor.
As jy al ooit gehoor hierdie kwartaal voordat jy
kan weet dat 'n Boole waarde in staat is om net
hou twee verskillende afsonderlike waardes.
Ware en valse.
Nou lyk dit redelik fundamentele, reg?
Dit is soort van 'n verrassing dat hierdie bestaan ​​nie in C as dit is gebou in.
En in baie moderne tale, natuurlik, Booleans
is 'n standaard tipe verstek data.
Maar in C, hulle is eintlik nie.
Maar ons het dit vir jou geskep.
So as jy ooit nodig het om te skep 'n veranderlike wie tipe is Bool,
net seker wees om include CS50.h aan die begin van jou program,
en jy sal in staat wees om te skep veranderlikes van die tipe Bool.
>> As jy vergeet om include CS50.h en jy begin met behulp van Boole-tipe veranderlikes,
jy kan 'n paar probleme ondervind wanneer jy die opstel van jou program.
Dus net op die uitkyk vir daardie.
En miskien kan jy net los die probleme deur pond insluitend CS50.h.
>> Die ander groot tipe data wat ons voorsiening te maak vir jou in die CS50 biblioteek
is string.
So, wat is 'n string?
Snare is regtig net woorde.
Hulle is versamelings van karakters.
Hulle is woorde.
Hulle is sinne.
Hulle is paragrawe.
Dalk hele boeke, selfs.
>> Baie kort om baie lang reeks karakters.
As jy nodig het om stringe te gebruik, byvoorbeeld om 'n woord te slaan,
net seker wees om CS50.h sluit aan die begin van jou program
sodat jy kan die tipe string gebruik.
En dan kan jy veranderlikes te skep wie tipe data is string.
Nou later in die kursus, ons sal ook sien dat dit is
nie die hele storie, óf.
Ons sal dinge teëkom genoem strukture,
wat jou toelaat om 'n groep wat kan wees 'n heelgetal en 'n string in 'n eenheid.
En ons kan gebruik wat vir 'n doel, wat kan
handig te pas kom later in die kursus.
>> En ons sal ook leer oor gedefinieerde tipes,
wat jou toelaat om te skep jou eie datatipes.
Ons hoef nie te bekommer oor wat vir nou.
Maar net weet dat dit is iets op die horison,
dat daar 'n baie meer aan hierdie hele tipe ding as ek vertel jou net
nou.
So nou dat ons geleer het 'n bietjie oor die basiese data
tipes en die CS50 data tipes, laat praat oor hoe om te werk met veranderlikes
en hulle te skep deur gebruik te maak van hierdie tipes data in ons programme.
As jy wil om 'n veranderlike te skep, al wat jy hoef te doen, is twee dinge.
>> Eerstens, moet jy om dit 'n soort.
Die tweede ding wat jy nodig om te doen is gee dit 'n naam.
Sodra jy dit gedoen het en geklap n kommapunt aan die einde van die lyn,
jy 'n veranderlike geskep het.
>> So hier is twee voorbeelde.
Int getal, char brief ;.
Wat het ek hier gedoen het?
Ek het twee veranderlikes geskep.
>> Die eerste, die veranderlike se naam is nommer.
En die aantal in staat is om te hou heelgetal tik waardes, want sy soort is int.
Brief is 'n ander veranderlike wat kan karakters hou
omdat die data tipe is char.
>> Redelik eenvoudig, reg?
As jy jouself in 'n situasie waar
wat jy nodig het om verskeie skep veranderlikes van dieselfde soort,
jy hoef net te spesifiseer die tik naam 'n keer.
Dan net soveel veranderlikes lys van daardie tipe as jy nodig het.
>> So ek kon byvoorbeeld hier in die derde reël van die kode,
sê int hoogte ;, nuwe lyn.
Int breedte ;.
En dit sou te werk.
Ek sal nog steeds kry twee veranderlikes genoem hoogte en breedte, wat elk
'n heelgetal is.
Maar ek mag, dinge om te C sintaksis, konsolideer tot 'n enkele lyn.
Int hoogte, breedte; Dit is dieselfde ding.
Ek het twee veranderlikes, een wat geroep is geskep hoogte een wat geroep breedte, beide van wat
in staat is om hou heelgetal tipe waardes.
>> Net so hier is, kan ek drie te skep drywende punt waardes gelyktydig.
Ek kan dalk te skep 'n veranderlike genoem vierkantswortel van 2--
wat vermoedelik sal uiteindelik hou die swaai point--
dat verteenwoordiging van die vierkant wortel van 2-- vierkantswortel van 3 en pi.
Ek kon dit gedoen het op drie afsonderlike lyne.
Vlot, vierkantswortel 2; Dryf vierkantswortel 3; dryf pi; en dit sou te werk.
>> Maar weereens, ek kan net konsolideer dit in 'n enkele lyn van die kode.
Maak dinge 'n bietjie korter, nie as clunky.
>> Nou in die algemeen, is dit 'n goeie ontwerp om slegs verklaar 'n veranderlike wanneer jy dit nodig het.
En ons sal 'n bietjie praat bietjie meer oor wat
later in die kursus wanneer ons bespreek omvang.
So nie noodwendig hoef te skep al jou veranderlikes
aan die begin van die program, wat sommige mense kan die verlede gedoen het,
of was beslis 'n baie algemene kodering praktyk baie jare gelede
wanneer daar met C. Jy mag dalk net wil 'n veranderlike reg toe te skep
jy dit nodig het.
Alles reg.
Dus het ons geskep veranderlikes.
Hoe kan ons dit gebruik?
Nadat ons verklaar veranderlike, het ons nie nodig
die tipe data spesifiseer van daardie veranderlike nie.
In werklikheid, as jy dit doen, kan jy eindig met 'n paar weird gevolge
dat ons sal soort van glans oor vir nou.
Maar om te sê, vreemde dinge gaan
om te begin gebeur as jy per ongeluk weer verklaar veranderlikes met dieselfde naam
oor en oor.
>> So hier Ek het vier reëls van die kode.
En ek het 'n paar van die kommentaar daar net aandui
wat gebeur op elke lyn net om te help
jy lê in wat gaan aan.
So int getal ;.
Jy sien dat voorheen.
Dit is 'n veranderlike verklaring.
>> Ek het nou 'n veranderlike geskep genoem getal wat is
in staat te hou heelgetal-tipe waardes.
Ek het verklaar dit.
>> Die volgende reël ek toeken 'n waarde te nommer.
Nommer gelyk 17.
Wat gebeur daar?
Ek is besig om die nommer 17 binnekant van die veranderlike.
>> So as ek ooit druk dan wat die inhoud van getal is later op,
hulle sal vir my sê dit is 17.
So het 'n veranderlike Ek verklaar, en dan het ek dit opgedra.
>> Ons kan die proses herhaal weer met 'char brief ;.
Dit is 'n verklaring.
Brief gelyk kapitaal H. Dit is 'n opdrag.
Redelik eenvoudig, ook.
>> Nou hierdie proses mag lyk soort van dom.
Hoekom doen ons dit in twee reëls van die kode?
Is daar 'n beter manier om dit te doen?
Trouens, daar is.
Soms jy kan sien hierdie sogenaamde inisialisering.
Dit is wanneer jy 'n veranderlike verklaar en ken 'n waarde op dieselfde tyd.
Dit is eintlik 'n mooi algemene ding om te doen.
Wanneer jy 'n veranderlike, het jy gewoonlik te skep dit wil hê om 'n paar basiese waarde het.
Selfs al is dit 0 of iets.
Jy net jy gee dit 'n waarde.
>> Jy kan 'n veranderlike inisialiseer.
Int getal is gelyk aan 17 is dieselfde as die eerste twee reëls van die kode bo.
Char brief gelyk h is dieselfde as die derde en vierde reëls van die kode hierbo.
Die belangrikste afhaal hier wanneer ons verklaar en die toeken
veranderlikes is nadat ons het verklaar dit, kennisgewing
Ek is nie weer die gebruik van die tipe data.
Ek sê nie int getal is gelyk aan 17 op die tweede reël van die kode, byvoorbeeld.
Ek sê maar net getal is gelyk aan 17.
>> Weereens, re-waarby 'n veranderlike na jy reeds verklaar dit kan lei
sommige weird gevolg.
So net versigtig wees van daardie.
>> Ek is Doug Lloyd.
En dit is CS50.