Tässä oppaassa käsitellään C++ kieltä ja sen olio-ominaisuuksia. Oppaan lähtökohtana, on että lukija on ohjelmoinut C-kielellä.

Aiheeseen liittyviä video-oppaita löytyy sivulta https://www.youtube.com/playlist?list=PLWl0bS7jZq9_6i4B1l4Im6sx9DKwUo7OU

Oppaaseen liittyvien esimerkkien lähdekoodit löytyy sivulta https://github.com/orgs/olio-kurssi/repositories.

Olio-ohjelmoinnin tärkeimmät käsitteet ovat luokka ja olio. Voisit ajatella, että luokka on ohjelmoijan tekemä uusi muuttujatyyppi ja olio muuttuja, jonka tyyppinä on tuo luokka. Voit siis verrata sitä tilanteeseen, jossa määrittelet muuttujan lauseella int age;. Samalla tavalla määrittelet olion lauseella Student myObject;. Sinun on kuitenkin itse luotava tuo luokka nimeltään Student.

Milloin on tarpeen luoda luokka ja olio?
Esimerkiksi teet sovelluksen, jossa käsittelet opiskelijoiden tietoja. Jokaiselle opiskelijalle määritellään nimi, syntymävuosi, osoite, sähköpostiosoite ja puhelinnumero. Yhdelle opiskelijalle sinun on luotava 5 muuttujaa. Jos käsittelet 10 opiskelijan tietoja, sinun on luotava 50 muuttujaa.

Edellistä parempi ratkaisu on luoda tietue, jossa määritellään nuo 5 muuttujaa. Ja sitten luot 10 muuttujaa, joiden tyyppinä on tuo tietue.

Miksi luoda luokka, jos tietuekin toimii?
Luokan sisään voit sijoittaa myös metodeja eli funktioita. Niiden avulla voit esimerkiksi antaa edellä mainutuille 5:lle muuttujalle arvoja hallitummin. Ja voit luoda metodeja jotka tulostavat noiden muuttujien arvoja haluamallasi tavalla.

Kun tehdään graafisia sovelluksia tarvitaan paljon buttoneita, tekstikenttiä, labeleita, alasvetovalikoita jne. Yleensä käytetään jotain valmiita kirjastoja tai frameworkkejä. Niissä on valmiiksi tehtynä esimerkiksi Button luokka, jolla on ominaisuuksia: buttonissa oleva teksti, klikkauksen aiheuttama tapahtuma, buttonin väri, reunojen tyyli jne. Aina kun laitamme omaan sovellukseemme buttonin, luomme Button luokan olion.

Mikä on Qt?
Qt on framework jolla voidaan luoda graafisia sovelluksia. Qt sisältää joukon valmiiksi tehtyjä luokkia, joita voimme hyödyntää. Kun asennat Qt:n voit asentaa myös Qt Creatorin. Qt Creator on graafinen sovellus, jolla voidaan luoda Qt-sovelluksia ja myös C- ja C++-sovelluksia.

Aluksi on syytä tutustua kuinka C++ kielessä tulostetaan konsolin ruudulle ja kuinka sieltä luetaan käyttäjän antamaa dataa. Voit toki käyttää C-kielestä tuttuja funktioita printf ja scanf, mutta niiden sijaan käytetään yleensä olioita: cout ja cin. Molemmat ovat iostream luokan olioita, joten niitä käyttäessäsi sinun tulee lisätä kooditiedostoon alkuun rivi

#include <iostream>

C++ kielessä voidaan käyttää merkkijonoille muuttujatyyppiä string, jota C-kielessä ei ole. C-kielessähän merkkijonoille käytettiin char -taulukkoja. Tuo string, samoin kuin cout ja cin on määritetty nimiavaruudessa eli namespace:ssa nimeltään std.

Voisit tehdä lyhyen ohjelman koodilla

#include <iostream>

