Muuttujan nimen kannattaa kuvata selkeästi, mitä tietoa muuttuja sisältää. Esimerkiksi nimet student_age ja total_price kertovat muuttujien tarkoituksesta paremmin kuin nimet x ja value. Lyhyet nimet, kuten i, sopivat kuitenkin esimerkiksi pienen silmukan laskuriksi, kun niiden merkitys käy asiayhteydestä selvästi ilmi.

Muuttujille on yleensä suositeltavaa antaa englanninkieliset nimet. Englanti on yleinen ohjelmoinnin kieli, ja englanninkieliset nimet sopivat yhteen ohjelmointikielten, kirjastojen ja dokumentaation kanssa. Ne myös helpottavat koodin jakamista eri kieliä puhuvien ohjelmoijien kesken. Samassa ohjelmassa kannattaa käyttää yhtä kieltä ja yhtenäistä nimeämistapaa.

• Nimi kannattaa aloittaa kirjaimella. Tämän jälkeen nimessä voidaan käyttää kirjaimia, numeroita ja alaviivoja. Alaviivalla alkavia nimiä kannattaa välttää, koska osa niistä on varattu kääntäjän ja standardikirjaston käyttöön.
• Nimessä ei voi olla välilyöntejä tai yhdysmerkkejä.
• C-kielen varattuja sanoja, kuten int, for tai return, ei voi käyttää muuttujien niminä.
• C-kieli erottaa isot ja pienet kirjaimet, joten age ja Age ovat eri muuttujia.
• Useasta sanasta muodostetut nimet voidaan kirjoittaa johdonmukaisesti esimerkiksi alaviivoilla: first_name ja maximum_speed.

Muuttuja voidaan luoda esimerkiksi seuraavilla lauseilla

• int age;
• float weight;
• double area;

Muuttujan alustamisella tarkoitetaan arvon sijoittamista muuttujaan sen luonnin yhteydessä. Esimerkiksi näin:

• int age=22;

Muuttujan näkyvyysalue tarkoittaa sitä osaa koodista, josta muuttujan voidaan viitata. Jos muuttujaan viitataan tämän näkyvyysalueen ulkopuolelta, kääntäjä antaa virheilmoituksen joka ilmoittaa "ettei muuttujaa ole".

Muuttujan näkyvyysalue on se lohko, jossa muuttuja on määritelty. Lohko tarkoittaa yleensä alkusulun { ja loppusulun } välistä aluetta.

Esimerkki

int main(){
    int i;
    for (i=1; i<=5; i++) {
        printf("%d: Hello inside loop!\n",i);
    }
    printf("%d: Hello outside loop!\n",i);
    return 0;
}

Jos esimerkkiä muutetaan näin:

int main(){
    for (int i=1; i<=5; i++) {
        printf("%d: Hello inside loop!\n",i);
    }
    printf("%d: Hello outside loop!\n",i);
    return 0;
}

Muuttuja kannattaa yleensä määritellä mahdollisimman lähellä sen käyttöpaikkaa. Jos muuttujaa i käytetään vain silmukan laskurina, se kannattaa määritellä for-lauseessa. Tällöin muuttuja ei ole tarpeettomasti käytettävissä muualla ohjelmassa, ja koodista käy selvemmin ilmi sen käyttötarkoitus. Muuttuja tulee määritellä ennen silmukkaa vain silloin, kun sen arvoa tarvitaan myös silmukan jälkeen.

Erityisesti scanf-funktiota käytettäessä on hyvä ymmärtää mitä tarkoittaa muuttujan osoite. Muuttujan osoite tarkoittaa sen muistipaikan numeroa, johon muuttujan arvo on tallennettu. Voidaan ajatella, että tietokoneen muisti on jaettu samankokoisiin lokeroihin, jotka on numeroitu. Kukin lokero on yhden tavun suuruinen eli siihen voidaan tallentaa 8 bittiä.

Muuttujan osoitteeseen viitataan c-kielessä laittamalla &-merkki muuttujan nimen eteen. Esimerkiksi muuttujan age osoite on &age.

