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?
Paitsi, että luokan sisään voidaan sijoittaa useita muuttujia eli jäsenmuuttujia, voidaan luokan sisään sijoittaa myös metodeja eli jäsenfunktioita. Niiden avulla voit esimerkiksi antaa edellä mainutuille jäsenmuuttujille 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.

C++-sovellusten luominen on helpompaa, jos käytetään siihen tarkoitettua ohjelmointiympäristöä, kuten Qt Creatoria.

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.

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.

class Person {
    int age;
public:
    int getAge() const {
        return age;  // OK: vain lukeminen
    }

    void badGetter() const {
        age = 25;  // VIRHE: const-metodi ei voi muuttaa jäsenmuuttujia!
    }
};

void printPersonInfo(const Person &p) {
    cout << p.getAge();    // OK: getAge() on const-metodi
    // p.setAge(30);       // VIRHE: setAge() ei ole const, ei voi kutsua!
}

vector<Person> people;
// ... lisätään henkilöitä ...

for(const Person &p : people) {
    cout << p.getAge();    // OK: getAge() on const
    // p.setAge(30);       // VIRHE: setAge() ei ole const
}

class Student {
private:
    string name;
    int age;
public:
    // Getterit ovat const - eivät muuta olion tilaa
    string getName() const { return name; }
    int getAge() const { return age; }

    // Setterit eivät ole const - muuttavat olion tilaa
    void setName(string n) { name = n; }
    void setAge(int a) { age = a; }

    // Tulostusmetodi on const - ei muuta olion tilaa
    void printInfo() const {
        cout << name << ", " << age << " vuotta" << endl;
    }
};

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;
}

void setAge(int value) {
    age = value;           // Toimii ilman this
}

void setAge(int value) {
    this->age = value;     // Toimii myös this:llä (selkeämpi)
}

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; //vapautetaan muisti
objectPerson2 = nullptr; //osoitin ei enää osoita vapautettuun muistiin

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

void processData() {
    Person* p = new Person();
    p->setAge(25);

    // Jos tässä tapahtuu virhe tai unohdetaan delete,
    // muisti jää varattuna = MUISTIVUOTO!

    if (jokinEhto) {
        return;  // VIRHE: delete puuttuu, muisti vuotaa!
    }

    delete p;  // Tähän ei koskaan päästä, jos jokinEhto == true
    p = nullptr;
}

void processData() {
    unique_ptr<Person> p = make_unique<Person>();
    p->setAge(25);

    if (jokinEhto) {
        return;  // OK: unique_ptr vapauttaa muistin automaattisesti!
    }

    // unique_ptr vapauttaa muistin myös normaalin paluun yhteydessä
}
// Muisti vapautetaan AINA kun funktio päättyy

// HUONO: Perinteinen osoitin
void riskyFunction() {
    Person* p = new Person();

    // Jos seuraava rivi heittää poikkeuksen,
    // delete-riviä ei koskaan suoriteta = MUISTIVUOTO!
    someRiskyOperation();

    delete p;
    p = nullptr;
}

// HYVÄ: unique_ptr
void riskyFunction() {
    unique_ptr<Person> p = make_unique<Person>();

    // Vaikka poikkeus heitetään,
    // unique_ptr vapauttaa muistin automaattisesti!
    someRiskyOperation();

    // Ei tarvitse delete:ä
}

unique_ptr<Person> p = make_unique<Person>();

// Metodien kutsu nuolioperaattorilla (kuten tavallinen osoitin)
p->setAge(30);
p->setName("Teppo");

// Ei tarvitse delete:ä - unique_ptr hoitaa kaiken!

int age = 25;
int &ageRef = age;  // ageRef on viittaus age-muuttujaan

ageRef = 30;        // Muuttaa age-muuttujan arvon 30:ksi
cout << age;        // Tulostaa: 30

int x = 10;

// Viittaus
int &ref = x;
ref = 20;          // Muuttaa x:n arvon 20:ksi
cout << x;         // 20

// Osoitin
int *ptr = &x;
*ptr = 30;         // Muuttaa x:n arvon 30:ksi (vaatii *)
cout << x;         // 30