int main()
{
    std::string name;
    std::cout<<"Kerro nimesi"<<std::endl;
    std::cin>>name;
    std::cout<<"Terve "<<name<<std::endl;
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    string name;
    cout<<"Kerro nimesi"<<endl;
    cin>>name;
    cout<<"Terve "<<name<<endl;
    return 0;
}

Olio-ohjelmoinnin kaksi keskeistä termiä ovat luokka ja olio. Olio-ohjelmoinnissa tieto ja sitä käsittelevä toiminnallisuus kootaan luokkarakenteeksi. Luokista luodaan olioita.

Olio-ohjelmointia tukevia kieliä ovat mm. C++, C#, Java ja Visual Basic. C++ poikkeaa muista edellä mainituista siten, että C++ sovelluksia ajetaan suoraan käyttöjärjestelmän päällä. Muilla edellä mainituilla kielillä tehdyt sovellukset ajetaan virtuaalikoneessa. Edellä mainitun eron vuoksi C++ sovellukset vaativat vähemmän resursseja koneelta ja toimivat näin nopeammin, varsinkin heikkotehoisissa koneissa. Haittapuolena on, että C++ sovelluksen ohjelmoiminen on työläämpää. C++ ohjelmoijan tulee itse huolehtia esimerkiksi muistin varaamisesta ja vapauttamisesta, kun muissa em. kielissä virtuaalikone huolehtii siitä. Alla olevassa kuvassa kuvataan C++ - ja Java-sovelluksen toimintaa.

Olio-ohjelmoinnin neljä tärkeää perusperiaatetta ovat: kapselointi, tiedon kätkentä, periytyminen ja polymorfismi.

Opiskeltuasi c-kieltä tietue lienee sinulle tuttu käsite. Myös C++ ohjelmassa voit luoda tietueita esimerkiksi seuraavasti:

typedef struct Person_struct{
    int age;
    string name;
}
person;

person pe;

pe.age=23;
pe.name="Teppo Testi";

Luokka voisi olla samanlainen, mutta usein se sisältää myös metodeja, joiden avulla noita muuttujia käsitellään. Voidaan luoda Person luokka seuraavasti:

class Person{
    private:
        int age;
        string name;
    public:
        int getAge() const {
            return age;
        }
        void setAge(int value){
            age=value;
        }
        string getName() const {
            return name;
        }
        void setName(string value){
            name=value;
        }
};

Luokan sisältämiä muuttujia nimitetään jäsenmuuttujiksi ja luokan sisältämiä funktioita (jotka käsittelevät em. muuttujia) nimitetään jäsenfunktioiksi eli metodeiksi.

Oheisen esimerkin sovellus, löytyy sivulta https://github.com/olio-kurssi/esim1

#ifndef PERSON_H
#define PERSON_H

#include <iostream>

using namespace std;

class Person
{
public:
    Person();
    int getAge() const;
    void setAge(int newAge);

    string getFname() const;
    void setFname(const string &newFname);

private:
    int age;
    string fname;
};

#endif // PERSON_H

#include "person.h"

Person::Person()
{

}

int Person::getAge() const
{
    return age;
}

void Person::setAge(int newAge)
{
    age = newAge;
}

string Person::getFname() const
{
    return fname;
}

void Person::setFname(const string &newFname)
{
    fname = newFname;
}

Person objectPerson1;

//luo osoitin, jonka tyyppinä Person    
Person *objectPerson2;
//varaa osoittimelle muistia new operaattorilla
*objectPerson2 = new Person;

Person *objectPerson2 = new Person;

objectPerson1.setAge(23);

objectPerson2->setAge(23);

delete objectPerson2;
objectPerson2 = nullptr;

#include <memory>
unique_ptr<Person> objectPerson = make_unique<Person>();

#include <iostream>
#include <memory>

using namespace std;
class TestClass{
public:
    TestClass(string value){
        fname=value;
        cout<<"TestClass olio luotiin"<<endl;
    }
    ~TestClass(){
        cout<<"TestClass olio tuhottiin"<<endl;
    }
    string getName(){
        return fname;
    }
private:
    string fname;
};