char tyyppiselle muuttujalle varataan muistia vain yksi muistipaikka, joten muuttujan osoite on selkeästi tuon muistipaikan osoite. Sen sijaan esimerkiksi int tyyppiselle muuttujalle varataan yleensä 4 muistipaikkaa ja muuttujan osoitteella tarkoitetaan näistä ensimmäistä. Jos esimerkiksi muuttujalle age on varattu muistipaikat 101,102,103 ja 104, niin &age on 101.

Typecasting tarkoittaa muuttujatyypin vaihtoa ohjelman suorituksen aikana. Se taphtuu kirjoittamalla uusi tyyppi suluissa muuttujan nimen eteen. Tällaista tarvitaan, jos halutaan esimerkiksi laskea kokonaislukujen osamäärä, niin että tulos on liukuluku. Esimerkiksi näin:

    int a, b;
    float result;
    result = (float)a / (float)b;

• Muodossa " %c" ennen %c-määrettä oleva välilyönti ohittaa syötteestä mahdolliset tyhjemerkit, kuten edellisen syötteen rivinvaihdon.
• Merkkitaulukon nimen name eteen ei kirjoiteta &-merkkiä.
• Muodon %29s pituusraja estää 30 merkin taulukon ylivuodon ja jättää tilaa merkkijonon lopetusmerkille '\0'. %s lukee vain ensimmäiseen tyhjemerkkiin asti.
• double-muuttuja luetaan scanf-funktiolla käyttäen määrettä %lf. printf-funktiossa sekä float- että double-arvo tulostetaan määreellä %f.

double distance;
scanf("%lf", &distance);
printf("%f\n", distance);

Funktio muodostuu kahdesta osasta:

• funktion otsikko
• funktion runko

• funktion palautusarvon tyyppi
• funktion nimi
• funktiolle annettavat parametrit ja niiden tyypit

Funktion palautusarvo tarkoittaa tietoa, jonka funktio lopuksi palauttaa. Voidaan esimerkiksi kirjoittaa funktio, joka suorittaa jonkin laskutoimituksen ja palauttaa tuon laskutoimituksen tuloksen. Palauttaminen määritetään käyttäen sanaa return.

Funktion parametrit tarkoittavat funktiolle annettavia lähtötietoja. Jos esimerkiksi kirjoitat funktion, joka laskee kahden kokonaisluvun summan, niin nuo kaksi kokonaislukua ovat funktion parametrit.

Esimerkki yhteenlasku-funktio voidaan kirjoittaa näin:

int sum(int a, int b)
{
    int answer=a+b;
    return answer;
}

• funktio palauttaa int-tyyppisen arvon
• funktion nimi on sum
• funktiolla on parametrit a ja b, molemmat int-tyyppiä

Sulkumerkkien {} sisällä oleva osa muodostaa funktion rungon. Sen sisällä suoritetaan yhteenlasku ja lopuksi palautetaan laskun tulos.

void-palautusarvo tarkoittaa, että funktio ei palauta mitään. Esimerkiksi yhteenlaskufunktio voidaan toteuttaa niin, että se tulostaa vastauksen, eikä palauta mitään:

void second_sum(int a, int b)
{
    int answer=a+b;
    printf("The sum is %d\n", answer);
}

Funktiota ei suoriteta, jollei sitä kutsuta. Funktion kutsu siis ilmoittaa, että tässä kohdassa halutaan suorittaa mainittu funktio.

Funktiota kutsutaan "mainitsemalla" sen nimi. Nimen perään tulee aina sulut (). Sulkujen sisään tulee argumentit eli siis ne arvot, jotka funktion parametreille annetaan. Jos, funktio palauttaa jotain, yleensä tämä palautusarvo tallennetaan johonkin (tai tulostetaan).

Esimerkiksi em. funktiota, joka ei palauta mitään voidaan kutsua näin:

second_sum(7,8);

Sen sijaan funktiota joka palauttaa annettujen lukujen summan voitaisiin kutsua näin:

