Termipankki
  1. A
    1. Abstraktio
    2. Alias
    3. Alustaminen
    4. Ankkatyypitys
    5. Argumentti
    6. Arvo
    7. Asetuslippu
    8. Avainsana
  2. B
    1. Binääriluku
    2. Binääritiedosto
    3. Bitti
    4. Bittinegaatio
    5. Bittioperaatio
  3. C
    1. C-funktio
    2. C-kirjasto
    3. C-muuttuja
  4. E
    1. Ehtolause
    2. Ehtorakenne
    3. Esikääntäjä
    4. Esikääntäjädirektiivi
    5. Esittely
    6. Etumerkitön
  5. H
    1. Heksadesimaali
  6. I
    1. Iteroitava
  7. K
    1. Kirjasto
    2. Kokonaisluku
    3. Kommentti
    4. Komplementti
    5. Konekieli
    6. Koodilohko
    7. Käskykanta
    8. Kääntäjä
  8. L
    1. Lause
    2. Liukuluku
    3. Looginen operaatio
  9. M
    1. Makro
    2. Merkki
    3. Merkkijono
    4. Metodi
    5. Muisti
    6. Muuntumaton
    7. main-funktio
  10. O
    1. Objekti
    2. Ohjausrakenne
    3. Optimointi
    4. Osoitin
    5. Otsikkotiedosto
    6. Otsikkotiedot
  11. P
    1. Paikanpidin
    2. Paluuarvo
    3. Parametri
    4. Poikkeus
    5. Prototyyppi
    6. Python-for
    7. Python-format
    8. Python-funktio
    9. Python-import
    10. Python-konsoli
    11. Python-lista
    12. Python-muuttuja
    13. Python-pääohjelma
    14. Python-tulkki
    15. Pääfunktio
    16. printf
  12. R
    1. Resurssi
  13. S
    1. Staattinen tyypitys
    2. Syntaksi
  14. T
    1. Taulukko
    2. Tavu
    3. Terminaali
    4. Tietorakenne
    5. Tyyppi
    6. Tyyppimuunnos
  15. V
    1. Varoitusviesti
    2. Virheviesti
  16. W
    1. while
Ratkaistu: / tehtävää

C-ohjelmoinnin peruspalikat

Kuten jo aiemmin luvattiin, kurssilla edetään suurinpiirtein samassa järjestyksessä kuin Ohjelmoinnin alkeissa. Ainakin siinä määrin kuin se C:n kanssa on mahdollista. Tällä kertaa on siis luvassa ohjelmoinnin kahden peruskiven uusiksi hiominen:
muuttujat
ja
funktiot
, joita ilman on hankala tehdä yhtään mitään. Erityisesti C:ssä jossa ei ole edes pääohjelmaa.

C:n muotoinen kehikko

Osaamistavoitteet: Tämän osion jälkeen osaat kirjoittaa C-ohjelman jonka voi kääntää ja suorittaa.

Pakolliset symbolit

Toisin kuin Pythonissa, jossa kooditiedosto voi sisältää pelkästään yhden koodirivin joka tekee jotain, C:ssä vaaditaan tiettyjä perusasioita. Edellisen materiaalin lopussa nähtiin esimerkki hyvin yksinkertaisesta C-ohjelmasta:
#include <stdio.h>