ptr = nullptr;     // OK: osoitin voi olla nullptr
// ref = ???;      // VIRHE: viittaus ei voi osoittaa toiseen

// Kopioi arvon (hidas isoilla olioilla)
void setAge1(Person p) {
    p.setAge(25);  // Muuttaa vain KOPION ikää, ei alkuperäistä!
}

// Viittaus (nopea, muuttaa alkuperäistä)
void setAge2(Person &p) {
    p.setAge(25);  // Muuttaa alkuperäisen olion ikää
}

// Const-viittaus (nopea, ei voi muuttaa - PARAS tapa lukemiseen)
void printPerson(const Person &p) {
    cout << p.getName();  // Vain lukeminen, ei kopiointia
    // p.setAge(30);      // VIRHE: const-viittaus
}

for(const Student &student : studentList) {
    student.printStudentData();  // Ei kopiointia, nopea
}

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(46);

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.

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

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

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

person.h
virtual void sayStatus();

student.h 
virtual void sayStatus() override; 

teacher.h 
virtual void sayStatus() override; 

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

Assosiaatio tarkoittaa luokkien välistä yhteyttä. Aggregaatio ja kompositio ovat assosiaation erikoistapauksia, joissa yhteys tulkitaan "osa–kokonaisuus"-suhteeksi. Erona on, että aggregaatiossa osat voivat olla olemassa myös ilman kokonaisuutta, mutta kompositiossa eivät.

• Assosiaatio = yleisnimitys kahden (tai useamman) luokan väliselle yhteydelle
• Aggregaatio = assosiaation erikoistapaus, jossa toinen luokka nähdään kokonaisuutena ja toinen sen osana, mutta osat voivat olla olemassa myös itsenäisesti
• Kompositio = vielä vahvempi erikoistapaus aggregaatiosta: osien elinkaari on sidottu kokonaisuuteen (kun kokonaisuus tuhoutuu, sen osatkin tuhoutuvat)

• Aggregaatiosta käytetään myös nimitystä heikko kooste
• Kompositiosta käytetään myös nimitystä vahva kooste

Assosiaatio tarkoittaa tilannetta, joissa kaksi oliota ovat yhteydessä toisiinsa, mutta kummallakaan ei ole omistajuutta toiseen.

Esimerkki 1: assosiaatio
Sovelluksessa on luokka Doctor ja Patient ja Doctor-oliolle voidaan antaa argumenttina Patient-olio seuraavasti:

class Patient {
private:
    string name;
public:
    Patient(const string& name) : name(name) {}

    string getName() const {
        return name;
    }
};

class Doctor {
private:
    string name;
public:
    Doctor(const string& name) : name(name) {}

    // Assosiaatio: Doctor käyttää Patient-oliota metodissa, mutta ei omista sitä
    void diagnose(const Patient& patient) const {
        cout << "Doctor " << name
                  << " diagnoses patient " << patient.getName() << endl;
    }
};

int main() {
    Doctor objectDoctor("Smith");
    Patient objectPatient("Alice");

    objectDoctor.diagnose(objectPatient);  // Assosiaatio: vain tilapäinen yhteys
}

class Player {
private:
    string name;
public:
    Player(const string& name) : name(name) {
        cout << "Player " << name << " luotiin" << endl;
    }

    ~Player() {
        cout << "Player " << name << " tuhottiin" << endl;
    }

    string getName() const {
        return name;
    }
};

class Team {
private:
    string name;
    vector<shared_ptr<Player>> players;  // Aggregaatio: jaettu omistajuus
public:
    Team(const string& name) : name(name) {
        cout << "Team " << name << " luotiin" << endl;
    }

    ~Team() {
        cout << "Team " << name << " tuhottiin" << endl;
        // shared_ptr:t hoitavat muistinhallinnan automaattisesti
    }

    void addPlayer(shared_ptr<Player> player) {
        players.push_back(player);
    }

    void printPlayers() const {
        cout << "Team " << name << " pelaajat:" << endl;
        for (const auto& p : players) {
            cout << "- " << p->getName() << endl;
        }
    }
};

