Hallo, en welkom terug.
Laten we het hebben over de basisprincipes van een programma.
Aangezien dit een begin is programmeerles, waar we het
specifiek over gaan hebben C, voordat je zelfs maar een programmeertaal
kunt begrijpen, moet je: om te begrijpen wat een programma is.
Dus ik wil een aantal fundamentele, basisconcepten aan u voordat we aan de slag
gaan met de details van C.
Computers zijn erg domme machines.
Jullie zijn, daar ben ik zeker van, meer dan meer dan niet bekend
met wat een computer kan doen en wat hij doet.
Specifiek echter, onder de motorkap en wat er gebeurt in termen van wanneer
u op uw browser klikt, wanneer u op uw verschillende toepassingen die u gebruikt, wat
er onder de motorkap gebeurt is er een soort
programma dat draait en dat programma is de computer vertellen wat hij moet doen.
Computers zijn echt dom.
Ze doen alleen wat hen wordt opgedragen.
Dus de basisbewerkingen van a computer zal vormen wat bekend staat als
de instructieset van de computer.
Een instructieset als je kunt denk daar eens over na, het is hoe het
iets gaat doen. Dus we
moeten deze computer vertellen hoe het gaat.
We doen het in de vorm van een programma op een nog lager niveau.
Elke computer heeft wat is een instructieset genoemd.
Een instructieset is eigenlijk: de instructies op de CPU, de
processor van de computer.
Dus om een probleem op te lossen met behulp van een computer door u te vertellen wat
u moet doen, biedt u deze oplossing door deze te verzenden instructies naar de instructieset.
Dus dat is wat er gebeurt
wanneer je schrijft een computerprogramma, je stuurt specifieke instructies om een specifiek probleem op
te lossen via commando's aan de CPU, de processor.
En de aanpak of methode die wordt gebruikt om het probleem op te lossen, staat
bekend als een algoritme.
Dus voor jullie die het begrijpen wiskunde, een algoritme is hoe je een
probleem oplost.
Dus als je bijv maak een heel programma en het enige dat
het doet is testen of een gebruiker voert een oneven of even getal in.
Wat zou worden omschreven als de algoritme zelf is de test, of het getal
even is of niet of vreemd, dat is het algoritme.
De uitspraken die het probleem oplossen in zijn geheel wordt het programma.
En we zullen dit bespreken concept en algoritme.
Algoritme is even is even meer een soort relatie - gerelateerd
aan moduleprogrammering.
Dus daar praten we over als we praat meer over de details om te zien.
Maar nogmaals, ik wil je laten begrijpen wat je doet als je
code schrijft.
Wat is er aan de hand bij de zeer, zeer onderste laag.
Je gaat schrijven deze
algoritmen die zich in een programma bevinden.
Dus om een programma te schrijven, ben je...
zal de instructies correct moeten schrijven om het algoritme implementeren.
Deze instructies kunnen worden uitgedrukt in elke vorm van
verklaringen van een bepaalde programmeertaal.
Dus we gaan ons concentreren op c voor deze les, maar
je hebt vast wel eens gehoord van andere programmeertalen
talen zoals java, c++, objective c gebruikt in iOS-applicaties maar eigenlijk meer nu, Swift wordt gebruikt.
Maar er is al deze programmering talen die
u kunt leren en waarmee u in wezen kunt stuur instructies naar de CPU
in de vorm van algoritmen en instructies.
Ook wil ik het hebben over een aantal basisterminologie, de CPU,
de centrale verwerkingseenheid.
Dit is het brein van de computer.
Dit is waar de meeste het werk wordt gedaan.
Dit is waar instructies worden uitgevoerd.
Geheugen, jij vaak hoor deze term geheugen.
En studenten krijgen vaak geheugen erg verward met de harde schijf.
Geheugen is niet hetzelfde als de harde schijf.
Geheugen wordt vaak aangeduid als ram, wat een willekeurig toegankelijk geheugen is.
Alle gegevens die in het geheugen zijn
opgeslagen, zijn een afzonderlijk hardware-onderdeel.
Het is geen echte diskdrive.
Alle gegevens in het programma wordt opgeslagen in het geheugen,
de afzonderlijke hardwarecomponent.
Dus het slaat de gegevens op die de programma terwijl het actief is.
En we gaan het hebben over variabelen en wat ze betekenen.
Maar een programma moet gegevens hebben om berekeningen uit
te voeren om algoritmen te doen.
Die gegevens worden opgeslagen in ram, geheugen.
De reden waarom we het in het geheugen opslaan: in tegenstelling tot het
opslaan op een harde schijf is dat geheugen veel sneller is, kan het
programma veel sneller worden uitgevoerd.
Maar het geheugen is ook meestal niet persistent over reboots een
ander soort verduidelijking.
Maar je zou het moeten begrijpen alleen deze term RAM.
Het betekent geheugen.
Het zijn de variabelen en de gegevens in het programma zelf waar het is opgeslagen.
De aparte hardware component dan de harde schijf.
De hardwareschijf is iets je koopt wanneer de computer - dat
is permanente opslag.
Dit is meestal heel erg groot. Het bevat gigabytes, terabytes aan gegevens.
Hierin worden bestanden opgeslagen die mogelijk bronnen van een programma zijn.
En als je de computer draait uit en weer aan, die bestanden
zijn er nog steeds.
Wanneer u de computer draait aan en uit voor een programma, stopt het
programma eigenlijk met uitvoeren en er zit niets in ram.
Dus begrijp het verschil tussen ram en harde schijf.
Het is een belangrijk begrip.
Nogmaals, beschouw ram als gerelateerd om te programmeren, omdat de harde schijf
gerelateerd is aan
permanente opslag en we daar meestal bronnen op plaatsen.
We hebben allemaal besturingssysteembestanden allerlei verschillende programmabronnen.
Er is een besturingssysteem ontwikkeld om maakt uw leven in feite een stuk gemakkelijker als u de
computer wilt gebruiken.
Omdat op een zeer laag niveau een computer doet gewoon
wat hem wordt opgedragen en het zijn slechts instructies met behulp van een instructieset.
Het zou heel moeilijk zijn gebruiken als u al
deze instructies moet begrijpen.
Er is dus een programma genaamd an besturingssysteem dat het voor een
gebruiker gemakkelijker maakt om een computer te gebruiken.
Het regelt de hele operatie! van de computer, verwerkt alle invoer en
uitvoer via hardware, dus het begrijpt hoe te communiceren
met een toetsenbord, een muis, een monitor.
Het beheert ook de computer's resources, zorgt voor de uitvoering
van verschillende toepassingen.
Een besturingssysteem is een volledig aparte klas.
Er komt veel bij kijken een besturingssysteem, maar
begrijp de basis ervan.
Het staat je gewoon toe om te gebruiken uw computer op een eenvoudigere manier.
Enkele voorbeelden van zeer gemeenschappelijke besturingssystemen zijn dingen als
Windows, toch.
Iedereen gebruikt Windows.
Windows 10,
Windows XP, hoe dan ook.
Linux, UNIX die we zullen meer over praten als we het
hebben over de geschiedenis van C.
Android is een besturingssysteem voor mobiele apparaten, iOS.
Dit zijn specifieke programma's die: zijn erg groot en kunnen veel verschillende programma's bevatten
die op elkaar inwerken, maak uw leven een stuk gemakkelijker door
interactie met de computer.
De uitvoeringscyclus voor ophalen.
Dit is de levenscyclus-CPU.
Ik vermeld dit alleen omdat, nogmaals, we
beschrijven alleen de basisterminologie.
Zo stuur je instructies naar een computer, de CPU, wat er feitelijk gebeurt,
is dat je... de instructies uit het geheugen halen,
want dat is het programma.
En dan ga je voer dat uit op de CPU, en het is dit soort lus
die je bent het steeds opnieuw en opnieuw doen.
Je herhaalt het.
En als je ooit hebt gehoord van de term gigahertz, een gigahertz-CPU kan
ongeveer een miljard keer per seconde doen, een miljard instructies per seconde.
Dus je kunt je een beetje voorstellen wat
gebeurt er als je hiermee een computer gebruikt? levenscyclus van uitvoering ophalen.
En hier is een kleine illustratie die ik heb overgenomen van een
afbeelding op internet die je deze effecten laat zien uitvoeringscyclus een beetje duidelijker.
Wat gaat er wanneer? je
communiceert met de CPU en deze instructies.
Wat gebeurt er? je grijpt van ram.
En ram, onthoud, bevat programmagegevens.
Je pakt gegevens daar voor instructies.
En je decodeert constant de gegevens die zijn opgeslagen in registers en ram en
vervolgens worden uitgevoerd op verschillende delen van de CPU, ofwel de
besturingseenheid of de ALU.
Dat is wel een lus.
Het herhaalt zich gewoon en steeds maar weer.
En nogmaals voor CPU's tegenwoordig miljard keer per seconde.
Dus als we het hebben over c-programma's en het schrijven van c-programma's, op het
zeer lage niveau, onder alles, we zijn gewoon interactie met de CPU via onze programmeertaal
op een hoger niveau.
Dus een hoger niveau programmeertaal.
Programmeertalen op een hoger niveau om het schrijven van programma's gemakkelijker te maken.
Als we nu zouden moeten nogmaals, begrijp al deze
instructies op de CPU, het zou erg moeilijk zijn om te schrijven.
En om alles te begrijpen instructies, betekent dat meestal dat het
een assembleertaal is.
Als je ooit de term vergadering hebt gehoord taal, het betekent gewoon
dat je een programma op een heel laag niveau schrijft waar het zo laag is
dat je de instructieset begrijpt.
En dat kun je je voorstellen als je al je programma's zou
schrijven met al deze instructies, is het zou erg inefficiënt zijn en
erg moeilijk om een programma te schrijven.
Dus programmeren op een hoger niveau taal zijn het
tegenovergestelde van een assembleertaal.
Het is een veel hoger niveau.
Een voorbeeld is c.
C is een hoger niveau programmeertaal.
Het beschrijft de acties die het programma gaat op een
veel abstractere manier presteren.
Je hoeft niet te onthouden de instructies op de CPU.
Je begrijpt gewoon de taal zelf, en je lost problemen op
via deze algoritmen.
Het lijkt veel meer op de Engelse taal.
Het is veel gemakkelijker te begrijpen.
Als je zou kijken naar een
assembler, wat je gaat zien zijn verplaatsopdrachten met registers, met nummers, eigenlijk
alleen maar numerieke verklaringen.
En door een hoger niveau te gebruiken taal zoals c, hoeft u zich hier
geen zorgen over te maken.
U hoeft zich geen zorgen te maken over de instructieset.
U hoeft zich geen zorgen te maken over assembler uitspraken.
Het is dus veel efficiënter en het is veel gemakkelijker om
problemen te bereiken en op te lossen.
En dus gaan we c bestuderen als onze programmeertalen
op een hoger niveau, maar andere voorbeelden zijn java, doelstelling c, dingen die ik noemde.
Dit zijn programma's op hoog niveau talen die uw leven een stuk
gemakkelijker en veel efficiënter maken.
Naast deze hogere niveaus programmeertalen, als je deze taal hebt die abstracter
is, je moet die taal kunnen nemen en
het vervolgens op een CPU kunnen uitvoeren.
Je moet het in wezen converteren naar instructies die de CPU begrijpt.
En dus is dit waar een compiler komt om de hoek kijken.
Vaak als je code schrijft in programmeren, ga je
een compiler gebruiken die vertaalt deze taal op
hoog niveau, broncode in gedetailleerd machinetaalinstructies,
eigenlijk assembler.
Dus je gaat schrijven a programma dat
meer abstract denken op hoog niveau gaat doen.
En dan gaat de compiler om alle miljoenen
instructies te genereren die naar de CPU op de instructieset.
Dus we gaan een compiler gebruiken in deze klas om precies dit te doen.
We gaan de broncode schrijven in een veel hoger niveau abstracte vorm.
En dan gaan we rennen programma genaamd de
compiler om die code in iets om te zetten dat de CPU begrijpt.
Hier is het andere ding over compilers: is dat ze ook gaan controleren
of je programma een geldige syntaxis heeft.
Dus als je code schrijft, moet je de regels
van de taal volgen.
De regels van de taal zijn: in wezen de syntaxis, of
je nu wel of niet een puntkomma hebt bij het einde van een
verklaring, ongeacht of u bepaalde trefwoorden gebruikt.
Als je deze dingen doet onjuist is, kunt
u uw programma niet uitvoeren.
Dus de compiler gaat vinden al deze fouten, en het zal je
vertellen en rapporteren aan jij en zeg, hey, je hebt
je code niet correct geschreven, je moet
repareer ze voordat we deze dingen daadwerkelijk gaan converteren naar de instructies die op de CPU zijn ingesteld.
Dus we gaan kennismaken met compilers
in algemene zin, hoe ze te gebruiken, hoe begrijpen, wat ze ons vertellen.
Talen op hoog niveau zijn veel gemakkelijker te leren, veel gemakkelijker
te programmeren dan machinetalen.
Dat is de kern van deze dia op dit moment is dat door een taal als c
te gebruiken, het gaat worden veel efficiënter en gemakkelijker.
Als we een programma schrijven, zijn we daadwerkelijk meerdere, meerdere
stappen gaan uitvoeren.
En ik vond deze illustratie die de stappen echt
op een hele leuke manier beschrijft.
Dit heb ik dus uit een boek gehaald.
Het is een basisreeks stappen wanneer: je schrijft elk soort programma.
Vanaf de eerste stap van het definiëren van de programmadoelstellingen, het begrijpen van de
vereisten, tot het onderhouden van en het wijzigen van het programma.
Dus laten we er gewoon doorheen lopen stappen heel snel en je zult
merken dat je aan het doen bent - gaan om dit in deze klas te doen.
Wanneer je begint te schrijven a programma, ga
je al deze stappen volgen.
De eerste stap zal zijn om de doelstellingen van het programma definiëren.
Hier ga je naar toe de eisen begrijpen.
U kunt pas beginnen met het schrijven van code: je begrijpt wat je moet doen.
Dus je moet een duidelijke idee van wat u
in deze stap wilt bereiken.
Nadat je de vereisten, ga je dan beginnen met
het ontwerpen van de code.
Wanneer u de code ontwerpt, zo gaat de code aan
de eisen voldoen.
Hoe gaat het met de gebruikersinterface? om eruit te zien als het nodig is.
Hoe ga jij je . organiseren programma,
ga je verschillende functies maken en proberen te creëren? verschillende algoritmen enzovoort.
Dan ga je beginnen met het implementeren van code.
Dit is waar je eigenlijk de . schrijft code en zet het in
een editor in een geïntegreerde ontwikkelomgeving.
Je vertaalt het ontwerp naar de syntaxis van de programmeertaal, in dit geval
c, begrijp de regels van de c taal.
U kunt dus elke teksteditor gebruiken.
We gaan daadwerkelijk gebruiken iets dat koude blokken wordt genoemd.
Meestal wil je iets gebruiken meer dan een teksteditor, iets dat een IDE wordt
genoemd, waar we het over zullen hebben.
Als u klaar bent met het schrijven van de code,
je moet het compileren omdat het de bron moet converteren code naar de taal op laag niveau.
We hadden het er al over, dus dit is een vrij eenvoudige stap.
En dan voer je het programma uit. Het programma uitvoeren
is het uitvoeren, het gebruiken.
En dan gaat dat de vijfde stap zijn.
Nadat u het programma hebt uitgevoerd, bent u niet gedaan, want hoewel
je de code hebt geschreven en het misschien voldoet aan de vereisten van de taal, doet het misschien niet
waarvoor het bedoeld is, dus je moet
het testen en je hebt om uw fouten te vinden en op te lossen.
Dus gewoon omdat een programma is draaien, betekent niet dat het werkt.
Ik krijg veel studenten zeg, hey, gecompileerd, ik ben klaar. Nee.
Je moet ervoor zorgen dat wanneer u het uitvoert, voldoet het
aan de vereisten en doet het wat je denkt dat het gaat lukken.
Je moet dus constant testen.
En je voert stap één uit tot zes keer op
keer. Je wordt ontdekken
dat je code gaat schrijven, testen, code schrijven testen, code schrijven, testen.
En meestal, als je dit doet, wil het in hele kleine stukjes doen.
U wilt twee regels schrijven van code, test. Nog twee regels code,
test enzovoort.
Dus je moet testen en debuggen.
Debuggen is een ander concept.
We zullen veel lezingen houden over foutopsporing, maar dit is wanneer u
uw programmeerfouten vindt en oplost.
Er zijn bepaalde technieken die je kunt doen, bepaalde hulpmiddelen die u kunt gebruiken om u te helpen
deze fouten te vinden.
En je zult een hoop leren door te testen en debuggen omdat je
altijd veel kunt leren informatie door fouten te maken.
En dat wordt normaal.
Je gaat compileren en de programma gaat niet
doen wat je doet wat je zei dat het deed en daar ga je van leren.
En dat is wat we zijn gaan doen in deze klas.
Ik ga het je niet alleen laten zien de juiste manier om dingen te doen.
Ik ga je het verkeerde laten zien manier om dingen te doen, en dan
zul je zien waarom dit verkeerd is.
De laatste stap is onderhoud.
Dit is wanneer de programma's zijn vrijgegeven en vervolgens door veel
mensen gebruikt, maar kunnen nog steeds bugs bevatten.
Dus bijvoorbeeld wanneer Windows 10 is uitgebracht, zult u merken dat het nog steeds bugs
bevat of nog steeds crasht.
En dus ben je constant updates krijgen.
En als je die updates krijgt, dat heet het programma onderhouden.
Dus gewoon omdat je klaar bent het schrijven van de code en
het vrijgeven aan het publiek, dat doet het niet betekent dat je klaar bent met het onderhouden ervan.
Onderhoud is de vaak de meest uitgebreide fase, de meest uitgebreide stap want wanneer
je een programma uitbrengt, kan het vijf of tien jaar
op de markt zijn.
Je zult deze moeten repareren bugs zodat uw klanten tevreden zijn.
Misschien wilt u ook nieuwe functies toevoegen om het in de markt up-to-date te houden.
Dus onderhoud is echt ook belangrijk.
Onderhoud gebeurt na jou het product vrijgeven aan de klant.
Dus voor al deze stappen mag je spring rond, voer stappen
uit in verschillende volgorde, afhankelijk van wat programmeermethodologie, dat is ook
een heel andere lezing.
Je gaat niet altijd noodzakelijkerwijs doe deze stappen in een watervalbenadering waarbij je bij het begin
begint en eindig bij de -- eindig bij de laatste stap.
Je bent misschien aan het ontwerpen en dan teruggaan en je testen doen
en dan teruggaan en opnieuw ontwerpen enzovoort.
Dus je gaat springen rond alles, afhankelijk van
wat het meest praktisch is.
Uit mijn ervaring, veel nieuwe programmeurs in veel van
de klassen in udemy negeren stap één en twee en ga direct naar het
schrijven van de code.
Ze laten je zien hoe je moet schrijven de code, maar ze laten
je niet zien waarom je de code schrijft.
Dit is dus een grote fout.
Wanneer u begint met het schrijven van code, u moet u de concepten
begrijpen, u moet de vereisten begrijpen.
En hier kom je mee weg in hele
kleine programma's, maar met grotere programma's ga je volledig moeten focussen op design.
Dus hoe groter en hoe meer hoe complexer het programma
is, hoe meer planning het vereist.
Je zou de gewoonte moeten ontwikkelen van planning vóór het coderen.
Duik er niet zomaar in, en je gaat aan de colleges in deze klas te merken
dat ik veel aan het plannen ben.
Ik ga het je vertellen in de uitdagingen wanneer je begint met het schrijven van
code die je nodig hebt doen en hoe je het moet ontwerpen.
Want dit gaat het maken gemakkelijker voor u om de code daadwerkelijk
te implementeren, wat stap drie is.
Houd daar dus rekening mee kan vaak dingen planten door dingen op
papier te schrijven.
Er is allerlei leuks documentatie over het ontwerpen van talen die er zijn en dingen
die je kunt gebruiken.
Maar je wilt altijd in principe efficiënt plannen.
En dan terwijl je aan het coderen bent, I
noemde dit eerder, maar dit is een andere zeer, zeer belangrijke concept,
je wilt altijd in kleine stapjes werken, verdeel en heers je wilt constant testen.
Je wilt geen 100 . schrijven regels code en zeg dan, oh, ik
ben klaar, laat me gaan testen.
Want nu, als dat niet zo is werk kan er een fout zijn in
elke 100 regels code.
Het wordt veel moeilijker om dat probleem op te lossen.
Maar als je code in weinig schrijft brokken, vijf regels code, test het en schrijf dan
nog eens vijf regels code, test het, het zal veel gemakkelijker zijn om
uw fouten te vinden en op te lossen.
Dus laten we ons concentreren op verdeel en heers wanneer we onze code in deze klasse schrijven.
Ik hoop dat dit heeft geholpen.
Nogmaals, dit zijn slechts enkele basisprincipes.
ik wilde voorzien wat basisterminologie.
Velen van jullie weten het misschien al veel van deze informatie.
Maar als je een leert programmeertaal, moet u
deze basis begrijpen.
Dank u.