void functionFirst();
void functionSecond(shared_ptr<TestClass> ptr);


int main()
{
    functionFirst();
}

void functionFirst(){
    shared_ptr<TestClass> ptr1=make_shared<TestClass>("Teppo");
    cout<<"Funktiossa1 nimi = "<< ptr1->getName()<<endl;;
    functionSecond(ptr1);
}
void functionSecond(shared_ptr<TestClass> ptr2){
    cout<<"Funktiossa2 nimi = "<< ptr2->getName()<<endl;
}

Edellä, jo kerrottiin, että luokan muodostin on metodi, jolla on sama nimi kuin itse luokalla. Muodostinta kutsutaan aina kun luokasta luodaan olio. Sillä ei ole koskaan paluuarvoa, eikä paluuarvoksi kirjoiteta edes sanaa void.

Voit lisätä muodostimelle parametrin tai useita parametrejä. Jos edellä muokattaisiin luokan muodostin h tiedostossa muotoon

Person(int value);

Person::Person(int value)
{
    age=value;
}

Person *objectPerson=new Person(46);

Person *objectPerson=new Person;

Person();
Person(int value);

Luokan tuhoaja on myös saman niminen kuin luokka, mutta sen edessä on merkki ~ eli seuraava olisi h-tiedostossa

~Person();

Person::~Person()
{
    cout<<"Person luokan tuhoajaa kutsuttiin\n";
}

Person *objectPerson=new Person;
delete objectPerson;
objectPerson=nullptr;

Sinun ei ole pakko luoda luokalle tuhoajaa, koska kääntäjä luo automaattisesti "näkymättömän tuhoajan". Ohjelmoijan kannattaa luoda tuhoaja vain, jos haluaa lisätä siihen jotain koodia.

Oheiseen esimerkkiin liittyvä sovellus, löytyy sivulta https://github.com/olio-kurssi/esim2

C++ mahdollistaa funktioiden ylikuormittamisen (function overloading) eli sen, että saman nimisiä funktioita on useita, mutta niillä on erilaiset parametrit. Myös palautusarvot voivat olla erilaisia, mutta pelkät erilaiset paluuarvot eivät mahdollista ylikuormitusta, jos parametrit ovat samat. Kääntäjä valitsee funktion kutsussa annettujen argumenttien avulla sopivan funktion.

Esimerkki ylikuormittamisesta

void calcSum(int a, int b){
    int sum=a+b;
    cout<<"Kokonaislukujen summa = "<<sum<<endl;
}
void calcSum(double a, double b){
    double sum=a+b;
    cout<<"Desimaalilukujen summa = "<<sum<<endl;
}

Periytyminen eli inheritance tarkoittaa, että jokin luokka voi periä toisen luokan. Ajatellaan esimerkiksi että rakentaisimme sovellusta, jolla käsitellään jonkin oppilaitoksen dataa. Todetaan, että oppilaitoksessa on opiskelijoita ja opettajia. Molemmilla on monia samalaisia ominaisuuksia, kuten esimerkiksi nimi ja syntymävuosi. Lisäksi opiskelijoilla on ryhmätunnus ja opettajilla on osasto.

Nyt voidaan tehdä niin, että

1. luodaan kantaluokka Person, johon laitetaan kaikille yhteiset ominaisuudet
2. luodaan luokka Student, joka perii luokan Person ja luokalla on lisäominaisuus groupName
3. luodaan luokka Teacher, joka perii luokan Person ja luokalla on lisäominaisuus department

Perityminen merkitään Student-luokalle näin:

class Student : public Person

Oheiseen esimerkkiin liittyvä sovellus, löytyy sivulta https://github.com/olio-kurssi/esim3. Sovelluksen luokkakaavio näyttää seuraavalta:

Periytymisen yhteydessä on syytä tutustua termiin protected, kun luokka perii toisen luokan se pääsee käsiksi ominaisuuksiin, jotka ovat tyypiltään public tai protected. Seuraavassa taulukossa kuvataan kuinka private, public ja protected rajaavat oikeuksia.

Edellä kuvattiin luokan jäsenten suojauksia. Periytymiselle voidaan myös määrittää suojaus seuraavilla vaihtoehdoilla

• class Student : public Person
  jolloin perivällä luokalla on pääsy perittävän public- ja protected-jäseniin
• class Student : protected Person
  jolloin perittävän luokan public-jäsenistä tulee perivän luokan protected-jäseniä
• class Student : private Person
  jolloin perittävän luokan public- ja protected-jäsenistä tulee perivän luokan private-jäseniä

Voit lukea lisätietoa periytymisestä sivulta https://www.tutorialspoint.com/cplusplus/cpp_inheritance.htm

Mikäli peritävässä luokassa on muodostin, joka ottaa parametreja, voidaan perivän luokan konstruktorissa kutsua tuota muodostinta.

Esimerkiksi, jos Person luokassa on seuraava muodostin

Person::Person (string na){
    name=na;
}

Student::Student(string gr, string na ) : Person(na){
    groupName=gr;
} 

Jos edellä Person luokalla on oletusmuodostin ja public tyyppinen metodi setName(), voitaisiin Student-luokan muodostin kirjoittaa muotoon:

Student::Student(string gr, string na ) {
    groupName=gr;
    this->setName(na);
} 

Abstrakti luokka, tarkoittaa luokkaa, josta ei voi luoda oliota, mutta luokkaa voidaan käyttää kantaluokkana muille luokille. Edellisessä esimerkissä voisimme tehdä Person luokasta abstraktin.

C++ kielessä abstraktin luokan luomiseksi on ensin tutustuttava käsitteeseen virtuaalimetodi. Virtuaalimetodiksi merkitty metodi on tarkoitus ylikirjoittaa (override) perivässä luokassa erilaisella metodilla. Seuraavassa esimerkissä lisäsin Person luokkaan metodin sayStatus ja ylikirjoitin sen Students ja Teacher luokissa.

Alla rivit h-tiedostoista

person.h
virtual void sayStatus();

student.h 
virtual void sayStatus() override; 

teacher.h 
virtual void sayStatus() override; 

void Person::sayStatus()
{
    cout<<"Person\n ";
}
void Student::sayStatus()
{
    cout<<"Opiskelija: ";
}
void Teacher::sayStatus()
{
    cout<<"Opettaja: ";
}

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim4

Edellisessä esimerkissä voit luoda Person luokasta olion. Luokka saadaan abstraktiksi, jos siihen lisätään yksi pure virtual method. Muutetaan Person luokassa sayStatus() metodin määrittely muotoon

virtual void sayStatus()=0;

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim5

Virtuaalifunktioita sisältävän luokan tuhoajan pitää myös olla virtuaalinen.

Luokkien välillä voi olla seuraavanlaisia suhteita

• Assosiaatio: Tämä viittaa kahden tai useamman luokan väliseen suhteeseen, jossa toinen luokka käyttää toisen luokan jäseniä. Se ei osoita omistussuhdetta eikä määrittele elinkaarisuhdetta, vaan yksinkertaisesti ilmaisee, että luokat ovat jollain tavalla yhteydessä toisiinsa. Esimerkiksi luokka "Auto" ja luokka "Moottori" voivat olla assosioituneita, koska auto käyttää moottoria.
• Aggregaatio: Tässä suhteessa yksi luokka "omistaa" toisen luokan ilmentymän. Se on looginen suhde, jossa yksi objekti koostuu toisista objekteista, mutta niillä voi olla oma elinkaari. Esimerkiksi, "Auto" voi sisältää "Moottorin", mutta moottori voi olla olemassa ilman autoakin.
• Kompositio: Tämä on tiukempi versio aggregaatiosta. Se tarkoittaa sitä, että jos koostavan luokan olio tuhoutuu, myös sen sisältämät toisten luokkien oliot tuhoutuvat. Se on "kokonaisuus ja osa" -suhde, jossa osalla ei ole itsenäistä elämää ilman kokonaisuutta. Esimerkiksi, "Talo" koostuu "Huoneista", ja jos talo tuhoutuu, myös sen huoneet tuhoutuvat.