int calc=sum(5,6);

Funktion prototyypin tarkoitus on kertoa kääntäjälle mikä on funktion palautusarvon tyyppi ja mikä on funktion parametrien lukumäärä ja niiden tyypit. Prototyypit kirjoitetaan yleensä ohjelman alkuun, koska prototyyppi on esitettävä ennen kuin funktiota kutsutaan.

Funktion prototyypiksi kelpaa funktion otsikko eli esimerkiksi aiemmista esimerkeistä rivi int sum(int a, int b). Parametrien nimiä ei ole prototyypissä välttämätön mainita eli voitaisiin kirjoittaa edellinen prototyyppi myös muodossa int sum(int , int )

Alla olevassa esimerkissä prototyyppien poisjättäminen aiheuttaa virheilmoituksen tai ainakin varoituksen.

int sum(int , int );
void second_sum(int , int );

int main(){
    int sum(int a, int b);
    void second_sum(int a, int b);

    int calc=sum(5,6);
    printf("The sum is %d\n",calc);
    second_sum(7,8);
    return 0;
}

int sum(int a, int b){
    int answer=a+b;
    return answer;
}

void second_sum(int a, int b){
    int answer=a+b;
    printf("The sum is %d\n", answer);
}

ping google.com

#include <stdio.h>
void valueTest(int x);
void pointerTest(int *x);

int main()
{
    int x=5;

    printf("Aluksi arvo=%d\n",x);
    //kutsutaan valueTest-funtiota
    valueTest(x);
    printf("valueTest kutsuttu ja mainissa arvo=%d\n",x);
    printf("\n");
    //kutsutaan pointerTest-funtiota
    pointerTest(&x);
    printf("pointerTest kutsuttu ja mainissa arvo=%d\n",x);
    printf("\n");
    return 0;
}
void valueTest(int x){
    x=x+2;
    printf("\tvalueTest funktiossa arvo=%d\n",x);
}
void pointerTest(int *x){
    *x = *x+2;
    printf("\tpointerTest funktiossa arvo=%d\n",*x);
}

printf- ja scanf-funktioissa merkkijonon muunnosmääre on %s.

Seuraavassa esimerkissä käyttäjältä kysytään nimi ja hänelle tulostetaan tervehdys:

#include <stdio.h>

int main(void)
{
    char fname[30];

    printf("What is your name?\n");
    scanf("%29s", fname);
    printf("Hello %s\n", fname);

    return 0;
}

• Esimerkissä luodaan fname-niminen 30 merkin taulukko. Siihen mahtuu enintään 29 varsinaista merkkiä, koska viimeinen paikka tarvitaan merkkijonon lopetusmerkille '\0'.
• Muunnosmääreen leveys %29s estää scanf-funktiota kirjoittamasta taulukon rajojen ulkopuolelle.
• scanf-kutsussa käytetään nimeä fname ilman &-merkkiä. Tässä yhteydessä taulukon nimi muuntuu osoittimeksi sen ensimmäiseen alkioon eli arvoon &fname[0].

Ilmaus &fname tarkoittaa osoitinta koko taulukkoon. Sen osoitearvo on sama kuin ensimmäisen alkion osoite, mutta sen tyyppi on eri, joten sitä ei pidä antaa scanf-funktion %s-muunnokselle.

scanf-funktio lopettaa %s-muunnoksella lukemisen ensimmäiseen tyhjemerkkiin. Siksi sillä voidaan lukea vain yksi sana kerrallaan. Kokonainen rivi, joka voi sisältää välilyöntejä, voidaan lukea fgets-funktiolla:

char fname[100];
fgets(fname, sizeof(fname), stdin);

Kun scanf-funktiolla luetaan syötettä, se jättää usein rivinvaihtomerkin \n syötepuskuriin. Jos tämän jälkeen käytetään fgets-funktiota, se voi lukea jäljelle jääneen rivinvaihdon ja palauttaa tyhjän rivin. Ennen fgets-kutsua rivin loput voidaan lukea ja hylätä seuraavasti:

