Tärkeimpiä olio-ohjelmoinnin periaatteita ovat kapselointi, tiedon kätkentä, periytyminen ja polymorfismi.

public osiossa määritelty getAge-metodi on age muuttujan Getter-metodi. Sen avulla saadaan haettua age muuttujan arvo. Ja setAge on age muuttujan Setter-metodi. Sen avulla muuttujan age arvo voidaan asettaa.

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> personList
// ... lisätään henkilöitä ...

for(const Person &p : personList) {
    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;
    }
};

Private tyyppisiin muuttujiin ja metodeihin päästään käsiksi vain luokan sisältä. Public tyyppisiin muuttujiin ja metodeihin päästään käsiksi myös luokasta luodun olion kautta. Protected tyyppisiin muuttujiin päästään käsiksi luokan ja perivän luokan sisältä. Usein noudatetaan seuraavia käytäntöjä:

1. jäsenmuuttujista tehdään private tyyppisiä
2. metodeista tehdään public tyyppisiä

Yleensä luokan muuttujien ja metodien määrittelyt tehdään h-tiedostossa. Kun luodaan Person-luokka, niin person.h tiedoston sisältö voisi olla seuraava

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

this on erityinen osoitin, joka viittaa olioon, jonka jäsenfunktiota parhaillaan suoritetaan. Se on implisiittinen parametri jokaisessa ei-staattisessa jäsenfunktiossa.

Milloin this on pakollinen?

1. Kun parametrin ja jäsenmuuttujan nimet ovat samat

   class Person {
       string name;
   public:
       void setName(string name) {
           this->name = name;  // Pakollinen! Ilman this->name viittaisi parametriin
       }
   };
   

2. Kun halutaan palauttaa viite olioon itseensä (method chaining)

   class Person {
       string name;
       int age;
   public:
       Person& setName(string n) {
           name = n;
           return *this;  // Pakollinen! Palautetaan olio itse
       }
       Person& setAge(int a) {
           age = a;
           return *this;
       }
   };
   
   // Käyttö: voidaan ketjuttaa metodikutsuja
   Person p;
   p.setName("Teppo").setAge(25);
   

3. Kun olio täytyy välittää parametrina toiselle funktiolle

   class Student {
       string name;
   public:
       void registerToSystem() {
           // Välitetään this-osoitin toiselle funktiolle
           systemDatabase.addStudent(this);
       }
   };
   

Milloin this on vapaaehtoinen?

Kun jäsenmuuttujien ja parametrien nimet ovat erilaiset, this-osoittimen käyttö on vapaaehtoista. Seuraavat ovat identtiset:

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

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

Hyvä käytäntö: Käytä aina erilaisia nimiä jäsenmuuttujille ja parametreille (esim. jäsenmuuttuja: age, parametri: value tai newAge), jolloin vältät this-osoittimen pakollisen käytön ja koodi on selkeämpi.

Olio on luokasta luotu ilmentymä eli instanssi. Voit verrata asiaa siihen, että int on muutujatyyppi ja voit luoda muuttujan lauseella int myVariable. Edellä olevassa esimerkissä on luotu luokka Person ja siitä voidaan luoda olio lauseella Person objectPerson.

Kun luot olioita sinun tulee ymmärtää, että sovelluksellasi on käytössä kahdenlaista muistia

• Stack eli pinomuisti
• Heap eli kekomuisti

Heap muistia allokoidaan dynaamisesti sovelluksen ajon aikana ja sinun on huolehdittava sen vapauttamisesta (jollet käytä smart pointteria).

Perinteisesti C++ ohjelmoinnissa olioita on voinut luoda kahdella tavalla eli joko

Person objectPerson1;

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

Person *objectPerson2 = new Person;

Ensin mainittu tapa luo ns. automaattisen olion Stack muistiin. Tässä tapauksessa käyttöjärjestelmä huolehtii olion muistinvarauksista ja vapauttamisista, olion luonnin ja tuhoamisen yhteydessä.