Kompositio eli vahva kooste tarkoittaa tilannetta, jossa koosteluokka sisältää toisen luokan olion/olioita. Esimerkissä 6 on luokka Classroom, joka sisältää kaksi Student-luokan oliota ja yhden Teacher-luokan olion seuraavasti:

class Student {

}
class Teacher {

}
Class Classroom{
private:
    unique_ptr objStudent1;
    unique_ptr objStudent2;
    unique_ptr objTeacher;
}

Sovelluksen luokkadiagrammi pelkistettynä näyttää tältä

Classroom on siis koosteluokka. Tässä esimerkissä Student- ja Teacher-luokan oliot luodaan smart pointtereiden avulla, mutta ne voitaisiin luoda myös "normi" pointtereilla tai pinomuistiin.

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim6

Kooste ja perintä ovat molemmat oliosuuntautuneita ohjelmistomalleja. Kooste tarkoittaa has a-tyyppistä suhdetta ja perintä is a-tyyppistä suhdetta. Tämän sivun esimerkeistä voidaan sanoa, että

• "Student is a Person", joten käytetään perintää
• "Classroom has a Student", joten käytetään koostetta

C++-vektori on osa C++ Standard Libraryä ja se on dynaaminen taulukko, joka voi mukautua erilaisiin datamäärien muutoksiin. Se tarjoaa samankaltaisia ominaisuuksia kuin perinteinen taulukko, kuten nopea elementteihin pääsy, mutta toisin kuin perinteiset taulukot, vektorin koko voi muuttua joustavasti.

Jos sovelluksessa tarvitaan monta oliota samasta luokasta, voidaan niistä luoda lista vektorin avulla. Seuraavassa esimerkissä luodaan oliolista, joka sisältää Student-luokan oliota. Listan käytöstä erillisten olioiden sijaan on etuna se, että listaa voidaan käydä läpi toistorakenteella.

#include "student.h"
#include "teacher.h"

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    vector studentList;

    Student objectStudent0("Teppo Testi",1999,"TVT23SPL");
    studentList.push_back(objectStudent0);
    Student objectStudent1("Liisa Joki",1998,"TVT23SPL");
    studentList.push_back(objectStudent1);
    Student objectStudent2("Aino Virta",1997,"TVT23SPO");
    studentList.push_back(objectStudent2);
    Student objectStudent3("Matti Virtanen",2001,"TVT23SPO");
    studentList.push_back(objectStudent3);
    Student objectStudent4("Mikko Vilkas",2001,"TVT23SPL");
    studentList.push_back(objectStudent4);

    for(int x=0; x<=4; x++){
        studentList[x].printStudentData();
    }
    return 0;
}

Esimerkissä 7 on käytetty smart_pointteria ja sen main.cpp on seuraava

#include "student.h"
#include "teacher.h"

#include <iostream>
#include <vector>
#include <memory>

using namespace std;

int main()
{
    unique_ptr<vector<Student>> studentList = make_unique<vector<Student>>();

    Student objectStudent0("Teppo Testi",1999,"TVT23SPL");
    studentList->push_back(objectStudent0);
    Student objectStudent1("Liisa Joki",1998,"TVT23SPL");
    studentList->push_back(objectStudent1);
    Student objectStudent2("Aino Virta",1997,"TVT23SPO");
    studentList->push_back(objectStudent2);
    Student objectStudent3("Matti Virtanen",2001,"TVT23SPO");
    studentList->push_back(objectStudent3);
    Student objectStudent4("Mikko Vilkas",2001,"TVT23SPL");
    studentList->push_back(objectStudent4);

    for(int x=0; x<=4; x++){
        // Hae opiskelijalista studentList-osoittimesta
        vector<Student>& students = *studentList;

        // Käytä opiskelijalistan elementtiä `x` ja kutsu printStudentData() -funktiota
        students[x].printStudentData();
    }

    return 0;
}

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim7