int c;
while ((c = getchar()) != '\n' && c != EOF) {
}

Muuttujan c tyyppi on int, koska getchar voi palauttaa joko luetun merkin tai erityisen EOF-arvon. Seuraavassa esimerkissä ikä luetaan scanf-funktiolla ja koko nimi fgets-funktiolla:

#include <stdio.h>
#include <string.h>

int main(void)
{
    int age;
    char fullname[100];

    printf("Enter your age: ");
    scanf("%d", &age);

    /* Luetaan ja hylätään nykyisen syöttörivin loput. */
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
    }

    printf("Enter your full name: ");
    fgets(fullname, sizeof(fullname), stdin);
    fullname[strcspn(fullname, "\n")] = '\0';

    printf("Age: %d\n", age);
    printf("Full name: %s\n", fullname);

    return 0;
}

Tyhjentämättä syöttöpuskuria fgets lukisi scanf-funktion jättämän rivinvaihdon ja palauttaisi tyhjän merkkijonon sen sijaan, että odottaisi käyttäjän nimeä.

Syötepuskuria ei tarvitse tyhjentää, jos kaikki käyttäjän syötteet luetaan fgets-funktiolla. fgets-funktiolla luettu ikä voidaan muuntaa kokonaisluvuksi esimerkiksi strtol-funktiolla. Seuraava yksinkertaistettu esimerkki olettaa, että käyttäjä syöttää kelvollisen kokonaisluvun ja että syötteiden lukeminen onnistuu:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char input[100];
    char fullname[100];
    int age;

    printf("Enter your age: ");
    fgets(input, sizeof(input), stdin);
    age = (int)strtol(input, NULL, 10);

    printf("Enter your full name: ");
    fgets(fullname, sizeof(fullname), stdin);
    fullname[strcspn(fullname, "\n")] = '\0';

    printf("Age: %d\n", age);
    printf("Full name: %s\n", fullname);

    return 0;
}

Huomautus: Oikeassa ohjelmassa kannattaa tarkistaa, onnistuiko syötteen lukeminen. Katso tarkistukset sisältävä esimerkki.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char input[100];
    char fullname[100];
    int age;

    printf("Enter your age: ");
    if (fgets(input, sizeof(input), stdin) == NULL) {
        return 1;
    }
    age = (int)strtol(input, NULL, 10);

    printf("Enter your full name: ");
    if (fgets(fullname, sizeof(fullname), stdin) == NULL) {
        return 1;
    }
    fullname[strcspn(fullname, "\n")] = '\0';

    printf("Age: %d\n", age);
    printf("Full name: %s\n", fullname);

    return 0;
}

strcspn-funktiolla etsitään nimen lopusta fgets-funktion tallentama rivinvaihto ja korvataan se merkkijonon lopetusmerkillä '\0'.

Huomautus: Jos käyttäjä kirjoittaa nimeksi Teppo Testi ja painaa Enter-näppäintä, fgets tallentaa merkkijonon tavallisesti muodossa "Teppo Testi\n\0". Jos rivinvaihtoa \n ei poisteta, se voi aiheuttaa tulostukseen ylimääräisen rivinvaihdon. Myös esimerkiksi vertailu strcmp(fullname, "Teppo Testi") epäonnistuu, koska fullname sisältää nimen lisäksi rivinvaihdon.

Kaksiulotteinen taulukko määritellään antamalla kaksi indeksiä eli ikäänkuin rivien ja sarakkaiden lukumäärä. Esimerkiksi seuraavassa määritellään kaksiulotteinen kokonaislukutaulukko.

int main()
{
    int tableOfNumbers[2][3]={
        {1,2,3},
        {4,5,6}
    };
    printf("The last number in the table is %d\n",tableOfNumbers[1][2]);
    return 0;
}

Yksinkertaisimmillaan ehtorakenne koostuu if-lauseesta ja lohkosta, joka suoritetaan vain ehdon ollessa tosi:

int test = 5;