Jälkimmäinen tapa luo olion Heap muistiin ja sinun on huolehdittava sen tuhoamisesta, kun et enää tarvitse sitä.

Kun olet luonut olion, pääset sen avulla käsiksi Person luokan metodeihin. Niihin viitataan eri tavalla riippuen siitä teitkö olion Stack vai Heap muistiin. Esimerkiksi setAge metodia voidaan kutsua näin:

objectPerson1.setAge(23);

objectPerson2->setAge(23);

Sinun ei itse tarvitse tuhota oliota objectPerson1, mutta sinun on tuhottava olio objectPerson2, kun et sitä enää tarvitse. Se tapahtuu seuraavasti:

delete objectPerson2; //vapautetaan muisti
objectPerson2 = nullptr; //osoitin ei enää osoita vapautettuun muistiin

Undefined behavior voi johtaa ohjelman kaatumiseen, muistivirheisiin tai satunnaiseen toimintaan.

Käytä automaattista muistialuetta (pino), kun tiedät olion koon etukäteen ja se on suhteellisen pieni. Oliot automaattisella muistialueella tuhoutuvat automaattisesti, kun niiden käyttöalue (kuten funktio) päättyy. Tämä auttaa välttämään muistivuotoja. Automaattinen muistialue on nopeampi käyttää kuin keko, koska sen hallinta on yksinkertaisempaa.

Käytä dynaamista muistialuetta (keko), kun olion koko ei ole tiedossa etukäteen tai se on suuri. Olet vastuussa olion muistialueen vapauttamisesta käytön jälkeen delete-avainsanalla. Oliot dynaamisella muistialueella säilyvät olemassa, kunnes ne tuhotaan manuaalisesti

Moderni C++ mahdollistaa resurssien hallinnan älykkäiden osoittimien avulla, mikä helpottaa muistin vapauttamista ja vähentää mahdollisuutta virheisiin.

C++ sisältää kolmenlaisia smart osoittimia:

1. unique_ptr: Omistaa dynaamisesti allokoidun muistin ja huolehtii sen vapauttamisesta, kun osoitin poistuu käytöstä. Se ei ole kopioitavissa.
2. shared_ptr: Jaettu älyosoitin, joka sallii useiden osoittimien osoittaa samaan resurssiin. Se pitää kirjaa viitteiden määrästä ja vapauttaa muistin, kun kaikki osoittimet ovat vapautettu.
3. weak_ptr: Heikko osoitin, joka liittyy shared_ptr:iin, mutta ei vaikuta resurssin elinkaareen.

Smart pointer voidaan luoda koodilla:

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

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

    if (jokinEhto) {
        return;  // Funktiosta poistutaan ennen deleteä: olio jää vapauttamatta.
    }

    delete p;  // Olio vapautetaan vain, jos suoritus pääsee tähän.
}

void processData(bool jokinEhto) {
    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ä
}

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!

Kappaleessa Koostaminen selitetään mitä eroa unique- ja shared- pointtereilla on.

#include <memory>

{
    Student objStudent1;
    Student* objStudent2 = new Student;
    unique_ptr<Student> objStudent3 = make_unique<Student>(); // C++14 tai uudempi
    // 1. Kaikki kolme oliota ovat elossa.

    delete objStudent2;      // 2. Kohdeolio tuhoutuu, osoitin jää jäljelle.
    objStudent2 = nullptr;   // 3. Osoitin ei enää osoita vapautettuun muistiin.
                             // 4. objStudent3:n kohdeolio ja objStudent1 tuhoutuvat automaattisesti.
}

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
int y = 20;
// ref = y;      // VIRHE: viittausta ei voi vaihtaa osoittamaan toiseen muuttujaan

// 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::Person(int value)
    : age(value)
{
}