Olio-ohjelmoinnissa käsite interface tarkoittaa luokkaa, josta ei tehdä olioita. Siinä määritellään metodeja, muttei niiden toteutuksia. Siis määritetään metodien paluuarvojen tyypit ja parametrien tyypit. Kun jokin luokka perii tuon interface luokan on perivän luokan toteutettava interface luokan metodit, muuten seuraa virheilmoitus.

Javassa ja C#:ssa interface luokka toteutetaan lisäämällä sana interface luokan määrityksen eteen. C++:ssa ei tällaista sanaa ole vaan interface luokka voidaan toteuttaa tekemällä metodeista puhtaita virtuaalimetodeja. Interface luokan nimi alkaa usein kirjaimella I.

Tein esimerkin, jossa on interface luokka nimeltään IPerson ja Student ja Teacher perivät sen, sekä luokan Person. Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim8

Staattinen luokka tarkoittaa luokkaa, jonka metodeita voidaan kutsua luomatta oliota kyseisestä luokasta. C++ kielessä ei voida luoda varsinaista staattista luokkaa, mutta toiminnallisesti käsitettä vastaa luokka, jonka kaikki metodit ovat staattisia.

Esimerkiksi C#:ssa on luokka Math, josta löytyy esimerkiksi funktio sqrt. Ei ole järkevää, että voidaksesi käyttää tuon luokan metodeja sinun tulisi luoda luokasta olio. Voit laskea esimerkiksi luvun 4 neliöjuuren koodilla Math.Sqrt(4).

Tein esimerkin, jossa on luokka nimeltään MyStaticClass ja siellä määritettynä metodi doubleMe. Luokan h-tiedostossa metodi on määritetty näin:

static double doubleMe(double);

double MyStaticClass::doubleMe(double value)
{
    return 2*value;
}

myResult=MyStaticClass::doubleMe(myValue);

Voit kuitenkin luoda olioita luokasta MyStaticClass. Jos haluat estää olioiden luomisen, voit muokata luokan oletusmuodostimen h-tiedosssa seuraavaan muotoon:

MyStaticClass()=delete;

Esimerkki löytyy sivulta https://github.com/olio-kurssi/esim9

UML eli Unified Modeling Language on standardoitu tapa kuvata ohjelmisto- ja järjestelmäsuunnittelua visuaalisesti. Se tarjoaa erilaisia kaavioita ja työkaluja ohjelmistojen rakenteen, toiminnallisuuden ja käyttötapauksien mallintamiseen. UML auttaa suunnittelijoita kommunikoimaan, ymmärtämään ja dokumentoimaan ohjelmistojen arkkitehtuuria ja toiminnallisuutta.

Luokkakaavio on UML-standardin mukainen mallinnustyyppi, joka kuvaa järjestelmän staattisen rakenteen luokkien ja niiden välisten suhteiden avulla.

Luokka piirretään suorakaiteena, joka on jaettu kolmeen osaan; luokan nimi, luokan tiedot (jäsenmuuttujat) ja luokan toiminnallisuus (jäsenfunktiot).

Diagrammeissa käytetyt symbolit ovat:

• - : private
• + : public
• # : protected

Oppaaseen liittyvien esimerkkien lähdekoodit löytyy sivulta https://github.com/orgs/olio-kurssi/repositories.

repository	aihe
esim0	Tietue
esim1	Luokka ja olio (pino ja keko)
esim2	Muodostin ja tuhoaja
esim3	Periytyminen
esim4	Virtuaalimetodi
esim5	Abstraktiluokka
esim6	Koostaminen
esim7	Oliotaulukko
esim8	Interface luokka
esim9	Staattinen luokka