int main() {
    // Luodaan pelaajat shared_ptr:llä
    auto player1 = make_shared<Player>("Alice");
    auto player2 = make_shared<Player>("Bob");
    auto player3 = make_shared<Player>("Charlie");

    {  // Sisempi scope tiimeille
        Team team1("Red Tigers");
        Team team2("Blue Sharks");

        // Alice ja Bob kuuluvat molempiin tiimeihin (jaettu omistajuus!)
        team1.addPlayer(player1);
        team1.addPlayer(player2);

        team2.addPlayer(player1);  // Alice pelaa myös toisessa tiimissä
        team2.addPlayer(player3);

        cout << "\n";
        team1.printPlayers();
        cout << "\n";
        team2.printPlayers();
        cout << "\n";
    }  // Molemmat tiimit tuhoutuvat, mutta pelaajat jatkavat!

    cout << "\nPelaajat ovat viela olemassa:" << endl;
    cout << player1->getName() << ", " << player2->getName()
         << " ja " << player3->getName() << endl;

    return 0;
    // Vasta nyt pelaajat tuhoutuvat automaattisesti
}

• Sisältävä olio (Team) jakaa omistajuuden sisältämiensä olioiden kanssa (Player)
• Sama olio voi kuulua useampaan kokonaisuuteen (Alice kuuluu kahteen tiimiin)
• Käytetään shared_ptr:ää jaetun omistajuuden ilmaisemiseen
• Sisältämät oliot tuhoutuvat vasta kun kaikki viittaukset poistetaan
• UML-diagrammissa merkitään valkoisella vinoneliöllä

Esimerkki 3: kompositio
Sovelluksessa on luokka Car ja Engine ja Car-olio luo ja tuhoaa Engine olion seuraavasti:

class Engine {
private:
    string type;
public:
    Engine(const string& type = "V6") : type(type) {
        cout << "Engine " << type << " luotiin" << endl;
    }

    ~Engine() {
        cout << "Engine " << type << " tuhottiin" << endl;
    }

    string getType() const {
        return type;
    }
};

class Car {
private:
    unique_ptr<Engine> objEngine;  // Kompositio: Car omistaa Enginen
    string model;
public:
    Car(const string& model) : model(model) {
        objEngine = make_unique<Engine>("V8");
        cout << "Car " << model << " luotiin" << endl;
    }

    ~Car() {
        cout << "Car " << model << " tuhottiin" << endl;
        // unique_ptr deletoi automaattisesti Engine-olion!
    }

    void printInfo() const {
        cout << "Auto: " << model << ", Moottori: " << objEngine->getType() << endl;
    }
};

int main() {
    Car objCar("Tesla Model S");  // Luo Carin, joka luo oman Enginen
    objCar.printInfo();

    return 0;
    // Car tuhoutuu ja tuhoaa samalla myös Enginen
}

• Sisältävä olio (Car) omistaa sisältämänsä olion (Engine)
• Sisältämä olio luodaan sisältävän olion konstruktorissa
• Sisältämä olio tuhoutuu automaattisesti kun sisältävä olio tuhoutuu
• Käytetään unique_ptr:ää omistajuuden ilmaisemiseen
• UML-diagrammissa merkitään mustalla vinoneliöllä

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.

Esimerkki 1: Perinteinen taulukko

#include <iostream>

int main() {
    int luvut[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; ++i) {
        std::cout << luvut[i] << " ";
    }

    return 0;
}
  

Esimerkki 2: std::vector

#include <iostream>
#include <vector>

int main() {
    std::vector<int> luvut = {1, 2, 3, 4, 5};

    for (int luku : luvut) {
        std::cout << luku << " ";
    }

    return 0;
}
  

Huomioita

• std::vector on turvallisempi ja joustavampi kuin perinteinen taulukko.
• Vektorin kokoa ei tarvitse määrittää etukäteen.
• Vektori tarjoaa monia hyödyllisiä metodeja, kuten push_back(), size(), ja at().

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 <iostream>
#include <vector>

using namespace std;

