Esimerkit

Harjoitus 1:

Aiheet: Luokka, olion luonti sekä jäsenmuuttujien ja metodien käsittely.

Elain.h:
class CElain
{
private: // privaatti, vain luokan sisällä voidaan muuttaa
char m_Nimi[100]; // Eläimen nimi
float m_Massa; // Eläimen massa, paino

void TulostaNimi(); // Tulostaa ruudulle eläimen nimen
void TulostaMassa(); // Tulostaa ruudulle eläimen massan

public: // julkinen, kaikki voi kutsua
   CElain(char Nimi[], float Massa); // Muodostin, parametreina Nimi ja Massa
   bool AsetaNimi(char Nimi[]); // Asettaa eläimen nimen
   bool AsetaMassa(float Massa); // Asettaa eläimen massan
    void Tulosta();
};

Elain.cpp:
#include "stdafx.h" // Ei tarvita, jos tekee Empty Project:in
#include "Elain.h" // CElain-luokan headeri

CElain::CElain(char Nimi[], float Massa)
{
strcpy(m_Nimi, Nimi); // Kopioidaan nimi luokkaan
m_Massa = Massa;
}

bool CElain::AsetaNimi(char Nimi[])
{
strcpy(m_Nimi, Nimi); // Kopioidaan nimi luokkaan
return true;
}

void CElain::TulostaNimi()
{
printf("Eläimen nimi on %s\n", m_Nimi);
}

bool CElain::AsetaMassa(float Massa)
{
m_Massa = Massa;
return true;
}

void CElain::TulostaMassa()
{
printf("Eläimen massa on %.2f kiloa\n", m_Massa);
}

void CElain::Tulosta()
{
TulostaNimi();
TulostaMassa();
}
main.cpp:
#include "stdafx.h"
#include "Elain.h"

int main(int argc, char* argv[])
{
CElain kissa("miuku", 2.4); // Luodaan olio CElain luokasta ja annetaan nimi ja massa parametreina

kissa.Tulosta();

return 0;
}

Harjoitus 2:

Aiheet: Periytyminen.

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

class CElain
{
private: // privaatti, vain luokan sisällä voidaan muuttaa
char m_Nimi[100]; // Eläimen nimi
float m_Massa; // Eläimen massa, paino

void TulostaNimi(); // Tulostaa ruudulle eläimen nimen
void TulostaMassa(); // Tulostaa ruudulle eläimen massan

public: // julkinen, kaikki voi kutsua
    bool AsetaNimi(char Nimi[]); // Asettaa eläimen nimen
    bool AsetaMassa(float Massa); // Asettaa eläimen massan
    void Tulosta();
};
Elain.cpp:#include "Elain.h" // CElain-luokan headeri

bool CElain::AsetaNimi(char Nimi[])
{
strcpy(m_Nimi, Nimi); // Kopioidaan nimi luokkaan
return true;
}

void CElain::TulostaNimi()
{
printf("Eläimen nimi on %s\n", m_Nimi);
}

bool CElain::AsetaMassa(float Massa)
{
m_Massa = Massa;
return true;
}

void CElain::TulostaMassa()
{
printf("Eläimen massa on %.2f kiloa\n", m_Massa);
}

void CElain::Tulosta()
{
TulostaNimi();
TulostaMassa();
}
Kissa.h:#include "Elain.h"

class CKissa :
    public CElain
{
public:
    CKissa(void);
    ~CKissa(void);
    void Kehraa();
};
Kissa.cpp:#include "Kissa.h"

CKissa::CKissa(void)
{
}

CKissa::~CKissa(void)
{
}

void CKissa::Kehraa()
{
printf("Kehraa...");
}
main.cpp:#include <stdio.h>
#include <conio.h>
#include "Kissa.h"

int main()
{
CKissa kissa;

    kissa.AsetaNimi("Miuku");
    kissa.AsetaMassa(1.2);
    kissa.Tulosta();
    kissa.Kehraa();

getch();

return 0;
}
Harjoitus 3:

Aiheet: Tulostaminen cout ja käyttäjän syötteen lukeminen cin -olioilla.

main.cpp:#include <iostream>
#include <string>

using namespace std;

int main()
{
    int Luku1, Luku2;
    char Operaattori;
    char Nimi[100];

cout << "Anna nimesi: ";
cin >> Nimi;

cout << "Anna 1. luku: ";
cin >> Luku1;

cout << "Anna 2. luku: ";
cin >> Luku2;

cout << "Anna operaattori: + - * / ";
cin >> Operaattori;

cout << "Hei " << Nimi << ", annoit laskutoimituksen: " << Luku1 << " " << Operaattori << " " << Luku2 << endl;

return 0;
}
Harjoitus 4:

Aiheet: Const-määritteet.

main.cpp:

#include "Luokka.h"

int main()
{
const CLuokka luokka;
luokka.YmpyranKeha(1.2467);

    CLuokka luokka2;
    luokka2.YmpyranKeha(283947);
    luokka2.TeeJotain();
}
Luokka.h:

class CLuokka
{
private:
const float m_Pii; // const tarkoittaa vakiota. Arvo ei voi muuttua ohjelman ajon aikana
int m_Luku;

public:
    CLuokka();
    float YmpyranKeha(const float r) const; // Parametri on const, arvo ei voi muuttua funktion sisällä
    void TeeJotain();
};
Luokka.cpp:

#include "Luokka.h"

CLuokka::CLuokka() :
m_Pii(3.14)
{
m_Luku = 0;
}

float CLuokka::YmpyranKeha(const float r) const
{
return 2*m_Pii*r;
}

void CLuokka::TeeJotain()
{
m_Luku = 2;
}

Harjoitus 5:

Aiheet: Funktioiden ylikuormitus.

main.cpp:

#include <cstdio>
#include <cstring>

class CElain
{
private: // saatavissa vain luokan metodeilla
char m_Nimi[100];
float m_Massa;

public: // voidaan käyttää luokan ulkopuolelta
    bool AsetaTiedot(char Nimi[], float Massa); // 'Alkuperäinen metodi'
    bool AsetaTiedot(char Nimi[]); // 1. Ylikirjoitettu metodi
    bool AsetaTiedot(float Massa); // 2. ylikirjoitettu metodi
};

bool CElain::AsetaTiedot(char Nimi[], float Massa)
{
    printf("AsetaTiedot(char[], float)\n");
    AsetaTiedot(Nimi);
    AsetaTiedot(Massa);
    return true;
}

bool CElain::AsetaTiedot(char Nimi[])
{
    printf("AsetaTiedot(char[])\n");
    strcpy(m_Nimi, Nimi);
    return true;
}

bool CElain::AsetaTiedot(float Massa)
{
    printf("AsetaTiedot(float)\n");
    m_Massa = Massa;
    return true;
}

int main()
{
CElain kissa;

    kissa.AsetaTiedot("Miuku", 2.4); // kutsuu metodia AsetaTiedot(char Nimi[], float Massa)
    kissa.AsetaTiedot("Mauku");      // kutsuu metodia AsetaTiedot(char Nimi[])
    kissa.AsetaTiedot(2.4);          // kutsuu metodia AsetaTiedot(float Massa)
}

Harjoitus 6, 7, 8:

Aihe: osoittimet .
float-tyyppisen muuttujan tulostaminen osoittimen avulla.#include <iostream>

using namespace std;

int main()
{
    float a = 3.1475;
    float b = 0.001;
    float* p;

p = &a;
cout << "*p = " << (*p) << endl;

p = &b;
cout << "*p = " << (*p) << endl;
}
Merkkijonon tulostaminen osoittimien avulla.
1. tapa on 'normaali' merkkijonon tulostaminen.
2. tapa tulostaa merkin kerrallaan hakasulkujen avulla.
3. tapa tulostaa merkkijonon osoitinta kasvattamalla.
#include <iostream>

using namespace std;

int main()
{
char mjono[]="Tämä on merkkijono";

// 1. tapa tulostaa merkkijono
cout << "mjono = " << mjono << endl;

    // 2. tapa tulostaa merkkijono
    cout << "mjono = ";
    for (int i=0; i<strlen(mjono); i++)
{         cout << mjono[i];     }
    cout << endl;
    // 3. tapa tulostaa merkkijono
    cout << "mjono = ";
    for (char* p = mjono; p < mjono+strlen(mjono); p++)
{         cout << (*p);     }
    cout << endl;
}
Osoitin funktion parametrina.
f():ssä tehdyt muutokset eivät näy main():iin.
f2():ssa tehdyt taas näkyvät.
#include <iostream>
using namespace std;

void f(int a)
{
a = -7;
}

void f2(int* p)
{
*p = -7;
}

int main()
{
int muut = 5;

f(muut);
cout << "muut = " << muut << endl;

f2(&muut);
cout << "muut = " << muut << endl;
}
Kertaustehtävä 1