printf("Before the test\n");
if (test == 5) {
    printf("The value of test is 5\n");
}
printf("After the test\n");

Ehto test == 5 on tosi, kun muuttujan test arvo on 5. Tällöin aaltosulkeiden { } sisällä oleva lohko suoritetaan. Jos ehto on epätosi, lohko ohitetaan. Vertailuoperaattori == tutkii arvojen yhtäsuuruutta, kun taas sijoitusoperaattori = antaa muuttujalle arvon.

Vertailuoperaattorit vertaavat kahta arvoa. Vertailun tulos on joko tosi tai epätosi.

Loogisilla operaattoreilla voidaan yhdistää ehtoja tai kääntää ehdon totuusarvo.

if (age >= 13 && age <= 19) {
    printf("Teenager\n");
}

if (day == 6 || day == 7) {
    printf("Weekend\n");
}

if (!is_logged_in) {
    printf("Please log in\n");
}

Operaattorit && ja || käyttävät oikosulkuarviointia. Operaattorin && jälkimmäistä ehtoa ei tutkita, jos ensimmäinen ehto on epätosi. Operaattorin || jälkimmäistä ehtoa ei tutkita, jos ensimmäinen ehto on tosi.

Huomautus: Loogiset operaattorit && ja || ovat eri operaattoreita kuin bittitason operaattorit & ja |.

C-kielessä <stdbool.h>-otsikkotiedosto määrittelee tyypin bool sekä arvot true ja false.

#include <stdbool.h>

bool is_ready = true;

Totuusarvoa ei tarvitse verrata erikseen arvoon true tai false. Seuraavat muodot ovat lyhyitä ja selkeitä:

if (is_ready) {
    printf("Ready\n");
}

if (!is_ready) {
    printf("Not ready\n");
}

C-kielen ehdoissa arvo 0 tulkitaan epätodeksi ja kaikki nollasta poikkeavat arvot tosiksi.

if–else-rakenteessa suoritetaan kahdesta vaihtoehdosta täsmälleen toinen:

if (is_ready) {
    printf("The program is ready\n");
} else {
    printf("The program is not ready\n");
}

Jos ehto on tosi, suoritetaan if-lohko. Muussa tapauksessa suoritetaan else-lohko.

Ehdollinen operaattori valitsee ehdon perusteella kahdesta arvosta toisen. Sitä kutsutaan myös ternääriseksi operaattoriksi, koska siinä on kolme osaa:

ehto ? arvo_jos_tosi : arvo_jos_epätosi

Esimerkiksi seuraava if–else-rakenne valitsee pääsymaksun asiakkaan iän perusteella:

int age = 16;
int fee;

if (age < 18) {
    fee = 5;
} else {
    fee = 10;
}

Sama valinta voidaan kirjoittaa ehdollisella operaattorilla näin:

int age = 16;
int fee = (age < 18) ? 5 : 10;

Ehdollisen operaattorin etuna on, että kahdesta arvosta valitseminen voidaan kirjoittaa tiiviisti yhtenä lausekkeena. Sitä kannattaa käyttää, kun ehto ja molemmat vaihtoehdot ovat lyhyitä ja rakenne säilyy helposti luettavana.

Tavallinen if–else on parempi valinta, jos vaihtoehdoissa suoritetaan useita toimenpiteitä, kutsutaan eri funktioita tai käytetään monimutkaisia ehtoja. Sisäkkäisiä ehdollisia operaattoreita kannattaa yleensä välttää, koska ne vaikeuttavat koodin lukemista.

Kun vaihtoehtoja on enemmän kuin kaksi, voidaan käyttää yhtä tai useampaa else if-haaraa:

int test = 1;

if (test == 1) {
    printf("Option A\n");
} else if (test == 2) {
    printf("Option B\n");
} else if (test == 3) {
    printf("Option C\n");
} else {
    printf("Option D\n");
}

Ehdot tutkitaan ylhäältä alaspäin. Vain ensimmäinen haara, jonka ehto on tosi, suoritetaan. Jos mikään ehto ei ole tosi, suoritetaan mahdollinen else-haara.