int main()
{
    vector<Student> studentList;
    // Luodaan olioita listaan
    studentList.emplace_back("Teppo Testi", 1999, "TVT23SPL");
    studentList.emplace_back("Liisa Joki", 1998, "TVT23SPL");
    studentList.emplace_back("Aino Virta", 1997, "TVT23SPO");
    studentList.emplace_back("Matti Virtanen", 2001, "TVT23SPO");
    studentList.emplace_back("Mikko Vilkas", 2001, "TVT23SPL");



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

Edellä for silmukka voitaisiin korvata myös seuraavalla rakenteella, jossa ei tarvitse tietää montako alkiota vektorissa on.

for(Student student: studentList){
    student.printStudentData();
}

for(Student student: studentList){
    student.setAge(25);  // Muuttaa vain KOPION ikää, ei alkuperäistä!
}

for(Student &student: studentList){
    student.setAge(25);  // Muuttaa alkuperäisen opiskelijan ikää!
}

for(const Student &student: studentList){
    student.printStudentData();  // Vain lukeminen, ei kopiointia
    // student.setAge(25);  // VIRHE: ei voi muuttaa const-viittausta
}

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

#include "student.h"

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

using namespace std;

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

    studentList->emplace_back("Teppo Testi", 1999, "TVT23SPL");
    studentList->emplace_back("Liisa Joki", 1998, "TVT23SPL");
    studentList->emplace_back("Aino Virta", 1997, "TVT23SPO");
    studentList->emplace_back("Matti Virtanen", 2001, "TVT23SPO");
    studentList->emplace_back("Mikko Vilkas", 2001, "TVT23SPL");

    // Hae opiskelijalista studentList-osoittimesta
    vector<Student>& students = *studentList;

    for(int x=0; x<=4; x++){
        // Käytä opiskelijalistan elementtiä `x` ja kutsu printStudentData() -funktiota
        students[x].printStudentData();
    }

    return 0;
}

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

Edellä for silmukka voitaisiin korvata myös seuraavalla rakenteella, jossa ei tarvitse tietää montako alkiota vektorissa on.

for (Student &student : students) {
    student.printStudentData();
}

Huom! Yleensä vektori kannattaa luoda pinoon, koska se on helpompi tapa. Tuota smart pointteria kannattaa käyttää vain, jos se on todella suuri.

emplace_back vs push_back: Esimerkeissä on käytetty emplace_back-metodia olioiden lisäämiseen vektoriin. Metodi emplace_back konstruoi olion suoraan vektoriin ottamalla vastaan konstruktorin parametrit, mikä on tehokkaampi tapa kuin push_back. Metodi push_back ottaa vastaan valmiin olion ja kopioi tai siirtää sen vektoriin, mikä voi vaatia ylimääräisiä kopio- tai siirto-operaatioita.

Esimerkki push_back-metodin käytöstä:

// Luodaan ensin Student-olio
Student student("Teppo Testi", 1999, "TVT23SPL");
// Lisätään olio vektoriin push_back-metodilla
studentList.push_back(student);

// Tai voidaan luoda olio suoraan push_back-kutsun yhteydessä
studentList.push_back(Student("Liisa Joki", 1998, "TVT23SPL"));

Vertailun vuoksi sama emplace_back-metodilla:

// emplace_back konstruoi olion suoraan vektoriin
studentList.emplace_back("Teppo Testi", 1999, "TVT23SPL");

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

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.

Olio-ohjelmoinnissa käsite interface luokka 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 <cmath> kirjastossa funktio sqrt. Ei ole järkevää, että voidaksesi laskea neliöjuuren sinun tulisi luoda olio. Voit laskea esimerkiksi luvun 4 neliöjuuren koodilla std::sqrt(4.0).

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 suojaustasoa kuvaavat symbolit ovat:

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

Esimerkiksi jäsenmuuttuja osiossa voisi olla rivi:
-age:int
joka tarkoittaa, että luokka sisältää int tyyppisen muuttujan nimeltään age, jonka suojaustaso on private