int main() {
    printf("aasisvengaa!\n");
    return 0;
}
Varsinainen suoritettava koodi on edelleen vain yksi rivi, mutta ympärille on ilmestynyt vähän kaikenlaista. Näitä käytiin läpi alustavasti edellisessä materiaalissa. Todettakoon heti alkuun, että ensimmäisen rivin #-merkki ei tee rivistä
kommenttia
(// sen sijaan tekee!). Kaikki #-merkillä alkavat rivit ovat sen sijaan rivejä, jotka on tarkoitettu
esikääntäjän
käsiteltäväksi. Lyhyesti selitettynä esikääntäjä on
kääntäjän
osa, joka muotoilee kooditiedostoa juuri näillä #-merkeillä merkittyjen
direktiivien
mukaan. Tässä vaiheessa näistä direktiiveistä käsitellään vain #include, joka siis vastaa toiminnaltaan jotakuinkin Pythonin
import-käskyä
. C:ssä tarvitaan includea heti opiskelun alussa, koska toisin kuin Python, C ei ei tarjoa tulostustfunktiota sisäänrakennettuna – funktio on erikseen otettava käyttöön lisäämällä ohjelmaan
kirjasto
stdio (Standard Input / Output), josta se löytyy. Ohjelmassa tämä tehdään siis käskyllä #include <stdio.h>.
Kirjastojen nimen lopussa on tunnuksena .h, joka tulee sanasta header. Tämä .h-tiedosto on kirjaston
otsikkotiedosto
, joka sisältää kirjaston funktioiden, vakioiden ja mahdollisten muuttujien esittelyn. Varsinainen kirjaston koodi on sitten stdio.c-tiedostossa. Tosin sitä emme yleensä pääse näkemään, koska kääntäjät toimittavat standardikirjastot valmiksi käännettyinä binääreinä. Otsikkotiedostoista lisää myöhemmin kurssilla. Koodia tarkastellessa saatetaan huomata yksi ero Pythonin importiin: kun printf-funktiota kutsutaan, ei kirjoitetakaan stdio.printf, vaan pelkästään printf. C:ssä include toimii siis itse asiassa samalla tavalla kuin Pythonin from moduuli import * eikä erillisiä nimiavaruuksia ole käytössä. Tämä tarkoittaa, että funktioiden nimeämisessä saa olla tavallista tarkempana.
Tässä käytetty kirjasto, stdio, sisältää funktioita jotka liittyvät tulostukseen ja syötteen lukemiseen. Käytännössä tässä vaiheessa se tulee käyttöön kaikissa ohjelmissa. Muita tässä vaiheessa tai lähitulevaisuudessa tarpeellisia kirjastoja ovat ainakin math ja stdlib. Näiden tarpeesta kerrotaan erikseen kun ne astuvat mukaan kuvioihin, jolloin ne myös lyhyesti esitellään. C:lle ei ole oikein olemassa samanlaista, yhtä käyttäjäystävällistä dokumentaatiovarastoa kuin Pythonille, joten suosittelemme tiedon etsimiseen joko C-kielen oppikirjaa tai menetelmää ”kato vaikka googlesta”.
Toinen merkittävä ero on se, että C-ohjelmaa ei voi tehdä ilman
funktioita
– pääohjelmaa ei siis ole. Sen sijaan on
pääfunktio
, joka on oletuksena main ja jonka paluuarvo on oletukseltaan muuttujatyyppiä int. Paluuarvon muuttujatyyppi on int, koska ohjelma palauttaa päättyessään koodin, joka kertoo siitä miten se lopetettiin – tällä arvolla on sitten käyttöä esimerkiksi useita ohjelmia peräkkäin suorittavissa skriptoissa, jotka paluuarvon perusteella päättelevät muun muassa sen, onnistuiko ohjelman suoritus. Syvemmälle C-funktion sielunelämään mennään tässä materiaalissa, mutta ei ihan vielä. Tässä vaiheessa riittää, että ymmärrät mikä on tämä mystinen int main() {-rivi – se siis määrittelee pääfunktion, jolla ei ole
parametreja
. Rivin lopussa oleva aaltosulku aloittaa koodilohkon. Kaikki tämän sulun ja sitä vastaavan sulkevan sulun välissä oleva koodi kuuluu funktion sisälle.

Muuttujien muodonmuutos

Osaamistavoitteet: Tämän osion jälkeen hallitset C-muuttujien perusteet. Tähän sisältyvät muuttujien tyyppien ymmärtäminen ja määrittely, sekä jonkinasteinen ymmärrys siitä millä tavalla muuttujat oleskelevat tietokoneen muistissa. Vilkaisemme myös miten muuttujia tulostetaan ja vaihdetaan tyypistä toiseen.

Kertaustuokio

Ennen
C:n muuttujien
sielunelämää, on hyvä palautella hieman mieleen mitä Ohjelmoinnin alkeissa sanottiin
Pythonin muuttujista
. Perusajatus oli, että muuttuja yhdistää ohjelmassa esiintyvän nimen tietokoneen
muistissa
olevaan arvoon. Hyvänä kertauksena toiminee tämä tuttu animaatio:
Näin siis Pythonissa, josta myös useaan otteeseen painotettiin, että
muuttuja
on viittaus muistissa olevaan
arvoon
eikä varsinaisesti sisällä arvoa. Tämä ilmenee animaatiossa kohdassa y = x, jossa molemmat muuttujat osoittavat samaan arvoon. Tämä voitiin myös osoittaa Python-tulkissa id-funktiota käyttämällä:
>>> a = 5
>>> id(a)
10894208
>>> b = a
>>> id(b)
10894208
Tässä nähdään että a ja b eivät pelkästään ole arvoltaan identtisiä, ne ovat myös sama
objekti
. Perusmuuttujatyyppien kuten numeroiden ja merkkijonojen kanssa tällä ei tosin ollut suuremmin merkitystä, koska nämä
tietotyypit
ovat Pythonissa luonteeltaan
muuntumattomia
. Sen sijaan
listojen
kanssa nähtiin jo todellisia seurauksia:
>>> a = [1, 2, 3]
>>> b = a
>>> b.append(4)
>>> a
[1, 2, 3, 4]
Tälle käyttäytymiselle oli ainakin yksi tyypillinen sovellus:
funktioille
annettiin
argumentiksi
listoja, joita funktio muokkasi, mutta ei palauttanut niitä. Niitä ei palautettu, koska se ei ollut tarpeen – funktion muokkaama lista oli sama lista kuin se, joka sille annettiin. Esimerkkinä tästä toimikoon vaikka kokoelmaohjelmaesimerkin lisaa-funktio:
def lisaa(kokoelma):
    print("Täytä lisättävän levyn tiedot. Jätä levyn nimi tyhjäksi lopettaaksesi")
    while True:
        levy = input("Levyn nimi: ")
        if not levy:
            break
            
        kokoelma.append({
            "artisti": input("Artistin nimi: "), 
            "albumi": levy, 
            "n": kysy_luku("Kappaleiden lukumäärä: "),
            "kesto": kysy_aika("Kesto: "),
            "vuosi": kysy_luku("Julkaisuvuosi: ")
        })

Vertaustuokio

C:ssä
muuttuja
on sidottu tiukemmin arvoonsa, siinä määrin että sen kohdalla todella voidaan sanoa että muuttuja sisältää arvon – muuttuja on ohjelmoijan asettama nimi
muistialueelle
, jossa arvo sijaitsee. Kun luodaan uusi muuttuja, varataan myös sen käyttöön uusi muistialue. Palataan tähän tarkemmin hetken päästä. Katsotaan kuitenkin lyhyt animaatio asiasta.
Toinen tapa jolla C:n muuttujat selkeästi eroavat Pythonista on se, että niillä on erikseen määritelty
tyyppi
. Tyyppi määritetään muuttujan
esittelyssä
, joka on siis aina muotoa muuttujan_tyyppi muuttujan_nimi.
Esittely ylipäätään on jotain, mitä Pythonissa ei tehdä lainkaan, koska muuttujat luodaan lennosta silloin kun niihin ensimmäisen kerran sijoitetaan jotain. C:ssä sen sijaan muuttujat täytyy aina esitellä, eli varata niille muistista tilaa, ennen kuin niitä voidaan käyttää. Esittelyn yhteydessä muuttujaan voidaan sijoittaa arvo, puhutaan
alustamisesta
.
Nämä molemmat ovat siis päteviä esittelyjä:
int i;
int x = 5;
Mitä tapahtuu jos muuuttujaa ei alusteta? Tällöin saadaan yleensä hyvin ennalta-arvaamattomia tuloksia, jotka ovat pahimmillaan tietoturvariski!

Tyyppejä kaikkialla

C:ssä siis
muuttujien
tyypit
ovat jokseenkin suuremmassa roolissa kuin Pythonissa. Siinä on myös enemmän perustyyppejä. Yllä nähtiin tuttu
kokonaislukutyyppi
int. Muita C-kielen kokonaislukutyyppejä ovat short ja long. Näille tyypeille on lisäksi olemassa määreet signed tai unsigned joilla voidaan määrätä muuttujalle etumerkki, oletuksena kaikki ovat tosin positiivisia kokonaislukuja. Kirjoitusmerkkejä varten C-kielessä on muuttujatyyppi char, joka itseasiassa on kokonaislukumuuttuja sekin, kuten myöhemmin selviää. Toisin kuin Pythonissa, C:ssä ei ole lainkaan
merkkijonomuuttujatyyppiä
. Merkkijonojen tallentamiseen muistiin palataankin vasta hieman myöhemmin.
C:stä löytyvät myös
liukuluvut
, jotka toimivat aika lailla samalla tavalla kuin Pythonissa. Vähemmän yllättäen nekin ovat vain bittejä muistissa, jotka sitten tulkitaan eri tavalla. C-kielessä on kaksi liukulukumuuttujatyyppiä, eli float ja double. Liukulukujen esityksen ymmärtäminen tietokoneen muistissa ei ole tämän kurssin kannalta oleellista, mutta muistetaan tässä vaiheessa, että ne eivät koskaan ole täysin tarkkoja vaan arvioita. Muuttujiin ja lukujärjestelmiin palaamme vielä tarkemmin.
Nyt kun tiedämme muuttujatyypeistä, voimme ottaa muutaman harjoitustehtävän jotta näistä jää jotain mieleenkin.

Muuttujien määrittelyä - Esitelmä muuttujista

Aloitetaan yksinkertaisemmasta päästä. Tehtävänä on esitellä kolme muuttujaa. Muuttujien nimet on kirjoitettu alle kursiivilla.
  • etumerkitön pieni kokonaisluku N
  • liukuluku keskipituus
  • merkki luokitus
Kirjoita esittelyrivit alla olevaan laatikkoon.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Muuttujien määrittelyä - Alussa oli...

Jatketaan harjoituksia. Nyt tehtävänä on esitellä sekä alustaa muuttujia. Tämä on suositeltavin tapa esitellä muuttujia, koska se varmistaa että kaikilla muuttujilla on jokin järkevä arvo. Tarvittavat muuttujat ovat:
  • etumerkitön suuri kokonaisluku laskuri, alkuarvo 0
  • kokonaisluku summa, alkuarvo 0
Kirjoita määrittelyrivit alla olevaan laatikkoon.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Tyyppejä tulostimessa

Kaiken muun hauskan lisäksi
muuttujien
tyypit
liittyvät myös tulostukseen. C-kielessä täytyy kääntäjälle kertoa, että missä tyypissa haluamme muuttujan tulostaa. Jotta asia ei olisi liian yksinkertaista, voimme tulostaa muuttujan eri tyyppisenä kuin se on esitelty. Tässä vaiheessa tarvitsee vain tietää, että C-kielessä annetaan tulostusfunktiolle printf parametrinä, ei pelkästään tulostettavat muuttujat, mutta myös kuvaus siitä miten ne tulostetaan. Alla esimerkki.
printf("%d\n", x);
Lyhyesti (palaamme kyllä asiaan myöhemmin), printf-funktiokutsussa yllä tulostetaan muuttuja x:n arvo ruudulle kokonaislukuna ja heti perään rivinvaihtomerkki. Funktion ensimmäinen parametri on merkkijono, joka kertoo miten tulostetaan, eli tässä "%d\n". Nyt %+kirjain -merkit vastaavat Pythonin
format-metodin
yhteydessä nähtyjä
paikanpitimiä
ja sen perään rivinvaihtomerkki \n. Itse asiassa myös Python tuntee vastaavan syntaksin – format on vain modernimpi ja monipuolisempi tapa tehdä sama asia. Ajatus on siis, että kunkin paikanpitimen tilalle tulee
printf-funktion
muut
argumentit
annetussa järjestyksessä, eli esimerkissämme %d:n kohdalle tulostukseen tulee muuttujan x arvo. Toisin kuin Pythonissa jossa voitiin käyttää tyhjää paikanpidintä tyyliin "Annoit numeron {}".format(luku), C:ssä paikanpitimet on sidottu muuttujien tyyppiin. Lista tällä kurssilla yleisimmistä:
paikanpidin muuttujatyyppi
%d int
%i int
%hi short
%li long
%u unsigned int
%hu unsigned short
%lu unsigned long
%f float, double
%c char
%s char[]
Lisäksi standardissa on muitakin, joita tullaan näkemään kurssimateriaalissa, mutta eivät suoraan liity yhteen muuttujatyyppiin. Esimerkiksi
paikanpidin merkitys
%x tulostaa muuttujan arvon heksadesimaalimuodossa

Tulostuksen peruskoulun C-luokka

Tulostelu ei ole tällä kurssilla itse asiassa erityisen keskeisessä asemassa, mutta perusjutut on syytä hallita siitäkin. Tässä siis pääasiassa harjoitellaan oikean
paikanpitimen
valintaa muuttujan tyypin perusteella.
Kääntäjä
antaa tyypillisesti virheellisistä paikanpitimistä
varoituksen
, mutta kääntää ohjelman kuitenkin koska sen voi edelleen suorittaa - tulostukset vain saattavat antaa vähemmän odotettuja tuloksia.
Tehtäväsi on napata alta koodinpätkä ja lisätä siihen tulostukset siten, että kunkin määritellyn muuttujan sisältö tulostetaan omalla rivilleen. Toisin kuin Pythonin print-funktio, C:n
printf-funktio
ei tulosta rivinvaihtoa automaattisesti loppuun, joten se pitää sinne itse lisätä - muuta tulostuksiin ei tarvitse sisällyttää.
HUOM: Tarkista, että viimeiseen rivii sisältyy myös uuden rivin merkki
tkj-tulostusperuskoulu-c
int main() {
    unsigned long n = 4000;
    unsigned short laskuri = 0;
    char luokka = 'C';
    float keskiarvo = 0.0;
    return 0;
}

Palauta tulostukset sisältävä kooditiedosto alle. Koodin täytyy kääntyä ilman varoituksia.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Funktioiden muodonmuutos

Osaamistavoitteet: Tässä osiossa tulee tutuksi miten C:ssä määritellään funktioita ja mitkä ovat pääasialliset erot Pythonin-funktioihin (tyypitetyt parametrit sekä paluuarvot). Uutena käsitteenä tulee prototyyppi.

Vaara: Funktiot syövät tyyppejä!

Periaatetasolla
C-funktion
määrittely ja käyttö eivät oikeastaan eroa
Python-funktiosta
. Funktio määritellään omalla määrittelyrivillään, jolla esitetään funktion nimi sekä
parametrit
ja määrittelyä seuraa funktion koodi. Syntaksi eroaa hieman: määrittelyrivillä ei ole erillistä
avainsanaa
kuten Pythonissa on def. Sen sijaan funktion määrittely näyttää alkuun samalta kuin muuttujan – funktioksi sen paljastavat nimen perässä alkavat sulut:
int main() {
    return 0;
}
def-avainsanan ”tilalla” on
muuttujatyyppi
. Tämä tyyppi määrittää mitä tyyppiä funktion
palauttama arvo
on. Huomattavaa on, että main-funktion kohdalla paluuarvo on tyyppiä int – funktion kuuluu antaa statuskoodi sen mukaan menikö suoritus nappiin vai ei. Funktion lopussa kuuluu siis yleensä olla return 0;, joka kertoo että kaikki meni ok. Virhetilanteissa paluuarvo on jokin muu numero, mutta näihin ei perehdytä tarkemmin tässä – juuri nyt on vain syytä muistaa, että pääfunktion loppuun tarvitaan tuo palautusrivi. Aivan samalla tavalla funktion parametreille täytyy määrittää tyyppi:
float laske_matka(float nopeus, float aika) {
    return nopeus * aika;
}
Jos funktiota yritetään kutsua vääräntyyppisillä arvoilla, seurauksena on
kääntäjän
antama virheilmoitus. Funktion myös täytyy palauttaa arvo, joka edustaa funktion määrittelyssä käytettyä tyyppiä – muuten saadaan jälleen käännösvirhe. Funktiolle, jonka ei ole tarkoitus palauttaa mitään, voidaan määrittää tyypiksi void:
void tulosta_ohjeet() {
    printf("Tämä ohjelma ei tee yhtään mitään järkevää");
}
Merkittävin toiminnallinen ero
C-funktioiden
ja
Python-funktioiden
välillä on se, että C:ssä funktiolla voi olla ainoastaan yksi paluuarvo. Jos halutaan palauttaa useita arvoja, käytetään viittauksia tai muuttujat voidaan esimerkiksi pakata
tietorakenteen
sisälle. Tähän perehdytään myöhemmin.

Prototyypit

C-kielessä myös funktiot tulee esitellä ennen käyttöä.
Prototyyppi
on funktion esittely ja kertoo
kääntäjälle
, että ohjelmasta löytyy tämänniminen funktio, joka syö näitä muuttujatyyppejä ja palautusarvo on tätä muuttujatyyppiä.
Prototyypit muodostavat siis ikäänkuin sisällysluettelon funktioista, jotka ohjelmasta löytyvät. Jos C-kielinen ohjelmamme koostuu useasta eri koodimodulista, pitää modulien jaettavat funktiot esitellä niiden otsikkotiedostoissa, jotta sisällysluettelomme olisi kattava. Otsikkotiedosto tarvitaan siis mukaan esikääntäjän #include-lauseella, koska muuten toiset modulit ei tiedä mitään toisissa moduleissa olevista funktioista. Tästäkin opimme lisää myöhemmin.
Tietenkin koko funktion voi kirjoittaa valmiiksi koodissa ennen sen käyttöä, tällöin sen esittely tulikin näppärästi hoidettua samalla, paitsi että tällöin funktio ei näy modulin ulkopuolelle jos se ei ole otsikkotiedostossa.
Prototyypin määrittelyrivi on identtinen varsinaisen funktion määrittelyn kanssa:
int laske_summa(int a, int b);

int laske_summa(int a, int b) {
    return a + b;
}
Yleensä siis prototyyppien lisääminen koodiin ei vaadi muuta kuin funktiomäärittelyjen kopioinnin koodin alkuun (
esikääntäjäohjeiden
alapuolelle). Prototyypit voivat myös sijaita erillisessä
otsikkotiedostossa
, joihin tutustutaan myöhemmin. Prototyyppien käyttö tällä kurssilla ei ole valinnaista – tarkistimen kääntäjää on ohjeistettu tuottamaan
virheilmoitus
puuttuvista prototyypeistä.
Huomatkaa, että main-funktiolle ei kuulu määritellä prototyyppiä, mutta se on aina oltava nimeltään main.

Kartiofunktio

Kirjoitetaan lämmittelyn vuoksi funktio. Funktio olkoon nimeltään kartion_tilavuus. Se saa kaksi liukulukuparametria, kartion pohjan säteen ja kartion korkeuden korkeimmassa kohdassa. Funktio laskee näistä kartion tilavuuden ja palauttaa sen liukulukuna. Potenssiinkorotuksen voit hoitaa peruskoulustrategialla (r*r). Käytä liukulukujen esitykseen double-tietotyyppiä!
Piin arvon saat kätevästi ottamalla math-kirjaston (math.h) mukaan ohjelmaan, jossa se esitetään vakiolla M_PI.
Palauta kooditiedosto jossa on ainoastaan tämän funktion määrittely, ilman pääfunktiota main. Muista prototyyppi!
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

C-kääntäjän perusteet

Osaamistavoitteet: Tässä osiossa opit perusteet C-kääntäjän käytöstä – riittävästi ainakin tätä C-ohjelmointiosuutta varten. Pääasiassa tämä tarkoittaa, että muutamat tärkeimmät asetusliput ovat tämän jälkeen tuttuja, ja että osaat lukea kääntäjän antamia virhe- ja varoitusilmoituksia.
Kurssilla tulemme käyttämään työasemissa virtuaalikonetta, jossa kääntäjäympäristö on valmiiksi asennettu, mutta kotikoneisiin joudutte itse sen asentamaan. Kurssin etusivulta löydät linkin asennusohjeisiin.

Kääntäjätaikuuden perusteet

Aiemmin esitettiin seuraavanlainen perusloitsu:
C:\polku\johonkin>gcc -Wall -o munohjelma.exe munkoodi.c
Tässä komennossa on kaiken kaikkiaan 4 osaa kuten ykkösmateriaalissa lyhyesti käytiin läpi. gcc on käytettävän ohjelman – eli
kääntäjän
– nimi (GNU C Compiler). Käännettävä kooditiedosto tai -tiedosto(t) löytyvät lopusta – niiden edessä ei ole viivalla alkavaa
asetuslippua
. Näistä -o määrittää nimen tiedostolle johon käännetty koodi tallentuu – Windowsissa nimelle annetaan päätteeksi .exe, Linuxissa taas suoritettavat ohjelmat ovat päätteettömiä. Viimeisen lipun -Wall kohdalla olemme itse asiassa vähän huijanneet: sitä ei varsinaisesti tarvita ohjelman kääntämisessä. Se lisää kääntäjän antamien
varoitusten
määrää liittämällä varoitettaviin asioihin useita kyseenalaisia ja helposti korjattavia rakenteita. Olemme sisällyttäeet lipun jokaiseen perusesimerkkiin siksi, että sen käyttö on erittäin suositeltavaa – oikeastaan jopa pakollista tällä kurssilla, koska tarkistimen kääntäjä käyttää sitä ja hylkää koodit jotka antavat varoituksia.
Näiden osasten järjestyksellä ei ole merkitystä, kunhan vain -o ja sen perään tuleva ohjelman nimi pysyvät yhdessä.

Vaihtoehtojen maailma

GNU Compiler Collectioniin sisältyvän C-kääntäjän lisäksi kääntäjiä löytyy lisääkin. Eräs hyvin suosittu vaihtoehto gcc:lle on LLVM-projektiin kuuluva clang, joka sekin on gcc:n tapaan avointa lähdekoodia ja löytyy asennettuna harjoitustehtävien ratkomiseen tarkoitetulta virtuaalikoneelta. clang kelpuuttaa pitkälti samat kääntövivut kuin gcc, joten voit käyttää sitä suoraan vaihtamalla komennoista gcc:n tilalle clang. Itse asiassa clangin kokeilu gcc:n lisäksi on jopa suositeltavaa, sillä clang saattaa joissain tilanteissa tarjota virheet ja varoitukset selkeämmässä muodossa. Useammalla kuin yhdellä kääntyjällä kääntyvät ohjelmat kielivät myös koodin laadusta: fiksusti koodattu ohjelma kääntyy millä tahansa kääntäjällä ja on taatusti standardit täyttävä!
Lisäksi muun muassa Inteliltä ja Microsoftilta löytyy omat C-kääntäjät. Näistä varsinkin Intelin kääntäjä on tunnettu hyvin optimoituja binäärejä tuottavana.

Lisää lippuja

Kuten jo ykkösmateriaalissa todettiin,
kääntäjällä
on
asetuslippuja
kuin kissoja internetissä. Tässä osiossa käymme lyhyesti läpi muutamia joita tällä kurssilla käytetään.
Kurssin kannalta erittäin tärkeä on -Werror, jota voi käyttää sellaisenaan tai =-merkin kanssa. Sellaisenaan se muuttaa kaikki
varoitukset
kääntäjävirheiksi
jolloin koodia ei käännetä lainkaan suoritettavaksi tiedostoksi ennen kuin ne on korjattu. Tämäkin on suositeltava lippu käyttää. Lipulle voi myös määrittää, että vain tietty tai tietyt varoitukset tulkitaan virheiksi. Tällä kurssilla erityisesti tärkeä käyttö on -Werror=missing-prototypes jota käytetään tarkistimessa. Tämä lippu aiheuttaa sen, että ohjelma josta puuttuu funktioiden
prototyypit
ei käänny. Sitä kannattaa siis käyttää myös omalla koneella jolloin saat nämä virheet varmuudella karsittua ennen tarkistukseen lähetystä.
Varoituksiin liittyy myös -Wextra, joka antaa vielä enemmän varoituksia kuin -Wall – lippujen nimeäminen on hieman hämmentävää, kun all ei tosiasiassa sisälläkään aivan kaikkea…
Linuxin käyttäjien on hyvä tietää vielä yksi peruslippu tässä vaiheessa: -lm. Jos yrität käyttää matematiikkakirjastoa (math.h) Linuxilla ilman tätä lippua, funktioita ei löydy ja ohjelmaa ei voida kääntää. Linuxissa matikkakirjasto on irrotettu muista C:n peruskirjastoista, ja -lm kertoo, että se tulee ottaa mukaan – tämän kohdalla on myös tärkeää, että lipun tulee olla komennossa käännettävien tiedostojen jälkeen:
/polku/johonkin$ gcc -Wall -Werror=missing-prototypes -o laskuohjelma laskuohjelma.c -lm

Mystiset käännösviestit

Kääntäjän
viestin lukeminen on keskeistä virheellisten ohjelmien korjaamisessa. Pythonin virheviestejä tulkinneille tässä ei ole varsinaisesti mitään erityisen uutta. Pitkälti sama informaatio löytyy siis näistäkin viesteistä. Alla on esitetty koodi jossa on joitain virheitä.
tkj-rikki-c
#include <stdio.h>
#include <math.h>

const float PI = 3.1416;

float laske_sektorin_ala(float sade, float kulma) {
    return  PI * pow(sade, 2) * kulma / 360;
}

int main() {
    printf("%f\n", laske_sektorin_ala(5));
    return 0;
}

Jos tätä koodia käännetään yllä esitetyllä komennolla, saadaan:
rikki.c:6:7: error: no previous prototype for ‘laske_sektorin_ala’ [-Werror=missing-prototypes]
 float laske_sektorin_ala(float sade, float kulma) {
       ^
rikki.c: In function ‘main’:
rikki.c:11:20: error: too few arguments to function ‘laske_sektorin_ala’
     printf("%f\n", laske_sektorin_ala(5));
                    ^
rikki.c:6:7: note: declared here
 float laske_sektorin_ala(float sade, float kulma) {
       ^
cc1: some warnings being treated as errors
C:tä käännettäessä kääntäjä normaalisti kaivaa koodista kaikki virheet siinä missä Pythonin kohdalla ohjelman suoritus loppuu ensimmäiseen ja loput paljastuvat vasta kun se on korjattu (toiminnan voi muuttaa antamalla -Wfatal-errors-lipun – tästä on lähinnä hyötyä jos koodin kääntäminen on pitkä prosessi). Puretaan tämä esimerkkituloste ilmoitus kerrallaan:
rikki.c:4:7: error: no previous prototype for ‘laske_liike_energia’ [-Werror=missing-prototypes]
 float laske_liike_energia(float nopeus, float massa) {
       ^
Tämä virhe johtuu em. -Werror=missing-prototypes-
lipusta
, minkä
kääntäjä
itse asiassa myös kertoo ensimmäisen rivin lopussa hakasuluissa. Ensimmäinen rivi noin muuten koostuu ilmoituksen sijainnista joka on muotoa tiedoston nimi:rivinumero:sarakenumero (sarakenumero siis tarkoittaa sitä monennenko merkin kohdalla virhe todettiin tapahtuneeksi). Sijainnin jälkeen seuraa ensin ilmoituksen tyyppi (error) ja sen jälkeen tekstimuotoinen selitys. Toinen rivi näyttää virheellisen rivin, ja sen alapuolella vielä ystävällinen apunuoli osoittaa kohdan jossa kääntäjä totesi virheen tapahtuneen. Seuraavassa viestissä on yksi rivi enemmän:
rikki.c: In function ‘main’:
rikki.c:9:20: error: too few arguments to function ‘laske_liike_energia’
     printf("%f\n", laske_liike_energia(5));
                    ^
Ensimmäinen rivi on uusi – se kertoo missä funktiossa virhe tapahtui. Aiempi ilmoitus ei nimittäin syntynyt mistään funktiosta vaan määrittelyosiosta. Muuten tämä ilmoitus on samanlainen kuin edellinen, ja virhe johtuu siis tällä kertaa siitä, että olemme epähuomiossa koittaneet antaa funktiolle vain yhden argumentin kun se vaatii kaksi. Itse asiassa seuraavat kolme riviäkin liittyvät tähän virheeseen.
rikki.c:4:7: note: declared here
 float laske_liike_energia(float nopeus, float massa) {
       ^
Tämä ilmoitus on tyypiltään note. Se kertoo missä päin koodia määritellään funktio, johon edeltävä virhe liittyi. Eli kyse on vain lisätiedosta. Myös viimeinen rivi on lisähuomio:
cc1: some warnings being treated as errors
Tämä siis kertoo muistutuksena, että ainakin joitain varoituksia kohdeltiin virheinä.

Loppuyhteenveto

Tässä materiaalissa olemme käsitelleet C-kielen peruskäsitteistä muuttujat ja funktiot, ja esittäneet miten ne eroavat Pythonista. C:lle ominaista on, että muuttujien tyypillä on paljon enemmän merkitystä. Yleisesti ottaen C on hieman kankeampi kieli kirjoittaa, koska huomioitavia asioita on enemmän. Mutta tällä taas päästään lähemmäksi tietokoneen laiteasoa. Ongelmanratkaisun näkökulmasta kyse on kuitenkin pitkälti samanlaisesta ohjelmoinnista kuin Pythonin kanssa – edelleen kirjoitamme funktioita ja käsittelemme muuttujia. Ainoastaan yksityiskohdat ovat muuttuneet.
?
Abstraktiolla tarkoitetaan sitä kun raa'an konekielen käskyt "piilotetaan" korkeamman tason ohjelmointikielen käskyjen alle. Abstraktiotasosta riippuu miten laajaa tämä piilotus on - mitä korkeampi taso, sitä vaikeampi on suoraan sanoa miten monimutkaiseksi koodirakennelma muuttuu kun se kääntyy konekielelle. Esim. Pythonin abstraktiotaso on huomattavasti korkeampi kuin C:n (itse asiassa Python on tehty C:llä...).
Alias on esikääntäjävaiheessa käsiteltävä korvaus, jolla tietty merkkijono koodissa korvataan toisella. Toiminta vastaa siis tekstieditorin replace-toimintoa. Aliaksia määritellään #define-direktiivillä. Esim #define PI 3.1416
Muuttujan alustamisella tarkoitetaan sitä, kun sille asetetaan koodissa jokin alkuarvo. Hyvin yleinen esimerkki tästä on lukumuuttujien alustaminen nollaan. Alustus voidaan tehdä muuttujan esittelyn yhteydessä: int laskuri = 0; tai erikseen. Jos muuttujia ei alusteta, niiden sisältönä on mitä ikinä muistipaikkaan on aiemmin jäänyt.
Pythonin käyttämää tapaa käsitellä arvojen tyyppiä kutsutaan dynaamiseksi tyypitykseksi eli ankkatyypitykseksi. Nimitys perehtyy lauselmaan "Jos se ui kuin ankka, kävelee kuin ankka ja ääntelee kuin ankka, se on ankka." Toisin sanoen arvon kelvollisuus määritellään sen ominaisuuksien perusteella. Tämä eroaa staattisesta tyypityksestä, jossa arvon kelvollisuus määritellään sen tyypin perusteella.
Argumentti on funktiokutsussa käytettävä arvo, joka välitetään kutsuttavalle funktiolle. Funktion sisällä argumentit sijoitetaan parametreiksi kutsuttuihin muuttujiin. Esimerkiksi printf("%c", merkki); -lauseessa argumentteja ovat "%c"-tulostusmäärittely sekä merkki-muuttujan sisältö.
Alkeiskurssilla arvo-termiä käytettiin kaikista ohjelman käsittelemistä arvoista, oli kyse sitten muuttujista, lauseiden tuloksista tai mistä tahansa. Arvo on siis käytännössä tietokoneen muistissa olevaa dataa, johon muuttujat voivat viitata. C:ssä muuttujan ja sen arvon suhde on Pythonia tiiviimpi, koska muuttuja vastaa suoraan sitä muistialuetta johon arvo on talletettu.
Asetuslippuja käytetään kun suoritetaan ohjelmia komentoriviltä. Ne ohjaavat ohjelman toimintaa. Asetuslippu kirjoitetaan yleensä joko yhdellä viivalla ja sitä seuraavalla kirjaimella (esim. -o) tai kahdella viivalla ja kokonaisella sanalla (tai sanoilla, sanojen välissä viiva) (esim. --system. Jotkut liput ovat ns. boolean lippuja eli ne ovat vain päällä tai pois, toisille annetaan lisäksi parametri. Parametri on tyypillisesti lipun perässä joko välilyönnillä tai =-merkillä erotettuna (esim. -o hemuli.exe).
Avainsanat ovat ohjelmointikielessä kielen käyttöön valittuja sanoja, joilla on erityinen merkitys. Hyvät tekstieditorit tyypillisesti merkitsevät avainsanat muista nimistä eroavalla tavalla (esim. lihavointi). Avainsanat ovat yleensä suojattuja, eli samannimistä muuttujaa ei voi luoda. Yleisiä avainsanoja ovat esim ohjausrakenteisiin kuuluvat if ja else. Avainsanat ovat siis osa ohjelmointikielen kielioppia.
Binääriluku on luku, joka muodostuu biteistä, eli arvoista 0 ja 1. Tämä tekee siitä 2-kantaisen lukujärjestelmän. Binäärilukujen tulkintaa voit tutkailla lukujärjestelmiä käsittelevässä lisämateriaalissa.
Binääritiedosto on tiedosto, joka sisältää konekielisiä käskyjä binäärinä. Ne on tarkoitettu ainoastaan tietokoneen luettavaksi, ja tyypillisesti jos niitä avaa vahingossa esim. tekstieditorilla tuloksena on merkkisotkua editorin yrittäessä tulkita tiedoston sisältämiä bittejä merkeiksi. Useimmat tekstieditorit myös varoittavat asiasta erikseen.
Bitti on pienin informaation yksikkö, joka voi saada arvot 0 ja 1. Tietokoneen sisällä kaikki tapahtuu bitteinä. Tyypillisesti muistissa on bittijonoja, jotka muodostuvat useista biteistä.
Bittinegaatio on operaatio jossa bittijonon bitit käännetään siten, että nollat muutetaan ykkösiksi ja ykköset nolliksi. Operaattori on ~
Bittioperaatiot ovat oma operaatioluokkansa joiden yhteispiirre on se, että niissä käsitellään bittijonojen yksittäisiä bittejä. Kääntöoperaatiossa yhden jonon bitit käännetään nollista ykkösiksi ja toisin päin. Osa operaatioista suoritetaan kahden bittijonon välillä siten, että jonoissa samassa kohdassa olevat bitit vaikuttavat toisiinsa. Näitä ovat and (&), or (|) sekä xor (^). Lopuksi on vielä siirto-operaatiot (<< ja >>), joissa yhden bittijonon bittejä siirretään oikealle tai vasemmalle N askelta.
C:n funktiot ovat Pythonin funktioita staattisempia. Funktiolla voi olla vain yksi paluuarvo, jonka tyyppi määritellään funktion määrittelyssä. Samoin määritellään kaikkien parametrien tyypit. Funktiota kutsuttaessa argumenttien arvot sijoitetaan parametreille varattuihin muistipaikkoihin, joten funktio käsittelee eri arvoja kuin sitä kutsuva koodi.
Ulkopuolinen koodi sijaitsee C:ssä kirjastoissa (library), josta niitä voidaan ottaa käyttöön #include-direktiivillä. C:ssä on mukana sisäiset kirjastot sekä lisäksi voidaan käyttää ulkoisia kirjastoja - ne täytyy kuitenkin koodissa käyttöönoton lisäksi kertoa kääntäjälle käännösvaiheessa. Tyypillisesti kirjasto koostuu c-kooditiedostosta sekä otsikkotiedostosta (.h), joka kertoo mitä funktioita kirjastossa on.
C:n muuttujat ovat staattisesti tyypitettyjä, eli niiden tyyppi kiinnitetään esittelyn yhteydessä. Lisäksi C:ssä muuttuja on sidottu sille varattuun muistialueeseeen. Muuttuja ei voi myöskään muuttaa tyyppiään jälkikäteen.
Ehtolause on yksittäisen ehdon määrittelevä rivi koodissa, jota seuraa aaltosulkeilla merkitty koodilohko, joka määrittää miten ehdon toteutuessa tulee toimia. Varsinaisia ehtolauseita ovat if-lauseet, joka voi esiintyä myös else-avainsanan kanssa else if. Toisiinsa liitetyt ehtolauseet muodostavat ehtorakenteita.
Ehtorakenne on yhdestä tai useammasta toisiinsa liitetystä ehtolauseesta muodostuva rakenne, joka haarauttaa ohjelman suoritusta. Useimmissa ehtorakenteissa on vähintään kaksi haaraa: if ja else. Näiden välissä voi olla myös N kpl else if-lauseilla aloitettuja haaroja. On myös mahdollista, että ehtorakenteessa on pelkkä if-lause. Ehtorakenteessa kussakin haarassa on suoritettavaa koodia, joka kuvaa miten ohjelman tulee ehdon määrittelemässä tilanteessa toimia. Jokainen haara on oma koodilohkonsa, joka merkitään siis aaltosulkeilla.
Esikääntäjä on värkki joka käy koodin läpi suorittaen kaikki esikääntäjädirektiivit ennen varsinaista kääntämistä. Näihin kuuluvat mm. include-lauseet joilla koodiin lisätään siihen liitetyt kirjastot sekä define-lauseet joilla voidaan määritellä vakioita ja makroja.
Esikääntäjädirektiivit ovat ohjeita, jotka on tarkoitettu esikääntäjälle. Ne puretaan koodista pois ennen varsinaista kääntämistä. Esikääntäjädirektiivit alkavat #-merkillä. Yleisin näistä on include, joka vastaa Pythonin importia. Toinen yleinen on define, jolla tällä kurssilla määritetään vakioita.
Muuttujan esittely tarkoittaa sitä kun muuttujan olemassaolosta kerrotaan ensimmäistä kertaa. Tällöin määritetään muuttujan tyyppi ja nimi, esim. int luku;. Kun muuttuja esitellään, sille varataan paikka muistista, mutta muistiin ei vielä kirjoiteta mitään - muuttujassa on siis muistiin jäänyt arvo. Tästä syystä muuttujat on usein myös hyvä alustaa esittelyn yhteydessä.
Etumerkitön kokonaislukumuuttuja on kokonaisluku jonka kaikki arvot ovat positiivisia. Koska etumerkille ei tarvitse varata bittiä, etumerkittömällä kokonaisluvulla voidaan esittää itseisarvoltaan 2x suurempi luku kuin etumerkillisellä. Etumerkitön kokonaisluku määritetään lisäämällä kokonaislukumuuttujan esittelyyn unsigned-avainsana: unsigned int laskuri;
Heksadesimaaliluvut ovat 16-kantaisia lukuja, joita käytetään erityisesti muistiosoitteiden sekä muistin bittisisällön esittämiseen. Heksadesimaaliluvun edessä on tyypillisesti 0x, ja numeroiden lisäksi käytössä ovat kirjaimet A-F jotka vastaavat numeroja 10-15. Heksadesimaalilukuja käytetään koska yksi numero vastaa aina tasan neljää bittiä, joten muunnokset binääriin ja takaisin ovat helppoja.
Iteroitava objekti on sellainen, jonka voi antaa silmukalle läpikäytäväksi (Pythonissa for-silmukalle). Tähän joukkoon kuuluvat yleisimpinä listat, merkkijonot ja generaattorit. C:ssä ei ole silmukkaa, joka vastaisi Pythonin for-silmukan toimintaa, joten taulukoiden yms. läpikäynti tehdään indeksiä kasvattavilla silmukoilla.
Kirjasto on tyypillisesti yhteen rajattuun tarkoitukseen tehty työkalupakki, joka yleensä sisältää nipun funktioita. Kirjastot otetaan käyttöön include-esikääntäjädirektiivillä. Jos kirjasto ei kuulu C:n sisäänrakennettuihin, sen käyttöönotto täytyy myös kertoa kääntäjälle.
Kokonaisluvut itsessään ovat tuttuja varmaan tässä vaiheessa, mutta C:ssä niitä on monenlaisia. Kokonaisluvuille nimittäin määritellään kuinka monella bitillä ne esitetään sekä se, onko luvussa etumerkkiä. Koska tietyllä bittimäärällä voidaan esittää vain rajallinen määrä eri lukuja (2 ^ n), etumerkillisissä luvuissa maksimiarvo on yhden bitin verran pienempi (2 ^ (n - 1)). Pienin kokonaisluku on 8-bittinen.
Kommentti on kooditiedostossa olevaa tekstiä, joka ohitetaan kun koodia suoritetaan. Kussakin kielessä on oma tapansa sille miten rivi merkitään kommentiksi. Pythonissa se on #-merkki, C:ssä //. Lisäksi C:ssä voi merkitä useita rivejä kommenteiksi kerralla - kommentti aloitetaan tällöin /*-merkkiparilla ja päätetään */-merkkiparilla. Kaikki näiden välissä tulkitaan kommentiksi.
Komplementti on negatiivisten lukujen esitystapa, jossa luvun etumerkki muutetaan kääntämällä sen kaikki bitit. Kahden komplementissa, jota tällä kurssilla käytetään, käännön jälkeen lisätään tulokseen 1. Tarkempaa tietoa löydät lukujärjestelmiä käsittelevästä oheismateriaalista.
Konekieli muodostuu käskyistä jotka laitteen prosessori ymmärtää. Konekieltä kutsutaan yleensä Assemblyksi ja se on alin taso jolla ihmisen on mielekästä antaa ohjeita tietokoneelle. Konekieltä käytetään tällä kurssilla loppuossa, joten siihen ei johdatuskurssia suorittavien tarvitse perehtyä.
Koodilohko on joukko koodirivejä, jotka kuuluvat jollain tavalla yhteen eli ne ovat samassa kontekstissa. Esimerkiksi ehtorakenteessa kunkin ehdon alla on oma koodilohkonsa. Samoin funktion sisältö on oma koodilohkonsa. Koodilohkot voivat sisältää muita koodilohkoja. Pythonissa koodilohkot erotetaan toisistaan sisennyksellä; C:ssä koodilohkon alku ja loppu merkitään aaltosulkeilla {}
Käskykanta määrittää mitä käskyjä laitteen prosessori osaa. Nämä käskyt muodostavat prosessoriarkkitehtuurin konekielen.
Kääntäjä on ohjelma, joka kääntää C-kielisen koodin konekieliseksi binääritiedostoksi, jonka tietokoneen prosessori osaa suorittaa. Kääntäjä myös tutkii koodin ja ilmoittaa siinä olevista virheistä sekä antaa varoituksia potentiaalisista ongelmista koodissa. Kääntäjän toimintaa voi ohjata lukuisilla asetuslipuilla.
Lause on ohjelmointikielessä nimitys yksittäiselle suoritettavalle asialle, joka on yleensä yksi koodirivi.
Liukuluku (engl. floating point number, lyh. float) on tietokoneiden käyttämä desimaaliluvun approksimaatio. Tietokoneet eivät arkkitehtuurinsa vuoksi pysty käsittelemään oikeita desimaalilukuja, joten niiden tilalla käytetään liukulukuja. Liukuluvut saattavat aiheuttaa pyöristysvirheitä - tämä on hyvä pitää mielessä niitä käyttäessä. C:ssä liukulukuja on yleensä kahta eri tarkkuutta: float ja double, joista jälkimmäisessä on nimensä mukaisesti 2 kertaa enemmän bittejä.
Looginen operaatio viittaa Boolen algebran operaatiohin, joissa käsitellään totuusarvoja. Tyypillisiä loogisia operaatioita ovat ehtolauseista tutut and, not ja or. C:ssä tunnetaan myös bittikohtaiset loogiset operaatiot jotka toimivat samalla logiikalla, mutta vaikuttavat jokaiseen bittiin erikseen.
Makro on alias, jolla määritetään tietty avainsana korvattavaksi koodinpätkällä. Hyvin käytettynä tällä voidaan joissain tilanteissa saada aikaan parempaa luettavuutta, mutta helposti käy toisin. Makroilla ei kannata tämän kurssin puitteissa leikkiä, kunhan tietää mistä on kyse jos niihin joskus törmää.
Merkki on nimensä mukaisesti yksi merkki. Merkki voidaan tulkita ASCII-merkkinä mutta sitä voidaan käyttää koodissa myös kokonaislukuna, koska se on pienin esitettävissä oleva kokonaisluku. Merkin koko on 1 tavu. Merkki merkitään yksinkertaisilla lainausmerkeillä, esim. 'c'.
Pythonissa kaikki teksti käsiteltiin merkkijonoissa, eikä siinä esim. ollut erillistä muuttujatyyppiä yksittäiselle merkille. C:ssä puolestaan ei ole varsinaista merkkijonomuuttujatyyppiä lainkaan - on ainoastaan merkeistä koostuvia taulukoita, joille on oma määrittelytapansa. Näillä taulukoilla on ennaltamäärätty pituus. "Merkkijonon" voi määritellä C:ssä char elain[5] = "aasi"; jossa numero kertoo merkkitaulukon koon ja on merkkien määrä + 1, koska lopetusmerkki '\0' lisätään tässä alustustavassa automaattisesti loppuun.
Metodi on funktio, joka on osa objektia eli objektin ominaisuus, jolla objekti usein muuttaa omaa tilaansa. Metodia kutsuttaessa käsiteltävä objekti tulee kutsun eteen: arvosanat.sort().
Kaikki suoritettavien ohjelmien käsittelemä data on tietokoneen muistissa ajon aikana. Tietokoneen muisti muodostuu muistipaikoista, joilla on muistiosoite sekä sisältö. Kaikki muistipaikat ovat saman kokoisia - jos talletettava tietomäärä on tätä suurempi, varataan useampi (peräkkäinen) muistipaikka.
Pythonissa objektit eroteltiin muuntuviin ja muuntumattomiin. Muuntumaton arvo oli sellainen, jonka sisältö ei voi muuttua - kaikki operaatiot jotka näennäisesti muuttavat arvoa tosiasiassa luovat siitä uuden kopion, joka yleensä sijaitsee uudessa muistipaikassa. Esimerkiksi merkkijonot olivat tyypillinen muuntumaton tyyppi Pythonissa. C:ssä tätä erottelua ei tarvita, koska muuttujien ja muistipaikkojen suhde on tiiviimpi - sama muuttuja osoittaa koko ohjelman suorituksen ajan tiettyyn muistipaikkaan.
Objekti, joskus myös olio, on Pythonissa yleistä terminologiaa. Kutsuimme objekteja pääasiassa arvoiksi alkeiskurssilla, mutta Pythonissa kaikkea voi käsitellä objekteina - tämä tarkoittaa, että mihin tahansa voidaan viitata muuttujilla (esim. funktion voi sijoittaa muuttujaan). Objekti-termiä käytetään tyypillisesti oliopohjaisissa kielissä (kuten Python). C ei kuulu tähän joukkoon.
Ohjausrakenne on yleisnimitys koodirakenteille, jotka hallitsevat jollain tavalla ohjelman suorituksen kulkua. Näihin rakenteisiin lukeutuvat ehtorakenteet sekä toistorakenteet. Myös poikkeusten käsittely voidaan lukea tähän joukkoon.
Koodin optimointi tarkoittaa sitä, että sen suorituskykyä parannetaan tyypillisesti joko vähentämällä aikaa, joka sen suoritukseen kuluu tai vähentämällä muistin käyttöä. Optimoinnista on hyvin tärkeää ymmärtää, että sitä ei koskaan kannata tehdä jos ei ole pakko - optimointia siis tehdään vasta kun koodi oikeasti toimii hitaasti tai kuluttaa liikaa muistia. Optimointia ei myöskään kannata tehdä sokkona - koodista tulee ensin tunnistaa mitkä ovat sen pullonkaulat eli ne osat jotka tuhlaavat eniten resursseja.
Osoitin (pointer) on C:ssä erityinen muuttujatyyppi. Osoitinmuuttuja sisältää muistiosoitteen, josta varsinainen arvo löytyy - ne toimivat siis tietyllä tapaa kuin Pythonin muuttujat. Muuttuja määritellään osoittimeksi lisäämällä tyypin perään * esittelyrivillä, esim. int* luku_os luo luku_os-muuttujan, joka on osoitin int-tyyppiseen arvoon. Osoittimen osoittaman muistialueen sisällön voi hakea käyttöön merkinnällä *luku_os ja vastaavasti jonkin muuttujan muistipaikan osoitteen saa merkinnällä &luku. Osoittimille on omistettu kokonainen materiaali (4).
Otsikkotiedosto on .h-päätteellä merkitty tiedosto, joka sisältää otsikkotiedot (funktioiden prototyypit, tietotyyppien määrittelyt yms) saman nimiselle .c-tiedostolle.
Otsikkotiedot ovat C-koodissa ja erityisesti kirjastojen yhteydessä eräänlainen muotti koodista. Tyypillisen otsikkotieto on funktion prototyyppi, jolla kerrotaan mitä funktio palauttaa ja mitä argumentteja sille annetaan. Rivi on sama kuin funktion varsinainen määrittely. Muita otsikkotietoja ovat mm. tietotyyppien ja vakioiden määrittelyt. Otsikkotiedot voivat sijaita kooditiedoston alussa, mutta erityisesti kirjastojen osalta ne ovat yleensä erillisessä .h-tiedostossa.
Paikanpidin on merkkijonojen muotoilussa käytetty termi, jolla esitetään kohta merkkijonossa, johon sijoitetaan esim. muuttujan arvo ohjelman suorituksen aikana. Pythonissa format-metodia käytettäessä paikanpitimiä merkittiin aaltosulkeilla (esim. {:.2f}). C:ssä käytetään %-merkkiä jota seuraa paikanpitimen määrittely, josta erityisen tärkeä osa on muuttujatyypin määrittely. Esimerkiksi "%c" ottaa vastaan char-tyyppisen muuttujan.
Paluuarvo on nimitys arvolle tai arvoille jotka funktio palauttaa kun sen suoritus päättyy. C:ssä funktioilla voi olla vain yksi paluuarvo, Pythonissa niitä voi olla useita. Koodia lukiessa paluuarvoa voi käsitellä päässään siten, että funktiokutsun paikalle sijoitetaan funktion paluuarvo sen jälkeen kun funktio on suoritettu.
Parametri on funktion määrittelyssä nimetty muuttuja. Parametreihin sijoitetaan funktion saamat argumentit. Parametri on siis nimitys jota käytetään kun puhutaan arvojen siirtymisestä funktion näkökulmasta. Tätä erottelua ei aina tehdä, vaan joskus puhutaan pelkästään argumenteista.
Poikkeus on ohjelmointikielessä määritelty virhetilanne. Poikkeuksella on tyyppi (esim. TypeError), jota voi käyttää poikkeuksen käsittelyssä ohjelman sisällä sekä myös apuna virhetilanteen ratkaisussa. Tyypillisesti poikkeukseen liitetään myös viesti, joka kertoo mistä ongelmassa on kyse.
Prototyyppi määrittelee funktion paluuarvon tyypin, nimen sekä kaikki argumentit ennen funktion varsinaista esittelyä. Kunkin funktion prototyypin tulisi löytyä joko kooditiedoston alusta tai erillisestä otsikkotiedostosta (.h). Prototyypin määrittely on kopio funktion varsinaisesti määrittelyrivistä.
Pythonin for-silmukka vastaa toiminnaltaan useimmissa kielissä olevaa foreach-silmukkaa. Se käy läpi sekvenssin -esim. listan - jäsen kerrallaan, ottaen kulloinkin käsittelyssä olevan jäsenen talteen silmukkamuuttujaan. Silmukka loppuu, kun iteroitava sekvenssi päättyy.
Merkkijonojen format-metodi on Pythonissa tehokas tapa sisällyttää muuttujien arvoja tulostettavaan tai tallennettavaan tekstiin. Merkkijonoon määritetään paikanpitimiä (esim: {:.2f}) joihin sijoitetaan format-metodin argumentit.
Python-funktiolla voi olla valinnaisia parametreja, joilla on asetettu oletusarvo. Argumenttien arvot siirtyvät parametreihin viittauksen kautta, joten funktion sisällä käsitellyt arvot ovat samoja kuin sen ulkopuolella käsitellyt - niillä on vain eri nimet. Python-funktiolla voi olla useita paluuarvoja.
Pythonin import-lauseella otettiin käyttöön moduuleja/kirjastoja - joko Pythonin mukana tulevia, muualta ladattuja tai itsekirjoitettuja. Pythonin import-lauseelle erityistä on, että oletuksena tuotuihin funktioihin ym. päästään käsiksi moduulin nimen kautta (esim. math.sin. C:ssä importia vastaa include, ja se tuo nimet suoraan ohjelman omaan nimiavaruuteen.
Interaktiivinen Python-tulkki tai Python-konsoli on ohjelma, johon voi kirjoittaa Python-koodirivejä. Nimitys "interaktiivinen" tulee siitä, että koodirivi suoritetaan välittömästi sen syöttämisen jälkeen, ja ohjelma näyttää käyttäjälle koodirivin tuottaman paluuarvon (esim. matemaattisen operaation tuloksen).
Pythonin lista osoittautui Ohjelmoinnin alkeissa hyvin tehokkaaksi työkaluksi. Se on järjestetty kokoelma arvoja. Listan monikäyttöisyys johtuu siitä, että sen koko on dynaaminen (eli suorituksen aikana muuttuva) minkä lisäksi se voi sisältää mitä tahansa arvoja - myös sekaisin. Samassa listassa voi siis olla useita erityyppisiä arvoja. Listat voivat tietenkin sisältää myös listoja tai muita tietorakenteita jne.
Kuten Ohjelmoinnin alkeissa opittiin, Python-muuttuja on viittaus arvoon, eli yhteys muuttujan nimen ja tietokoneen muistissa olevan arvon välillä. Python-muuttujilla ei ole tyyppiä, mutta arvoilla on. Arvon kelpaavuus kokeillaan koodia suorittaessa tilannekohtaisesti. Tässä suhteessa ne siis eroavat toiminnaltaan C:n muuttujista, ja niiden toiminta muistuttaa usein enemmän C:n osoittimia.
Pythonissa pääohjelma on se osa koodia, joka suoritetaan kun ohjelma käynnistetään. Pääohjelma sijaitsee tyypillisesti koodin lopussa, ja useimmiten if __name__ == "__main__":-lauseen alla. C:ssä ei ole varsinaista pääohjelmaa, siinä suoritus aloitetaan oletuksena main-nimisestä funktiosta.
Python-tulkki on ohjelma, joka muuttaa Python-koodin tietokoneelle annettaviksi ohjeiksi. Se vastaa niin kooditiedostojen kuin myös interaktiiviseen Python-tulkkiin kirjoitettujen komentojen suorittamisesta. Tällä kurssilla sanalla tulkki viitataan kuitenkin useimmiten nimenomaan interaktiiviseen Python-tulkkiin.
Pääfunktio on C:ssä ohjelman aloituspiste ja se korvaa Pythonista tutun pääohjelman. Oletuksena pääfunktion nimi on main ja se määritellään yksinkertaisimmillaan int main().
Resurssi viittaa laitteiston käytössä olevaan prosessoritehoon, muistiin, oheislaitteet jne. Se käsittää siis kaikki rajoitteet sille millaista ohjelmakoodia voidaan ajaa sekä sen, mitä ohjelmakoodilla voidaan tehdä. Tietokoneilla resurssit ovat ohjelmointiopiskelijan näkökulmasta aika rajattomat, mutta sulautetuilla järjestelmillä rajat voivat hyvinkin tulla vastaan.
C käyttää staattista tyypitystä. Se tarkoittaa sitä, että muuttujien tyypit määritellään kun ne luodaan ja muuttujaan ei voida sijoittaa erityyppistä arvoa. Lisäksi arvon kelvollisuus määritellään koodia suorittaessa sen tyypin perusteella (tai oikeastaan tämä tehdään jo käännösvaiheessa). Pythonissa taas käytetään dynaamista eli ankkatyypistystä.
Syntaksi (engl. syntax) on koodin kielioppi. Esimerkiksi Pythonin syntaksi määrittää, millainen teksti on tulkittavissa Python-koodiksi. Jos teksti ei noudata koodin syntaksia, sitä ei voida suorittaa tai C:n tapauksessa kääntää. Syntaksi antaa myös koodaajalle tietoa siitä, missä muodossa halutunlainen ohje tulee antaa.
Taulukko (array) on ohjelmointikielissä yleinen tietorakenne, joka sisältää useita (yleensä) samantyyppisiä arvoja. C:n taulukot ovat staattisia - niiden koko tulee määritellä taulukon esittelyn yhteydessä - ja taulukossa voi olla vain samantyyppisiä muuttujia (myös tyyppi määritellään esittelyssä).
Yhden muistipaikan koko on yksi tavu (byte) - tyypillisesti 8 bittiä. Tavu on siis pienin yksikkö joka voidaan osoittaa tietokoneen muistista. Muuttujien tyyppien varaamat muistialueet lasketaan tavuissa.
Terminaali, komentokehote ja komentorivi ovat eri nimiä käyttöjärjestelmän tekstipohjaiselle käyttöikkunalle. Windowsissa komentoriville pääsee kun kirjoittaa suorita...-ikkunaan cmd. Komentorivillä annetaan tekstikomentoja käyttöjärjestelmälle. Tällä kurssilla pääasiassa siirrytään cd-komennolla hakemistosta toiseen ja käytetään kääntäjää kooditiedostojen kääntämiseen sekä suoritetaan käännettyjä koodeja.
Tietorakenne on yleisnimitys kokoelmille jotka sisältävät useita arvoja. Pythonissa näitä olivat mm. lista, monikko ja sanakirja. C:ssä taas yleisimmät tietorakenteet ovat taulukot (array) ja tietueet (struct).
Tietokoneen muistissa oleva data on pelkästään bittejä, mutta muuttujilla on tyyppi. Tyyppi kertoo millä tavalla muistissa olevat bitit pitää tulkita. Se kertoo myös kuinka suuresta määrästä bittejä muuttujan arvo muodostuu. Tyyppejä ovat esim int, float ja char.
Tyyppimuunnos on operaatio jossa muuttuja muutetaan toisentyyppiseksi. Alkeiskurssilla tätä tehtiin pääasiassa int- ja float-funktioilla. C:ssä tyyppimuunnos merkitään hieman toisin: liukuluku = (float) kokonaisluku. Huomioitavaa on myös, että operaation tulos voidaan tallentaa ainoastaan muuttujaan jonka tyyppi on kohdetyyppiä (esimerkissä float). Pythonissa nähdyt luku = int(luku)-temput eivät siis onnistu.
Varoitusviesti on ilmoitus siitä, että ohjelman suorituksessa tai - erityisesti tällä kurssilla - sen kääntämisessä kohdattiin jotain epäilyttävää, joka saattaa johtaa virhetilanteisiin, mutta ei suoraan estä ohjelman käyttöä. Yleisesti ottaen kaikki varoitukset on syytä korjata ohjelman toiminnan vakauttamiseksi.
Virheviestiksi kutsutaan tietokoneen antamaa virheilmoitusta joko koodia kääntäessä tai ohjelmaa suorittaessa. Virheviesti tyypillisesti sisältää tietoa kohdatusta ongelmasta ja sen sijainnista.
C:ssä main-funktio on ohjelman suorituksen aloituspiste kun ohjelma käynnistetään. Ohjelman komentoriviargumentit tulevat main-funktiolle (mutta niitä ei ole pakko vastaanottaa), ja sen palautusarvon tyyppi on int. Lyhimmillään main-funktion voi siis määritellä: int main().
C:ssä yksi tulostustapa on printf-funktio, joka muistuttaa pääasiassa Pythonin print-funktiota. Sille annetaan tulostettava merkkijono, sekä lisäksi merkkijonoon sijoitettavat arvot mikäli on käytetty paikanpitimiä. Toisin kuin Pythonin print, printf ei automaattisesti lisää rivinvaihtoa, joten loppuun on yleensä syytä lisätä \n.
Silmukoista while pohjautuu toistoon ehdon tarkastelun kautta - silmukan sisällä olevaa koodilohkoa suoritetaan niin kauan kuin silmukalle annettu ehto on tosi. Ehto määritetään samalla tavalla kuin ehtolauseissa, esim: while (summa < 21).