Suosi yleensä alustuslistaa jäsenmuuttujien alustamiseen. Esimerkiksi merkkijonojäsen alustetaan silloin suoraan halutulla arvolla. Jos arvo sijoitetaan vasta muodostimen rungossa, merkkijono muodostetaan ensin tyhjäksi ja sille sijoitetaan arvo sen jälkeen.

Alustuslista on välttämätön esimerkiksi const- ja viitejäsenten alustamiseen, kun niille ei ole annettu alkuarvoa luokan määrittelyssä. Sitä tarvitaan myös, kun kantaluokan tai jäsenolion muodostimelle pitää antaa argumentteja. Muodostimen runkoon voi kirjoittaa muut alustamiseen liittyvät toimenpiteet.

Huomaa järjestys: jäsenmuuttujat alustetaan aina siinä järjestyksessä, jossa ne on esitelty luokan määrittelyssä. Kirjoita myös alustuslista samaan järjestykseen.

Kummassakin vaihtoehdossa olioa luotaessa pitää antaa kokonaisluku eli olion voisi luoda näin:

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). Tämä tarkoittaa, että samalla nimellä voidaan määritellä useita funktioita, kunhan niiden parametrilistat eroavat toisistaan. Paluuarvo voi olla sama tai erilainen, mutta pelkkä erilainen paluuarvo ei riitä ylikuormittamiseen. Kääntäjä valitsee kutsuttavan funktion argumenttien tyyppien perusteella.

Esimerkki ylikuormittamisesta:

void doubleMe(int a)
{
    int doubled = 2 * a;
    cout << "Kokonaisluku " << a << " tuplattuna = " << doubled << endl;
}
void doubleMe(double a)
{
    double doubled = 2 * a;
    cout << "Desimaaliluku " << a << " tuplattuna = " << doubled << endl;
}

doubleMe(7);      // Tyyppi int: ensimmäinen versio
doubleMe(5.5);    // Tyyppi double: toinen versio

Funktiomalli mahdollistaa edellisen kaltaisen toteutuksen yhdellä funktiolla. Funktiomallissa tyypin paikalla käytetään tyyppiparametria T. Kääntäjä päättelee tyypin funktion kutsun perusteella ja muodostaa tarvittaessa funktiosta kyseiselle tyypille sopivan version.

Esimerkki funktiomallista:

template <typename T>
void doubleMe(T a)
{
    T doubled = 2 * a;
    cout << "Luku " << a << " tuplattuna = " << doubled << endl;
}

doubleMe(7);      // T päätellään tyypiksi int
doubleMe(5.5);    // T päätellään tyypiksi double

Milloin käytetään ylikuormittamista ja milloin funktiomallia?

Ylikuormittaminen sopii tilanteeseen, jossa eri tyyppiset argumentit vaativat erilaisen toteutuksen. Funktiomalli sopii tilanteeseen, jossa sama algoritmi toimii useilla tyypeillä. Edellä doubleMe-funktion toiminta on sama sekä kokonaisluvuille että desimaaliluvuille, joten funktiomalli vähentää toistuvaa koodia. Jos eri tyyppien käsittely vaatisi erilaisen algoritmin, funktioita voisi ylikuormittaa erikseen.

Periytyminen eli inheritance tarkoittaa, että luokka voi periä ominaisuuksia ja toimintoja toiselta luokalta. Ajatellaan esimerkiksi, että rakentaisimme sovellusta, jolla käsitellään jonkin oppilaitoksen dataa. Todetaan, että oppilaitoksessa on opiskelijoita ja opettajia. Molemmilla on monia samankaltaisia ominaisuuksia, kuten 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("TVT23SPL", "Teppo Testi");

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

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 i = 0; i < 5; ++i) {
        std::cout << luvut[i] << " ";
    }

    return 0;
}

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

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");

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

    return 0;
}

• studentList = unique_ptr-osoitin
• *studentList = itse vector
• student = vuorossa oleva Student-olio viitteenä

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

Huom! Yleensä vektori kannattaa luoda pinoon, koska se on helpompi tapa. Tuota smart pointteria kannattaa käyttää vain, jos vektori 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");

