Esimerkit
Harjoitus 1:
Aiheet: Luokka, olion luonti sekä jäsenmuuttujienja metodien käsittely.
...
Elain.h:
| Code Block |
|---|
} {code} 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 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 void Tulosta(); }; |
Elain.cpp:
| Code Block |
|---|
\#include "stdafxElain.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:
| Code Block |
|---|
\#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>
...
| Wiki Markup |
|---|
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
| Wiki Markup |
|---|
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 |
...
| Wiki Markup |
|---|
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;
...
| Wiki Markup |
|---|
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>
| Wiki Markup |
|---|
class CElain
\{
private: // saatavissa vain luokan metodeilla
char m_Nimi\[100\];
float m_Massa; |
...
| Wiki Markup |
|---|
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
}; |
...
| Wiki Markup |
|---|
bool CElain::AsetaTiedot(char Nimi\[\], float Massa)
\{
printf("AsetaTiedot(char\[\], float)\n");
AsetaTiedot(Nimi);
AsetaTiedot(Massa);
return true;
} |
...
| Wiki Markup |
|---|
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;
| Wiki Markup |
|---|
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;
...
| Wiki Markup |
|---|
int main()
\{
char mjono\[\]="Tämä on merkkijono"; |
...
//
...
1.
...
tapa
...
tulostaa
...
merkkijono
cout << "mjono = " << mjono << endl;
| Wiki Markup |
|---|
// 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
| Wiki Markup |
|---|
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
| Wiki Markup |
|---|
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) \{
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)
...
{ UusiSolmu->AsetaSeuraava(m_pSeuraava);
m_pSeuraava=UusiSolmu;
if (Debug==1)
{ printf("\nTama %s Uusi %s Seuraava %s",
pTamanNimi,pUusiNimi,pSeuraavanNimi);
| Wiki Markup |
|---|
} |
...
} else \{ 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)
{ 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)
{m_pSeuraava=pTemp2; //hypätään yli
}
else
{m_pSeuraava=0;
}
return;
}
if (m_pSeuraava)
{m_pSeuraava->Poista(Nimi);
}
}
else
{printf("\nNimea ei loydy tietokannasta Paina enter");
getch();
| Wiki Markup |
|---|
|
...
} } // Solmun tulostus näytölle void CSolmu::Tulosta() \{ |
...
char Nimi\[100\]; |
if (m_pTyontekija->KysyNimi(Nimi) > 0)
{printf("\nTyontekija %s", m_pTyontekija->KysyNimi(Nimi));
}
if (m_pSeuraava)
{m_pSeuraava->Tulosta(); // Rekursiivinen kutsu
}
}
/***********************************************************
Tietokannan talletus tiedostoon
************************************************************/
void CSolmu::Talleta()
{ FILE* pTiedosto;
int iLukum;
CSolmu *pTemp=0;
| Wiki Markup |
|---|
|
...
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)
{ 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()
{ 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
{ iLukum=fread(&Temp, sizeof(CTyontekija),1,pTiedosto); // luetaan tiedostoa yksi työntekijä kerrallaan muuttujaan Temp
if (iLukum) { // onnistuiko luku tiedostosta
pTemp=new CTyontekija(); // varataan työntekijälle tila keosta
*pTemp=Temp; // *:llä haetaan osoitteessa pTemp oleva muuttuja ja talletetaan siihen tiedostosta haettu tieto
pSolmu=new CSolmu (pTemp); // Varataan solmulle tilaa
this->Lisaa(pSolmu); // lisätään solmu tietokantaan
}
} 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();
| Wiki Markup |
|---|
|
...
void AsetaNimi(char Nimi\[\]); |
| Wiki Markup |
|---|
|
...
char\* KysyNimi(char Nimi\[\]); |
CTyontekija();
~CTyontekija();
CTyontekija operator=(CTyontekija T);
| Wiki Markup |
|---|
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"
| Wiki Markup |
|---|
////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CTyontekija::CTyontekija() \{ |
...
//printf("\nAnna nimi: "); |
...
//gets(m_ |
...
Nimi) |
...
; } CTyontekija::~CTyontekija() |
...
\{ |
...
} void CTyontekija::AsetaNimi(char Nimi\[\]) |
| Wiki Markup |
|---|
\{ 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;
| Wiki Markup |
|---|
char Nimi\[100\]; |
CSolmu* pSolmu=0;
int Tiedosto=0; // Varataan tietokannalle alkukohta
CTyontekija* pTyontekija = new CTyontekija();
pTyontekija->AsetaNimi("aaa");
CSolmu* pJuuri = new CSolmu(pTyontekija);
Tiedosto = pJuuri->HaeTiedostosta(); // Haetaan tiedostosta alkukohtaa seuraavat tiedot
while(1)
{ Menu(); Valitsin=getch();
switch (Valitsin)
{ case '0': exit(1);
// lisäys case '1':
pTyontekija=new CTyontekija();
pTyontekija->AsetaNimi();
pSolmu=new CSolmu(pTyontekija);
pJuuri->Lisaa(pSolmu); // lisätään duunari listaan
pJuuri->Talleta();
break;
// Tulostus case '2':
pJuuri->Tulosta();
break;
// Poisto case '3':
printf("Anna nimi: ");
gets(Nimi);
pJuuri->Poista(Nimi);
pJuuri->Talleta();
break;
default:
break;
}
}
}
void Menu()
{ printf("\n\n0=ohjelman
...
lopetus");
...
printf("\n1=Duunarin
...
lisays
...
tietokantaan");
...
printf("\n2=Kaikkien
...
duunarien
...
tulostus");
...
printf("\n3=Duunarin
...
poisto
...
tietokannasta\n\n");
...
}
...
Merkkijonot
C:n
...
merkkijonot
...
C++-kieli
...
tarjoaa string-luokan,
...
jota
...
voidaan
...
käyttää
...
merkkijonojen
...
käsittelyyn.
...
Sen
...
etu
...
C:n
...
merkkijonoihin
...
on,
...
että
...
sille
...
ei
...
tarvitse
...
määritellä
...
kokoa
...
ja
...
se
...
osaa
...
kasvaa
...
tarvittaessa.
...
Esimerkki
...
1.
...
string-luokan
...
peruskäyttö:
...
#include
...
<string> // Täällä esitellään string-luokka
#include <iostream> // Täällä esitellään cout.
using namespace std; // Otetaan std namespace käyttöön.
int main()
{ string MJono = ""; // Tyhjä merkkijono.
MJono = "Tämä on merkkijono"; // Tekstin sijoitus.
cout << "MJono: " << MJono << endl; // Tekstin tulostus cout:lla.
return 0; }
Tämän lisäksi string-luokka tarjoaa paljon muutakin:
Tekstin lisääminen merkkijonoon:
MJono += ", johon on lisätty tekstiä..."; // Tekstin lisääminen loppuun.
Tekstin tulostus printf()-funktiolla:
printf("MJono: %s\n", MJono.c_str());
...
// Tekstin tulostus printf():llä.
...
Tekstin
...
tulostaminen
...
merkki
...
kerrallaan:
...
for (int
...
i=0;
...
i<MJono.length();
...
i++)
...
{ // length()
...
palauttaa
...
merkkijonon
...
pituuden.
| Wiki Markup |
|---|
cout << "MJono\[" << i << "\]: " << MJono\[i\] << endl; // \[indeksi\] palauttaa indeksin osoittaman merkin, esim. MJono\[1\] |
...
|
...
toisen merkin, jne. |
...
|
...
|
...
} |
Tekstin vertaaminen toiseen tekstiin:
Ei ole sama -vertailu:
if (MJono != "kerkko")
{ // 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ä...")
...
{
...
//
...
Testataan
...
onko
...
merkkijonot
...
samat.
...
cout << "MJono on sama kuin \"Tämä
...
on
...
merkkijono,
...
johon
...
on
...
lisätty
...
tekstiä...\""
...
<<
...
endl;
...
}