Seuraavassa esimerkissä henkilö luokitellaan iän perusteella lapseksi, teini-ikäiseksi tai aikuiseksi:

int age = 16;

if (age < 13) {
    printf("Child\n");
} else if (age <= 19) {
    printf("Teenager\n");
} else {
    printf("Adult\n");
}

Kun ohjelma pääsee toiseen ehtoon, ensimmäisen ehdon tiedetään jo olevan epätosi. Siksi ehtoa ei tarvitse kirjoittaa muodossa age >= 13 && age <= 19, vaan pelkkä ylärajan tarkistus age <= 19 riittää.

switch-rakenne sopii tilanteeseen, jossa yhden muuttujan arvoa verrataan useisiin kiinteisiin arvoihin. Aiemman test-esimerkin voi kirjoittaa näin:

switch (test) {
    case 1:
        printf("Option A\n");
        break;
    case 2:
        printf("Option B\n");
        break;
    case 3:
        printf("Option C\n");
        break;
    default:
        printf("Option D\n");
}

Jokainen case määrittää yhden mahdollisen arvon. break lopettaa switch-rakenteen suorittamisen, jotta suoritus ei jatku seuraavaan haaraan. default suoritetaan, jos mikään case-arvo ei vastaa muuttujan arvoa.

switch ei sovellu suoraan vaihteluvälien tai operaattoreilla && ja || yhdistettyjen ehtojen tutkimiseen. Tällaisissa tilanteissa käytetään tavallisesti if–else if -rakennetta.

Yksittäisiä merkkejä voidaan verrata tavallisilla vertailuoperaattoreilla. Välilyönti ennen %c-määrettä ohittaa syötteeseen mahdollisesti jääneet tyhjemerkit:

char character;
scanf(" %c", &character);

if (character == 'a') {
    printf("The character is a\n");
}

Merkkijonojen sisältöjä ei verrata operaattorilla ==, sillä se vertaisi merkkijonojen osoitteita. <string.h>-otsikkotiedostossa esitelty strcmp-funktio vertaa merkkijonojen sisältöjä:

#include <string.h>

char word[20];
scanf("%19s", word);

if (strcmp(word, "Terve") == 0) {
    printf("The strings are equal\n");
}

strcmp palauttaa arvon 0, kun sille annetut merkkijonot ovat sisällöltään samat. Muodon %19s pituusraja jättää 20 merkin taulukkoon tilaa myös merkkijonon lopetusmerkille.

Joskus tarvitaan toistorakenne toistorakenteen sisälle. Seuraavassa esimerkissä kaksiulotteisen kokonaislukutaulukon alkiot tulostetaan rivi kerrallaan kahdella sisäkkäisellä for-silmukalla.

int main()
{
    int tableOfNumbers[3][4] = {
        {5, 2, 9, 11},
        {4, 6, 8, 10},
        {12, 8, 4, 3}
    };
    for (int row = 0; row < 3; row++) {
        for (int column = 0; column < 4; column++) {
            printf("%d, ", tableOfNumbers[row][column]);
        }
        printf("\n");
    }
    return 0;
}

Edellisen ohjelman tulostus on:

5, 2, 9, 11,
4, 6, 8, 10,
12, 8, 4, 3,

Matemaattiset operaattorit ovat:

• + yhteenlaskuoperaattori
• - vähennyslaskuoperaattori
• * kertolaskuoperaattori
• / jakolaskuoperaattori
• % jakojäännösoperaattori

Incrementointi tarkoittaa tässä yhteydessä muuttujan arvon kasvattamista yhdellä ja decrementointi taas vähentämistä yhdellä. C-kielessä nämä ovat

• ++ incrementointi
• -- decrementointi

Yksinkertaisin sijoitusoperaattori on =, joka siis sijoittaa merkin oikealla puolella olevan arvon(muuttuja tai vakio) merkin vasemmalla puolella olevaan muuttujaan.

Muita sijoitusoperaattoreita ovat :