Assosiaatio tarkoittaa luokkien välistä yhteyttä, jossa toisen luokan oliot eivät omista toisen luokan olioita. Käytännössä tämä tarkoittaa että oliot ovat yhteydessä toisiinsa tilapäisesti, esimerkiksi metodin parametrina välitettynä viittauksena.

Esimerkki: Doctor-luokka ja Patient-luokka ovat assosiaatiossa. Käytännössä tämä tarkoittaa, että Doctor-olio voi käsitellä Patient-oliota metodissaan, mutta ei omista sitä. Molemmat oliot voivat olla olemassa itsenäisesti.

Näytä Doctor-Patient esimerkki

UML-diagrammi:

classDiagram
    direction TB
    class Doctor {
        -string name
        +Doctor(string name)
        +diagnose(Patient& patient) void
    }
    class Patient {
        -string name
        +Patient(string name)
        +getName() string
    }
    Doctor ..> Patient : uses

Assosiaation pääpiirteet:

• Oliot ovat yhteydessä toisiinsa, mutta eivät omista toisiaan
• Käytännössä yhteys toteutetaan tyypillisesti metodin parametrina
• Oliot voivat olla olemassa itsenäisesti toisistaan
• UML-diagrammissa merkitään katkoviivanuolella tai tavallisella viivalla

Käytännön ero koodissa:
Assosiaatiossa toisen luokan olio ei ole jäsenmuuttuja, vaan se välitetään metodille parametrina:

class Doctor {
private:
    string name;
    // EI Patient-jäsenmuuttujaa!
public:
    void diagnose(const Patient& patient) {  // Vain parametri
        // Käyttää Patient-oliota tilapäisesti
    }
};

Assosiaation erikoistapaukset:
Aggregaatiossa ja kompositiossa toisen luokan olio on jäsenmuuttuja:

• Aggregaatio (heikko kooste) = assosiaation erikoistapaus, jossa toinen luokka nähdään kokonaisuutena ja toinen sen osana. Osaluokan olio on jäsenmuuttuja, mutta osat voivat olla olemassa myös itsenäisesti
• Kompositio (vahva kooste) = vahvempi erikoistapaus aggregaatiosta. Osaluokan olio on jäsenmuuttuja ja osien elinkaari on sidottu kokonaisuuteen (kun kokonaisuus tuhoutuu, sen osatkin tuhoutuvat)

Koostaminen (composition) tarkoittaa "osa–kokonaisuus"-suhdetta luokkien välillä. Koostaminen voi olla joko heikkoa (aggregaatio) tai vahvaa (kompositio). Erona on, että aggregaatiossa osat voivat olla olemassa myös ilman kokonaisuutta, mutta kompositiossa eivät.

classDiagram
    direction TB
    class Team {
        -string name
        -vector~shared_ptr~Player~~ players
        +Team(string name)
        +addPlayer(shared_ptr~Player~ player) void
        +printPlayers() void
    }
    class Player {
        -string name
        +Player(string name)
        +getName() string
    }
    Team o-- Player : has
    note for Team "shared_ptr = jaettu omistajuus<br/>Player voi olla olemassa<br/>ilman Team-oliota"

class Team {
private:
    vector<shared_ptr<Player>> players;  // Jäsenmuuttuja!
public:
    void addPlayer(shared_ptr<Player> player) {
        players.push_back(player);  // Tallennetaan luokkaan
    }
};

classDiagram
    direction TB
    class Car {
        -string model
        -unique_ptr~Engine~ objEngine
        +Car(string model)
        +printInfo() void
    }
    class Engine {
        -string type
        +Engine(string type)
        +getType() string
    }
    Car *-- Engine : owns
    note for Car "unique_ptr = yksinomainen omistajuus<br/>Engine-olio tuhoutuu<br/>Car-olion mukana"