-Tehkää luokka, jossa on pari muuttujaa, asetus- ja tulostusfunktiot.
-Luokaa luokasta olio main():ssa, sekä vakio-osoitin, jonka pistätte osoittamaan luotuun olioon.
-Kutsukaa luokan funktioita osoittimen kautta.

Kertaustehtävä 2

-Luokaa luokka, jossa on vakio jäsenmuuttuja.
-Alustakaa jäsenmuuttuja muodostimen initialisointilistassa, mutta tuokaa alustettava arvo muodostimen parametrina.
-Varmistakaa että annettu arvo tosiaan välittyy vakiomuuttujalle.

Kertaustehtävä 3

-Luokaa luokka, joka koostuu toisesta luokasta.
-Tehkää molempiin luokkiin parametrillinen muodostin.
-Viekää main():sta arvo koostavalle luokalle, joka puolestaan välitetään koostettavalle luokalle.
-Huom. koostettavan luokan muodostinta pitää kutsua koostavan luokan initialisointilistassa!

Kertaustehtävä 4

-Luokaa kaksi luokkaa joista toinen perii toisen.
-Luokaa vanhempaan vakio aito virtuaalifunktio.
-Toteuttakaa perillisessä tämä funktio.
-Luokaa main():ssa olio perillisestä.
-Luokaa main():ssa vanhempi luokan tyyppinen vakio-osoitin, jonka kautta kutsutte virtuaalifunktiota.

Linkitetty lista (Linked list)

Linkitetty lista on yksi perustietorakenteista. Se koostuu joukosta solmuja, joista jokainen koostuu linkitettävästä tiedosta ja viitteistä seuraavaan (ja mahdollisesti edelliseen) solmuun listassa. Yhden viitteen listaa kutsutaan yksisuuntaiseksi ja jälkimmäistä kaksisuuntaiseksi. Haluttaessa löytää tietty solmu, tulee aloittaa listan alusta, juurisolmusta (root node), ja käydä listaa läpi, kunnes haluttu solmu on löytynyt. Linkitetyn listan etuna on rajoittamaton kasvu (ei staattisesti määriteltyä maksimikokoa) ja O(1)-tason lisäys ja poisto-operaatiot (kun käytetään kaksisuuntaista linkitettyä listaa). Indeksointi on O .

Esimerkki 1. Solmun koodirunko.
class CSolmu
{
public:
CSolmu* Seuraava();
void AsetaSeuraava();

protected:
    CSolmu* m_Seuraava; // Osoitin seuraavaan solmuun.
    CSolmu* m_Edellinen; // Osoitin edelliseen solmuun.
    CData* m_Data; // Osoitin listan 'dataan' eli siihen mitä listaan tallennetaan.
};
Varoitus: Koodit toimivat vain Windows-ympäristössä!
// Solmu.h: interface for the Solmu class.
// Solmu-luokka huolehtii tiedon järjestyksestä
// sekä tiedon hausta tiedostosta ja talletuksesta tiedostoon
//////////////////////////////////////////////////////////////////////

#include "Tyontekija.h"
#ifndef h_Solmu
#define h_Solmu

class CSolmu
{
public:
    int HaeTiedostosta();
    void Talleta(); // tiedon talletus levylle
    void Tulosta(); // tulostus ruudulle
    void Lisaa(CSolmu*); // solmun lisäys oikeaan kohtaan
    void Poista(char Nimi[]);
    CTyontekija* AnnaTyontekija() const;
    CSolmu* AnnaSeuraava() const;
    void AsetaSeuraava(CSolmu*);
    CSolmu(CTyontekija*);
    ~CSolmu();

private:
CSolmu* m_pSeuraava;
CTyontekija* m_pTyontekija;
};

#endif
Lähdetiedosto solmulle on seuraava: // Solmu.cpp: implementation of the Solmu class.
//
//////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include "Tyontekija.h"
#include "Solmu.h"
void Menu(void);
int Debug=1;

// CSolmun muodostin
CSolmu::CSolmu(CTyontekija* Tt)
{
m_pTyontekija=Tt;
m_pSeuraava=NULL;
}

// CSolmun tuhoajafunktio
CSolmu::~CSolmu()
{
    printf("\nPoistetaan tyontekija");
    getch();
    delete m_pTyontekija;
    m_pTyontekija=0;
    printf("\nAion poistaa solmun");
    //delete m_pSeuraava;
    //m_pSeuraava=0;
}