Osoitinta tarvitaan, jos funktion pitää muuttaa sille annettujen muuttujien arvoja. Esimerkiksi seuraavassa sovelluksessa funktiolle doubleValueByValue annetaan muuttujan x arvo argumenttina. Tällöin funktio ei muokkaa alkuperäisen muuttujan x arvoa, koska funktion parametrina määritelty muuttuja x ei ole sama muuttuja kuin mainissa määritelty x.

void doubleValueByValue(int x);
int main()
{
    int x=5;
    doubleValueByValue(x);
    printf("Test1: mainissa x:n arvo=%d\n",x);

    return 0;
}

void doubleValueByValue(int x){
    x=2*x;
    printf("funktiossa doubleValueByValue x:n arvo=%d\n",x);
}

funktiossa doubleValueByValue x:n arvo=10
Test1: mainissa x:n arvo=5

void doubleValueByPointer(int *x);
int main()
{
    int x=5;

    doubleValueByPointer(&x);
    printf("Test2: mainissa x:n arvo=%d\n",x);
    return 0;
}

void doubleValueByPointer(int *x){
    *x=2**x;
    printf("funktiossa doubleValueByPointer x:n arvo=%d\n",*x);
}

funktiossa doubleValueByPointer x:n arvo=10
Test2: mainissa x:n arvo=10

Samasta tietuetyypistä voidaan muodostaa taulukko. Seuraava esimerkki tallentaa kolmen joukkueen jäsenen numerot ja nimet:

Joukkuetta varten luodaan team-niminen kolmen alkion tietuetaulukko lauseella Person team[3] = {0};. Person on tietuetyypin nimi, team on taulukkomuuttujan nimi ja [3] ilmoittaa taulukon alkioiden määrän. Alustus {0} alustaa taulukon kaikkien tietueiden kentät nolliksi: jokaisen number-kentän arvoksi tulee 0 ja name-kentän merkit alustetaan nollamerkeiksi, jolloin nimi on aluksi tyhjä merkkijono.

#include <stdio.h>
#include <string.h>

typedef struct Person {
    int number;
    char name[20];
} Person;

Person team[3] = {0};

for (int x = 0; x < 3; x++) {
    printf("Anna %d. numero\n", x + 1);
    scanf("%d", &team[x].number);

    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
    }

    printf("Anna %d. nimi\n", x + 1);
    if (fgets(team[x].name, sizeof(team[x].name), stdin) != NULL) {
        team[x].name[strcspn(team[x].name, "\n")] = '\0';
    }
}

printf("Joukkueen jäsenet\n");
for (int x = 0; x < 3; x++) {
    printf("Nimi: %s, numero: %d\n", team[x].name, team[x].number);
}

scanf-funktion jälkeen syötepuskuriin jäävä rivinvaihto poistetaan getchar-silmukalla ennen nimen lukemista. Nimi luetaan fgets-funktiolla, jotta se voi sisältää välilyöntejä. fgets tallentaa yleensä myös rivinvaihdon merkkijonoon, joten se etsitään strcspn-funktiolla ja korvataan merkkijonon lopetusmerkillä '\0'.

Tiedostosta voidaan lukea merkkejä fscanf-funktiolla. Sen syntaksi on muuten sama kuin scanf-funtkiolla, mutta ensimmäinen parametri on tiedosto osoitin. Esimerkiksi kaksi lausetta, joista ensimmäinen lukee ruudulta annetun luvun ja jälkimmäinen tiedostosta

scanf("%d", &age);
fscanf(filepointer, "%d", &age);

Tiedostoon voidaan kirjoittaa fprintf-funktiolla. Sen syntaksi on muuten sama kuin printf-funktiolla, mutta ensimmäinen parametri on tiedosto osoitin. Esimerkiksi kaksi lausetta, joista ensimmäinen tulostaa ruudulle ja jälkimmäinen tiedostoon

printf("Name of the student = %s and age =  %d",name, age);
fprintf(filepointer,"Name of the student = %s and age = %d",name, age);

char x='a';
fputc(x, filepointer);