class Car {
private:
    unique_ptr<Engine> objEngine;  // Jäsenmuuttuja!
public:
    Car(const string& model) {
        objEngine = make_unique<Engine>("V8");  // Luodaan konstruktorissa
    }
    // ~Car() tuhoaa automaattisesti myös objEngine:n
};

Abstrakti luokka on luokka, josta ei voi luoda oliota, mutta jota voidaan käyttää kantaluokkana. C++:ssa luokka saadaan abstraktiksi lisäämällä siihen vähintään yksi puhdas virtuaalimetodi (pure virtual method). Esimerkiksi Person-luokan sayStatus()-metodin esittely muutetaan muotoon:

virtual void sayStatus() = 0;

Tässä metodille ei kirjoiteta toteutusta person.cpp-tiedostoon. Person-luokassa voi silti olla jäsenmuuttujia, muodostimia ja muita metodeja valmiine toteutuksineen. Perivän luokan pitää toteuttaa sayStatus(), jotta siitä voidaan luoda olio. Muuten myös perivä luokka jää abstraktiksi.

Abstraktius ei itsessään vaadi virtuaalista tuhoajaa. Kantaluokan tuhoajan pitää kuitenkin olla virtuaalinen, kun perivän luokan olio tuhotaan kantaluokan osoittimen kautta. Esimerkiksi:

Person* person = new Student();
delete person;

Tämä edellyttää, että Student voidaan muodostaa ilman argumentteja ja Person-luokan julkisessa osiossa on virtuaalinen tuhoaja:

virtual ~Person() = default;

Näin myös Student-luokan tuhoaja suoritetaan oikein. Ilman virtuaalista tuhoajaa edellä olevan delete-lauseen toiminta on määrittelemätöntä. Sama vaatimus koskee std::unique_ptr<Person>-älyosoitinta, joka omistaa Student-olion. Merkintä = default pyytää kääntäjää tuottamaan tuhoajan toteutuksen.

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

Rajapinta (interface) määrittelee, mitä metodeja sen toteuttavan luokan pitää tarjota. C++:ssa rajapintakin on abstrakti luokka. Erillistä interface-avainsanaa tai muuta merkintää, joka muuttaisi abstraktin luokan rajapinnaksi, ei ole.

Kun luokka suunnitellaan puhtaaksi rajapinnaksi, sen toimintametodit esitellään public-osiossa puhtaina virtuaalimetodeina (virtual ... = 0). Siihen ei lisätä jäsenmuuttujia tai toimintametodien toteutuksia. Näin luokka määrittelee vain vaaditun toiminnan. Esimerkiksi:

class IPerson {
public:
    virtual ~IPerson() = default;
    virtual void sayStatus() = 0;
};

Virtuaalinen tuhoaja mahdollistaa olion tuhoamisen IPerson-osoittimen kautta; = default pyytää kääntäjää tuottamaan tuhoajan toteutuksen. Tuhoaja ei tee luokasta rajapintaa. Myös nimen alun I on vain nimeämiskäytäntö.

Rajapinta toteutetaan julkisella periytymisellä ja toteuttamalla sen puhtaat virtuaalimetodit. Luokan h-tiedostossa esimerkiksi:

class Student : public IPerson {
public:
    void sayStatus() override;
};

Metodin toteutus kirjoitetaan student.cpp-tiedostoon. Rajapinnan perivän luokan on toteutettava kaikki rajapinnan puhtaat virtuaalimetodit, jotta luokasta voidaan luoda olio. Muuten myös perivä luokka jää abstraktiksi.

Ero käytännössä: abstrakti kantaluokka voi jakaa periville luokille yhteistä tietoa ja valmista toimintaa. Puhdas rajapinta määrittelee vain toimintametodien vaatimukset. Tämä on C++:ssa suunnittelukäytäntö, ei kääntäjän valvoma erillinen luokkatyyppi.

Esimerkki, jossa Student ja Teacher perivät sekä IPerson-rajapinnan että Person-luokan, 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.

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

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