// Laitetaan seuraavaksi solmuksi listaan
void CSolmu::AsetaSeuraava(CSolmu* solmu)
{
m_pSeuraava=solmu;
}

CSolmu* CSolmu::AnnaSeuraava() const
{
return m_pSeuraava;
}

CTyontekija* CSolmu::AnnaTyontekija() const
{
return m_pTyontekija;
}

// Uuden solmun lisäys listaan
void CSolmu::Lisaa(CSolmu* UusiSolmu)
{
    char UusiNimi[100];
    char* pUusiNimi;
    char TamanNimi[100];
    char* pTamanNimi;
    char SeuraavanNimi[100];
    char* pSeuraavanNimi;
    char Nimi[100];
    if (!m_pSeuraava)

Unknown macro: { m_pSeuraava=UusiSolmu; if (Debug==1){ printf("nLaitan viimeideksi %s", m_pSeuraava->AnnaTyontekija()->KysyNimi(Nimi)); }

    } else {
        pSeuraavanNimi=m_pSeuraava->AnnaTyontekija()->KysyNimi(SeuraavanNimi);
        pUusiNimi=UusiSolmu->AnnaTyontekija()->KysyNimi(UusiNimi);
        pTamanNimi=m_pTyontekija->KysyNimi(TamanNimi);
        // Tarkistetaanko, sopiiko solmu nykyisen ja seuraavan väliin
        if (strcmp(pUusiNimi,pTamanNimi)>0 && strcmp(pSeuraavanNimi,pUusiNimi)>0)

Unknown macro: { UusiSolmu->AsetaSeuraava(m_pSeuraava); m_pSeuraava=UusiSolmu; if (Debug==1){ printf("nTama %s Uusi %s Seuraava %s", pTamanNimi,pUusiNimi,pSeuraavanNimi); }

} else

Unknown macro: { m_pSeuraava->Lisaa(UusiSolmu); //rekursiivinen kutsu }

    }
}
void CSolmu::Poista(char Nimi[])
{
    char seNimi[100];
    CSolmu* pTemp;
    CSolmu* pTemp2;
    if (m_pSeuraava) {
        if (strcmp(Nimi,m_pSeuraava->AnnaTyontekija()->KysyNimi(seNimi))==0)

Unknown macro: { printf("Loytyi"); getch(); pTemp=m_pSeuraava; pTemp2=m_pSeuraava->m_pSeuraava; if (Debug==1){ printf("n%s",pTemp->AnnaTyontekija()->KysyNimi(seNimi)); // Tarkistetaan onko poistettavaa seuraava olemassa if (pTemp2) printf("n%s",pTemp2->AnnaTyontekija()->KysyNimi(seNimi)); }

delete m_pSeuraava;
if (pTemp2)

Unknown macro: { m_pSeuraava=pTemp2; //hypätään yli }

else

Unknown macro: { m_pSeuraava=0; }

                return;
            }
        if (m_pSeuraava)

Unknown macro: { m_pSeuraava->Poista(Nimi); }

} else

Unknown macro: { printf("nNimea ei loydy tietokannasta Paina enter"); getch(); }

}
// Solmun tulostus näytölle
void CSolmu::Tulosta()

Unknown macro: { char Nimi[100]; if (m_pTyontekija->KysyNimi(Nimi) > 0){ printf("nTyontekija %s", m_pTyontekija->KysyNimi(Nimi)); }

if (m_pSeuraava)

Unknown macro: { m_pSeuraava->Tulosta(); // Rekursiivinen kutsu }

}
/***********************************************************
Tietokannan talletus tiedostoon
************************************************************/
void CSolmu::Talleta()

Unknown macro: { FILE* pTiedosto; int iLukum; CSolmu *pTemp=0; char SeuraavanNimi[100]; char* pSeuraavanNimi; pTemp=this; pTiedosto=fopen("Tiedot.oma","wb"); if (pTiedosto==NULL){ printf("nTiedosto ei aukea"); getch(); }

do {
if (pTemp->m_pSeuraava)

Unknown macro: { iLukum=fwrite(pTemp->m_pSeuraava->m_pTyontekija, sizeof(CTyontekija),1,pTiedosto); if(Debug){ pSeuraavanNimi=pTemp->m_pSeuraava->AnnaTyontekija()->KysyNimi(SeuraavanNimi); printf("nTalletettava %s",pSeuraavanNimi); }

        }
        // Siirrytään tietokannassa seuraavaan kohtaan
        pTemp=pTemp->m_pSeuraava;
    } while(pTemp);
    fclose(pTiedosto);
}

/********************************************************
Tietokannan haku tiedostosta
**********************************************************/
int CSolmu::HaeTiedostosta()

Unknown macro: { FILE* pTiedosto; // Esitellään osoitin tiedostoon CSolmu* pSolmu=0; int iLukum; CTyontekija* pTemp; // pointteri tilavaraukselle CTyontekija Temp; // tilapäisvarasto tiedostohaulle // Avataan tiedosto pTiedosto=fopen("Tiedot.oma","rb"); if (pTiedosto==NULL){ printf("nTiedosto ei aukea"); getch(); return 0; }

do

Unknown macro: { // luetaan tiedostoa yksi työntekijä kerrallaan muuttujaan Temp iLukum=fread(&Temp, sizeof(CTyontekija),1,pTiedosto); if (iLukum){ // onnistuiko luku tiedostosta // varataan työntekijälle tila keosta pTemp=new CTyontekija(); // *}

    } while(iLukum); // luetaan niin kauan, kun löytyy
    fclose(pTiedosto);
    return 1;
}
Työntekijälle yksinkertainen luokka:
// Tyontekija.h: interface for the CTyontekija class.
//
#ifndef h_Tyontekija
#define h_Tyontekija

class CTyontekija
{
public:
    void AsetaNimi();
    void AsetaNimi(char Nimi[]);
    char* KysyNimi(char Nimi[]);
    CTyontekija();
    ~CTyontekija();
    CTyontekija operator=(CTyontekija T);

private:
char m_Nimi[100];
};

#endif
Tyontekijäluokka, joka liittyy linkitettyyn listaan on esitetty seuraavassa:
// Tyontekija.cpp: implementation of the CTyontekija class.
//
//////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include "Tyontekija.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CTyontekija::CTyontekija()
{
//printf("\nAnna nimi: ");
//gets(m_Nimi);
}

CTyontekija::~CTyontekija()
{
}

void CTyontekija::AsetaNimi(char Nimi[])
{
strcpy(m_Nimi,Nimi);
}

char* CTyontekija::KysyNimi(char Nimi[])
{
strcpy(Nimi,m_Nimi);
return Nimi;
}

void CTyontekija::AsetaNimi()
{
printf("Anna nimi ");
gets(m_Nimi);
}

CTyontekija CTyontekija::operator=(CTyontekija T)
{
    strcpy(m_Nimi,T.m_Nimi);
    //strcpy(m_Osasto,T.m_Osasto);
    return *this;
}

Linkitetylle listalle on seuraavassa esitetty pääohjelma:
/************************************************************
Työntekijätietokanta
Tietokanta on toteutettu linkitettynä listana
Tietokanta muodostuu solmuista, jotka on likitetty osoittimilla toisiinsa
*************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include "Tyontekija.h"
#include "Solmu.h"
void Menu();

int main()
{
    int Valitsin;
    char Nimi[100];
    CSolmu* pSolmu=0;
    int Tiedosto=0;
    // Varataan tietokannalle alkukohta
    CTyontekija* pTyontekija = new CTyontekija();
    pTyontekija->AsetaNimi("aaa");
    CSolmu* pJuuri = new CSolmu(pTyontekija);
    // Haetaan tiedostosta alkukohtaa seuraavat tiedot
    Tiedosto = pJuuri->HaeTiedostosta();

while(1)

Unknown macro: { Menu(); Valitsin=getch(); switch (Valitsin){ case '0'}

}
}
void Menu()

Unknown macro: { printf("nn0=ohjelman lopetus"); printf("n1=Duunarin lisays tietokantaan"); printf("n2=Kaikkien duunarien tulostus"); printf("n3=Duunarin poisto tietokannastann");} ----Merkkijonot C}

Tekstin vertaaminen toiseen tekstiin:
Ei ole sama -vertailu:
if (MJono != "kerkko")

Unknown macro: { // Testataan eroaako merkkijonot. cout << "MJono ei ole sama kuin "kerkko"" << endl; }

Onko sama -vertailu:
if (MJono == "Tämä on merkkijono, johon on lisätty tekstiä...")

Unknown macro: { // Testataan onko merkkijonot samat. cout << "MJono on sama kuin "Tämä on merkkijono, johon on lisätty tekstiä..."" << endl; }

Child pages

Esimerkit

Esimerkit