Ja jäsenfunktio osiossa voisi olla rivi:
+getInfo(int):float
joka tarkoittaa, että public metodi getInfo ottaa vastaan argumenttina int tyyppisen arvon ja palauttaa float tyyppisen arvon

Kontruktoria ei välttämättä merkitä diagrammiin.

auto on C++11:ssä esitelty avainsana, joka mahdollistaa tyyppi-inferenssin eli kääntäjä päättelee muuttujan tyypin automaattisesti annetun arvon perusteella.

Perusesimerkki:

// Perinteinen tapa - eksplisiittinen tyyppi
int age = 25;
string name = "Teppo";
double price = 19.99;

// Auto - kääntäjä päättelee tyypin
auto age = 25;        // Tyyppi: int
auto name = "Teppo";  // Tyyppi: const char* (HUOM!)
auto price = 19.99;   // Tyyppi: double

Hyödylliset käyttötapaukset:

1. Smart pointerit - koodi selkeämpää

// Ilman autoa - pitkä ja toistuva
unique_ptr<Person> p1 = make_unique<Person>();
shared_ptr<Student> s1 = make_shared<Student>();

// Autolla - lyhyempi ja selkeämpi
auto p1 = make_unique<Person>();
auto s1 = make_shared<Student>();

2. For-silmukat - erityisen hyödyllinen

vector<Student> studentList;

// Ilman autoa
for(const Student &student : studentList) {
    student.printStudentData();
}

// Autolla - yhtä selkeä, vähemmän kirjoitusta
for(const auto &student : studentList) {
    student.printStudentData();
}

3. Monimutkaiset tyypit

// Ilman autoa - vaikealukuista
// begin() palauttaa iteraattorin (osoittimen kaltainen objekti) vektorin alkuun
vector<unique_ptr<Student>>::iterator it = studentList.begin();

// Autolla - paljon selkeämpi, kääntäjä päättelee tyypin
auto it = studentList.begin();

Milloin VÄLTTÄÄ auto:a:

Hyvät käytännöt:

• Käytä auto:a kun tyyppi on ilmeinen oikean puolen perusteella (esim. make_unique, make_shared)
• Käytä auto:a for-silmukoissa, erityisesti const-viittausten kanssa: for(const auto &item : list)
• Käytä auto:a kun tyyppi on pitkä ja monimutkainen (esim. iteraattorit)
• Käytä eksplisiittisiä tyyppejä kun haluat dokumentoida koodia selkeästi
• Oppimisen alkuvaiheessa käytä eksplisiittisiä tyyppejä ymmärryksen parantamiseksi

Auto ja viittaukset:

Person p;

auto p1 = p;       // Kopioi p:n -> p1 on tyyppiä Person
auto &p2 = p;      // Viittaus p:hen -> p2 on tyyppiä Person&
const auto &p3 = p; // Const-viittaus -> p3 on tyyppiä const Person&

p1.setAge(25);  // Muuttaa vain p1:n ikää
p2.setAge(30);  // Muuttaa p:n ikää (viittaus!)
// p3.setAge(35); // VIRHE: const-viittaus

Yhteenveto:

• auto on hyödyllinen työkalu, joka tekee koodista lyhyempää ja helpommin ylläpidettävää
• Erityisen hyödyllinen smart pointereiden, for-silmukoiden ja monimutkaisten tyyppien kanssa
• Oppimisen alkuvaiheessa käytä eksplisiittisiä tyyppejä ymmärtääksesi paremmin mitä tapahtuu
• Kun ymmärrät tyypit ja niiden toiminnan, voit alkaa käyttää auto:a järkevästi
• Älä käytä auto:a vain siksi että se on lyhyempi - käytä sitä kun se tekee koodista selkeämpää

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

repository	aihe
esim0	Tietue
esim1	Luokka ja olio (pino ja keko)
esim2	Muodostin ja tuhoaja
esim3	Periytyminen
esim4	Virtuaalimetodi
esim5	Abstraktiluokka
esim6	Vahva kooste
esim6b	Heikko kooste
esim7	Oliotaulukko
esim8	Interface luokka
esim9	Staattinen luokka
unit_test	Yksikkötestaus