8. C++- kielen muuttujista ja aliohjelmista

• Mitä tässä luvussa käsitellään?

Mitä tässä luvussa käsitellään?

* malliohjelma jossa tarvitaan välttämättä muuttujia

* osoiteoperaattori, &

* osoitin muuttujat ja epäsuora osoitus, *

* aliohjelmat, eli funktiot

* erilaiset aliohjelmien kutsumekanismit

* referenssimuuttujat eli viitemuuttujat, &

Syntaksi:

	Seuraavassa muut = muuttujan nimi, koostuu A-Z,a-z,0-9,_, ei ala 0-9
	muut.esittely:    tyyppi muut = alkuarvo;            // 0-1 x =alkuarvo
	sijoitus:         muut = lauseke;
	lukeminen, C:     scanf(format, osoite, osoite, ...) // 0-n x osoite
	lukeminen, C++    cin >> olio >> olio;               // 1-n x olio
	aliohj.esittely:  tyyppi aliohj_nimi(tyypi muut, tyyppi muut);  // 0-n x muut
	aliohj.kutsu      muut = aliohj_nimi(arvo, arvo);    // 0-1 x muut=, 0-n x arvo
	muut.osoite:      &muut
	osoitinmuut.esit: tyyppi *pMuut_nimi
	epäsuora osoitus: *osoite
	viitemuut.esit.   tyyppi &rMuut_nimi

8.1 Mittakaavaohjelman suunnittelu

Millainen ohjelman toiminta voisi olla? Vaikkapa seuraavanlainen:

	C:\OMA\MATKAAJA>matka[RET]
	Lasken 1:200000 kartalta millimetreinä mitatun matkan 
	kilometreinä luonnossa.
	Anna matka millimetreinä>35[RET]
	Matka on luonnossa 7.0 km.
	C:\OMA\MATKAAJA>matka[RET]
	Lasken 1:200000 kartalta millimetreinä mitatun matkan 
	kilometreinä luonnossa.
	Anna matka millimetreinä>352[RET]
	Matka on luonnossa 70.4 km.
	C:\OMA\MATKAAJA>

8.2 Muuttujat

Kone viittaa muistipaikkaan muistipaikan osoitteella. Kääntäjäohjelman tehtävä on muuttaa muuttujien nimiä muistipaikkojen osoitteiksi. Kääntäjälle täytyy kuitenkin kertoa aluksi minkäkokoisia 'möhkäleitä' halutaan käyttää. Esimerkiksi kokonaisluku voidaan tallettaa pienempään tilaan kuin reaaliluku. Mikäli haluaisimme varata vaikkapa muuttujan, jonka nimi olisi matka_mm kokonaisluvuksi, kirjoittaisimme seuraavan C- kielisen lauseen (muuttujan esittely):

	int matka_mm; /* yksinkertaisen tarkkuuden kokonaisluku */

	VAR matka_mm: INTEGER;

	double matka_km; /* kaksinkertaisen tarkkuuden reaaliluku */

	signed int matka_km;       /* Sama kuin int matka_km  */
	unsigned int sormia;       /* Aina positiivinen       */
	short int varpaita;        /* Ei koskaan kovin montaa */
	long int valtion_velka_Mmk;/* Tarvitaan ISO arvoalue  */

	signed matka_km;       /* Sama kuin int matka_km  */
	unsigned sormia;       /* Aina positiivinen       */
	short varpaita;        /* Ei koskaan kovin montaa */
	long valtion_velka_Mmk;/* Tarvitaan ISO arvoalue  */

	const volatile unsigned long int sadasosia; 

	int      -  kokonaisluvut - 32 768 -   32 767, 16-bit, tai
	           - -2 147 483 648 - 2 147 483 647, 32-bit systeemit
	double   -  reaaliluvut n. 15 desim. - > 1.7e308
	char     -  kirjaimet, kokonaislukuina - 128 -   127 (tai 0-255)

8.2.1 Matkan laskeminen

c-muut\matka.cpp - mittakaavamuunnos 1:200000 kartalta

	// matka.cpp
	// Ohjelmalla lasketaan mittakaavamuunnoksia 1:200000 kartalta
	// Vesa Lappalainen 18.9.1991
	#include <iostream.h>
	
	const double MITTAKAAVA = 200000.0;
	const double MM_KM      = 1000.0*1000.0;
	
	int main(void)
	{
	  int    matka_mm;
	  double matka_km;
	
	  // Ohjeet
	  cout << "Lasken 1:" << MITTAKAAVA 
	       << " kartalta millimetreinä mitatun matkan\n";
	  cout << "kilometreinä luonnossa.\n";
	
	  // Syöttöpyyntö ja vastauksen lukeminen
	  cout << "Anna matka millimetreinä>";
	  cin >> matka_mm;
	
	  // Datan käsittely
	  matka_km = matka_mm*MITTAKAAVA/MM_KM;
	
	  // Tulostus
	  cout << "Matka on luonnossa "<< matka_km << " km." << endl;
	
	  return 0;
	}

Tehtävä 8.55 Vakion korvaaminen

Korvaa vakioiden esittely #define makroilla. Mitä vaaroja liittyy makrojen käyttöön tässä tapauksessa.

8.2.2 Muuttujan nimeäminen

Muuttujan nimi ei myöskään saa olla mikään varatuista sanoista (reserwed word):

	C-kielen varatut sanat:
	auto   	break       	case      	char
	const   	continue    	default   	do
	double      	else        	enum     	extern
	float     	for         	goto	if
	int       	long        	register	return
	short    	signed      	sizeof	static
	struct    	switch      	typedef	union
	unsigned   	void        	volatile	while
	C++:ssa on lisäksi varattuja sanoja:
	asm	bool	catch	class	
	const_cast	delete	dynamic_cast	explicit 
	false	friend	inline	mutable	
	namespace	new	operator	private	
	protected 	public	__rtti	static_cast	
	template	this	throw	true	
	try	typeid	typename 	reinterpret_cast
	using	virtual	wchar_t

Tehtävä 8.56 Varatut sanat

Merkitse edelliseen taulukkoon kunkin varatun sanan viereen se, missä kohti monistetta ko. sana on selitetty.

Tehtävä 8.57 Muuttujan nimeäminen

Mitkä seuraavista ovat oikeita muuttujan esittelyjä ja mitkä niistä ovat hyviä:

int o;

int 9_kissaa;

int _9_kissaa;

double pitkä_matka;

int i, j, kissojen_maara;

int auto, pyora, juna;

8.2.3 Muuttujalle sijoittaminen =

Sijoitusmerkin = vasemmalle puolelle tulee muuttujan nimi ja oikealle puolelle mikä tahansa lauseke, joka tuottaa halutun tyyppisen tuloksen (arvon). Lausekkeessa voidaan käyttää mm. operaattoreita +,- ,*,/ ja funktiokutsuja. Lausekkeen suoritusjärjestykseen voidaan vaikuttaa suluilla (ja):

	kengan_koko  = 42;
	pi           = 3.14159265358979323846;
	// usein käytetään math.h:n M_PI vakiota 
	pi           = M_PI;
	pinta_ala    = leveys * pituus;
	ympyran_ala  = pi*r*r;
	hypotenuusa  = vastainen_kateetti/sin(kulma);
	matka_km     = matka_mm*MITTAKAAVA/MM_KM; 

	r*r = 5.0; /* MIELETÖN USEIMMISSA OHJELMOINTI KIELISSA! */	

Huom! C- kielessä = merkki EI ole yhtäsuuruusmerkki, vaan nimenomaan sijoitusmerkki. Yhtäsuuruusmerkki on = =.

Tehtävä 8.58 Muuttujien esittely

Esittele edellisissä sijoitus - esimerkeissä tarvittavat muuttujat.

8.2.4 Muuttujan esittely ja alkuarvon sijoittaminen

	int    kengan_koko = 32, takin_koko = 52;
	double pi = 3.14159265358979323846, r = 5.0; 

8.3 Muuttujan arvon lukeminen päätteeltä

8.3.1 scanf ja muuttujan osoite &

	  scanf("%d",&matka_mm); 
	

&matka_mm tarkoittaa muuttujan matka_mm osoitetta. Funktiolle ei voida viedä parametrina itse muuttujan arvoa, koska funktio ei tämän perusteella tiedä mihin se luetun arvon sijoittaisi. Tämän takia välitämmekin muuttujan osoitteen, eli sen paikan muistissa, missä muuttujan arvo sijaitsee. Näin aliohjelma tietää sen mihin paikkaan arvo tulee sijoittaa.

Varoitus! Yleinen virhe on unohtaa &- merkki pois scanf- funktion kutsusta.

Joissakin ohjelmointikielissä (kuten Pascal tai Fortran ja osittain myös C++:ssa) ei osoitemerkkiä kirjoiteta, koska kääntäjä kääntää vastaavat kutsut siten, että parametrina viedäänkin osoite. C- kielessä on mahdollista välittää vain arvoja parametrina.

	  int pituus,leveys;
	  printf("Anna kentän pituus ja leveys metreinä >");
	  scanf("%d %d",&pituus,&leveys); 

c-muut\ala.c - tietojen kysyminen kunnes oikein

	/* ala.c */
	/* Ohjelmalla luetaan kentän leveys ja pituus sekä tulostetaan
	   näiden perusteella kentän ala.  Tietoja kysytään kunnes
	   molemmat tulevat oikein annetuksi.
	
	   Vesa Lappalainen 18.9.1991
	*/
	#include <stdio.h>
	int main(void)
	{
	  int pituus,leveys;
	  do {
	    printf("Anna kentän pituus ja leveys metreinä >");
	    fflush(stdin); /* Poistetaan mahd. ed. kier. ylim. merkit, epästd. */
	  } while ( scanf("%d %d",&pituus,&leveys) < 2 );
	  printf("Ala on %d m2.\n",pituus*leveys);
	  return 0;
	}

	scanf("%d,%d",&pituus,&leveys) 

	  printf("Anna mittakaava muodossa 1:2000 >");
	  scanf("1:%lf",&mittakaava); 

	  printf("Anna mittakaava muodossa 1:2000 >");
	  scanf("%lf:%lf",&kerroin,&mittakaava); 

	  scanf("1:%lf",&mittakaava); 

Tehtävä 8.59 Mittakaavan kysyminen

Muuta matka- ohjelmaa siten, että myös mittakaava kysytään käyttäjältä. Mikäli mittakaavaan vastataan pelkkä [RET] pitää mittakaavaksi tulla 1:200000.

8.3.2 Tiedon lukeminen C++:ssa, cin

	cin >> matka_mm;

c-muut\ala.cpp - tiedon kysyminen kunnes pilkku väliin

	#include <iostream.h>
	int main(void)
	{
	  int pituus,leveys;
	  char c;
	  do {  // Ohjelma on helppo saad ikuiseen silmukkaan!
	    cout << "Anna kentän pituus ja leveys metreinä >";
	    cin >> pituus >> c >> leveys;
	  } while ( c != ',' );
	  cout << "Ala on " << pituus*leveys << " m2." << endl;
	  return 0;
	}

8.4 Osoittimet

8.4.1 Miksi osoittimet?

Edellä sanottiin, että &matka_mm on osoite muuttujaan matka_mm. Tätä voitaisiin kuvata seuraavasti:

8.4.2 Muuttujan arvon epäsuora muuttaminen

c-muut\kissaoso.cpp - epäsuora osoitus

	// kissaoso.cpp
	// Mitä ohjelma tulostaa?
	#include <iostream.h>
	int main(void)
	{
	  int kissoja,koiria;
	  int *pElaimia;   // Osoitinmuuttuja kokonaislukuun. (p = pointer)
	
	  pElaimia  = &kissoja;
	  *pElaimia = 5;
	
	  pElaimia  = &koiria;
	  *pElaimia = 3;
	
	  cout << "Kissoja on " << kissoja << " ja koiria " << koiria << "." << endl;
	
	  return 0;
	}

	osoitin =                // tässä tapauksessa pElaimia =

Vastaavasti muoto *osoitin ("tähdätään osoitinta pitkin") tarkoittaa sen muistipaikan sisältöä, johon muuttuja osoitin osoittaa. Olkoon meillä muisti jakaantunut käännöksen jälkeen seuraavasti:

Tehtävä 8.60 Sijoitus osoittimeen

Jos edellä voitaisiin sijoittaa

pElaimia = 100;

niin mitä tapahtuisi sijoituksella

*pElaimia = 10;

Entäpä jos olisi sijoitukset

pElaimia = 106;

*pElaimia = 104;

*pElaimia = 108;

8.4.3 * ja &

	*p

c-muut\ososij.c - miten osoitinta saa käyttää

	/* ososij.c */
	int *p,i;        ...  i = *p;  /* OK jos on ollut sijoitus p = */
	double *p,d;     ...  d = *p;  /* OK jos on ollut sijoitus p = */
	void *p; int i;  ...  i = *p;  /* VÄÄRIN */

	&i

	int i,*p;        p = &i;  /* OK */
	double *p,d;     p = &d;  /* OK */
	void *p; int i;  p = &i;  /* OK, koska void osoittimelle saa
	                                 sijoittaa minkä tahansa osoittimen */

	double *p; int i; 
	  p = &i;  /* VAARALLINEN */
	  i = *p;  /* OK, paikassa p oleva double muuttuu int */

	int i,j;
	j = *i; /* VÄÄRIN, koska i ei ole osoitin! */

Tehtävä 8.61 *&

Tästä tehtävästä huolimatta ei alla olevan kaltaisia sotkuja tule käyttää!

Olkoon muuttujien esittelyt kuten ohjelmassa kissaoso.c. Missä seuraavista tapauksissa tulee sijoitetuksi 5 muuttujalle kissa (*&i tarkoittaa *(&i)):

/* ososotku.c */

/* a */ *&kissoja = 5;

/* b */ &*kissoja = 5;

/* c */ *&*&*&*&kissoja = 5;

/* d */ &*pElaimia = &kissoja; *&*pElaimia = 5;

/* e */ *&pElaimia = kissoja; *pElaimia = 5;

8.4.4 NULL- osoitin

NULL on varattu tarkoittamaan, ettei osoittimella ole laillista osoitteena toimivaa arvoa. Yleensä vakio NULL on 0, mutta tähän ei saa liiaksi luottaa. Kuitenkin taataan, että jos p on NULL- osoitin, niin ehtolause

	if ( p ) ...
	/* on sama kuin */
	if ( p != NULL ) ... 

8.5 Aliohjelmat (funktiot)

1.

Haluttu tehtävä on valmiiksi jonkun toisen kirjoittamana aliohjelmana esimerkiksi standardikirjastossa.

2.

Haluttua tehtävää suoritetaan usein liki samanlaisena joko samassa ohjelmassa tai jossain toisessa ohjelmassa.

3.

Haluttu tehtävä muodostaa selvän kokonaisuuden, jonka toiminta on ilmaistavissa muutamalla sanalla riittävän selkeästi (= aliohjelman nimi).

4.

Haluttua tehtävää ei juuri sillä hetkellä osata tai viitsitä ohjelmoida. Tällöin määritellään millainen aliohjelma tarvitaan ja kirjoitetaan tarvittavaan kohtaan pelkkä aliohjelman kutsu. Itse aliohjelma voidaan aluksi toteuttaa varsin triviaalina ja korjata myöhemmin tekemään sen varsinainen tehtävä.

5.

Rakenne saadaan selkeämmän näköiseksi.

8.5.1 Parametriton aliohjelma

c-muut\matka_a1.c - ohjeet aliohjelmaksi

	#include <stdio.h>
	
	#define MITTAKAAVA 200000.0
	#define MM_KM      (1000.0*1000.0)
	
	void ohjeet(void)
	{
	  printf("Lasken 1:%3.0lf kartalta millimetreinä mitatun matkan\n",MITTAKAAVA);
	  printf("kilometreinä luonnossa.\n");
	}
	
	int main(void)
	{
	  int    matka_mm;
	  double matka_km;
	
	  ohjeet();
	
	  printf("Anna matka millimetreinä>");
	  scanf("%d",&matka_mm);
	
	  matka_km = matka_mm*MITTAKAAVA/MM_KM;
	
	  printf("Matka on luonnossa %1.1lf km.\n",matka_km);
	
	  return 0;
	}

Tämän etu on siinä, että saimme pääohjelman selkeämmän näköiseksi.

8.5.2 Funktiot ja parametrit

	  ohjeet();
	  kysy_matka(&matka_mm);
	  matka_km = mittakaava_muunnos(matka_mm);
	  tulosta_matka(matka_km);
	  return 0; 

Edellä on käytetty neljän eri tyypin aliohjelmia (funktioita)

1.

ohjeet();- parametriton aliohjelma

2.

kysy_matka(&matka_mm); - aliohjelma joka palauttaa tuloksen parametrissaan (vrt. esim scanf).

3.

mittakaava_muunnos(matka_mm); - funktio, joka palauttaa tuloksen nimessään

4.

tulosta_matka(matka_km); - aliohjelma, jolle vain viedään arvo, mutta mitään arvoa ei palauteta

c-muut\matka_a2.cpp - erilaisia funktioita

	// matka_a2.cpp
	// Ohjelmalla lasketaan mittakaavamuunnoksia 1:200000 kartalta
	// Vesa Lappalainen 4.1.1997
	#include <iostream.h>
	
	const double MITTAKAAVA = 200000.0;
	const double MM_KM      = 1000.0*1000.0;
	
	void ohjeet(void)
	{
	  cout << "Lasken 1:" << MITTAKAAVA 
	       << " kartalta millimetreinä mitatun matkan\n";
	  cout << "kilometreinä luonnossa.\n";
	}
	
	void kysy_matka(int *pMatka_mm)
	{
	  int mm;
	  cout << "Anna matka millimetreinä>";
	  cin >> mm;
	  *pMatka_mm = mm;
	}
	
	double mittakaava_muunnos(int matka_mm)
	{
	  return matka_mm*MITTAKAAVA/MM_KM;
	}
	
	void tulosta_matka(double matka_km)
	{
	  cout << "Matka on luonnossa "<< matka_km << " km." << endl;
	}
	
	
	int main(void)
	{
	  int    matka_mm;
	  double matka_km;
	
	  ohjeet();
	  kysy_matka(&matka_mm);
	  matka_km = mittakaava_muunnos(matka_mm);
	  tulosta_matka(matka_km);
	  return 0;
	}

mittakaava_muunnos on reaaliluvun palauttava funktio, joten se esitellään double - tyyppiseksi.

Seuraavaksi pöytätestaamme ohjelmamme toiminnan:

	main	kysy_matka	mi..muunnos	tulosta
lause	matka_mm	matka_km	pMatka_mm	mm	matka_mm	tulos	matka_km	tulostus
40 ohjeet()	??	??
9-13 cout<<								Lasken 1:200000
41 kysy_mat			&matka_mm
16-18 int m				??
19 cout <<								Anna matka ...
20 cin>>mm				352
21 *pMatka	352		<==o
42 matka_km					352
26 return						70.4
42 matka_km		70.4
43 tulosta							70.4
29-31 cout<								Matka on luo..
44 return 0;

Mikäli kukin aliohjelma olisi testattu erikseen, riittäisi meille pelkkä pääohjelman testi:

	main
lause	matka_mm	matka_km	tulostus
40 ohjeet()	??	??	Lasken 1:200000
41 kysy_mat	352		Anna matka ..
42 matka_km		70.4
43 tulosta			Matka on luo..
44 return 0;

Tämä on testaustapa, johon tulisi pyrkiä. Isossa ohjelmassa ei ole enää mitään järkeä testata sitä jokainen aliohjelma kerrallaan. Koodiin liitettyjen aliohjelmien tulee olla testattuja kukin erillisinä ja lopullinen testi on vain viimeisimmän mallin mukainen!

Tehtävä 8.62 matka_a2.c

Kirjoita matka_a2.cpp:stä C- versio (tietovirrat => printf/scanf)

8.5.3 Parametrin nimi kutsussa ja esittelyssä

c-muut\matka_a3.cpp - erilaisia tapoja kutsua funktiota

	// matka_a3.cpp
	#include <iostream.h>
	
	void tulosta_matka(double matka_km)
	{
	  cout << "Matka on luonnossa "<< matka_km << " km." << endl;
	}
	
	int main(void)
	{
	  double d = 50.2;
	  tulosta_matka(d);         // eri niminen muuttuja
	  tulosta_matka(30.7);      // vakio 
	  tulosta_matka(d+20.8);    // lauseke
	  tulosta_matka(2*d-30.0);  // lauseke 
	  return 0;
	}

	matka_km = d;
	matka_km = 30.7;
	matka_km = d+20.8;
	matka_km = 2*d- 30.0

8.5.4 Osoitteen välittäminen

	kysy_matka(&matka_mm) 

	void kysy_matka(int *pMatka_mm) 

Aliohjelmassa on aluksi yksinkertaisuuden vuoksi esitelty aliohjelman paikallinen muuttuja mm, johon päätteeltä saatava arvo ensin luetaan. Jotta myös pääohjelma saisi tietää tästä, pitää suorittaa epäsuora osoitus ("tähdätä osoitinta pitkin"):

	*pMatka_mm = mm;

	void kysy_matka(int *pMatka_mm)
	{
	  cout << "Anna matka millimetreinä>";
	  cin >> *pMatka_mm;
	}

Lyhennetty C- versio samasta aliohjelmasta olisi:

	void kysy_matka(int *pMatka_mm)
	{
	  printf("Anna matka millimetreinä>");
	  scanf("%d",pMatka_mm);
	}

	scanf("%d",&matka_mm); 

	scanf("%d",&*pMatka_mm); /* ==scanf("%d",pMatka_mm); */

8.5.5 Viitemuuttujat (referenssimuuttujat, &)

Aliohjelma olisi muotoa:

c-muut\matka_ar.cpp - parametri referenssinä

	void kysy_matka(int &rMatka_mm) 
	{
	  int mm;
	  cout << "Anna matka millimetreinä>";
	  cin >> mm;
	  rMatka_mm = mm;
	}

	void kysy_matka(int &rMatka_mm)
	{
	  cout << "Anna matka millimetreinä>";
	  cin >> rMatka_mm;
	}

	int &rMatka_mm

	rMatka_mm = mm;

Huonona (tai jonkin mielestä hyvänä) puolena viitemuuttujista voitaisiin pitää sitä, että itse kutsu pääohjelmasta täytyy nyt olla muodossa:

	kysy_matka(matka_mm);                 // HUOM!

Hyvänä puolena on taas se, että aliohjelma voidaan muuttaa viitteitä käyttäväksi muuttamatta itse kutsuvaa ohjelmaa. Tämä tulee kyseeseen sitten kun välitämme parametreinä "isoja" oliota, jolloin on edullisempaa vain viitata olioon, kuin kuljettaa mukana koko olio.

Vielä yksi huono (tai joidenkin mielestä hyvä) puoli viitemuuttujissa on se, ettei niiden viittaamaa paikkaa voida muuttaa muuta kuin alustuksessa (esim. aliohjelman kutsun yhteydessä). Näin osoittimia tarvitaan vielä tilanteissa, joissa tietorakenteita pitää käydä läpi.

8.5.6 & - merkillä monta eri merkitystä

1.

Osoiteoperaattori: Jos & on jo olemassa olevan muuttujan edessä, otetaan muuttujan osoite. - scanf("%d",&matka_mm);

2.

Referenssin esittely: Jos & on muuttujan esittelyn yhteydessä, esitellään viitemuuttuja (referenssi) - int &rMatka_mm

3.

Bittitason AND- operaattori: Jos & esiintyy kahden lausekkeen välissä, on kyseessä bittitason JA- operaattori: parillinen = luku & 0xfffe

4.

Looginen AND- operaattori: Jos & esiintyy 2-kertaisena kahden lausekkeen välissä, on kyseessä looginen JA- operaattori:
if ( kello < 23 && 0 < rahaa ) ...

Yleensä AND operaatiot eivät aiheuta sekaannusta, mutta jokin muistisääntö tarvitaan siihen milloin kirjoitetaan * ja milloin &. Olkoon se vaikka: Vinkki

Tähdet taivaalla

1.

Jos kyseessä on osoiteparametrin välitys tulee * ylös, koska tähdet ovat taivaalla ja niitä osoitetaan, tällöin &- merkit tulevat alas!

2.

Jos kyseessä on parametrin välitys referenssin avulla, ei tarvitse tähtäillä, joten tähtiä ei tule ja jokainen merkki siirtyy pykälän ylöspäin, eli & merkit ylös ja alhaalle ei jää mitään!

3.

Tavallisessa arvoparametrin välityksessä ei tarvita mitään ihmemerkkejä, mutta ei saada ihmeitä aikaankaan!

8.5.7 Nimessään arvon palauttavat funktiot

	int suurempi(int a, int b)
	{
	  if ( a >= b ) return a;
	  return b;
	}

	int hopo(int a) 	
	{
	  int i;
	  return 5;  /* Palauttaa aina 5!!! */
	  i = 3 + a;
	  return i+2;
	}

c-muut\funjaoso.c - sivuvaikutuksellinen funktio

	/* funjaoso.c */
	#include <stdio.h>
	
	int tupla_plus_yksi(int *pArvo)
	{
	  int vanha=*pArvo;     /* Alkuperäinen arvo talteen              */
	  *pArvo = *pArvo + 1;  /* Kutsun muuttuja muuttui nyt! eli j = 4 */
	  return 2*vanha;       /* Arvo palautui nimessä nyt!   eli i = 6 */
	}
	
	int main(void)
	{
	  int i,j=3;
	  i = tupla_plus_yksi(&j);
	  printf("i = %d, j = %d\n",i,j);
	  return 0;
	} 

Tehtävä 8.63 Funktio ja osoitin

Mitä pääohjelma funjaoso tulostaisi jos aliohjelma olisikin ollut:

	int tupla_plus_yksi(int *pArvo)
	{
	  *pArvo = *pArvo + 1;  
	  return 2**pArvo;     
	}

Tehtävä 8.64 Funktio ja referenssi

Kirjoita edellisestä tehtävästä molemmista tupla_plus_yksi - versioista viitemuuttujia käyttävä versio!

8.5.8 Ketjutettu kutsu

	  ohjeet();
	  kysy_matka(&matka_mm);
	  tulosta_matka(mittakaava_muunnos(matka_mm));
	  return 0; 

	(abs)   acos   asin   atan   atan2     atof  (cabs)  ceil 
	cos     cosh   exp    fabs   floor     fmod  frexp   (hypot)
	(labs)  ldexp  log    log10  (matherr) modf  (poly)   pow 
	(pow10) sin    sinh   sqrt   tan       tanh 

	c = sqrt(a*a+b*b) + asin((sin(alpha)+0.2)/2.0); 

	matka_km = kysy_matka()*kysy_mittakaava()/MM_KM; 

Tämän vuoksi pyrimmekin kirjoittamaan funktioiksi vain sellaiset aliohjelmat, jotka palauttavat täsmälleen yhden arvon ja jotka eivät ota muuta informaatiota ympäristöstä kuin sen mitä niille parametrina välitetään. Eli tavoitteena on se, että funktioiden kutsuminen lausekkeen osana olisi turvallista.

Muut aliohjelmat kirjoitamme siten, että arvot palautetaan osoitteen avulla. Hyvin yleinen C- tapa on kuitenkin palauttaa tällaisenkin aliohjelman onnistumista kuvaava arvo funktion nimessä (vrt. esim. scanf).

Tehtävä 8.65 math.h

Katso Turbo- C:n Help- toiminnon avulla kunkin math.h- kirjaston funktion parametrien määrä ja tyyppi sekä se mitä kukin todella tekee.

Tehtävä 8.66 Funktiot

Kirjoita edellä mainitut kysy_matka ja kysy_mittakaava nimessään arvon palauttavina funktioina.

Tehtävä 8.67 Ympyrän ala ja pallon tilavuus

Kirjoita funktiot, jotka palauttavat r- säteisen ympyrän pinta- alan ja r- säteisen pallon tilavuuden.

Kirjoita pääohjelma, jossa pinta- ala ja tilavuus - funktiot testataan.

Tehtävä 8.68 Pääohjelma yhtenä funktiokutsuna

Jatka edellä mainittua ketjuttamista siten, että koko pääohjelma on vain yksi lauseke (ohjeet- kutsu saa olla oma rivinsä jos haluat). Tosin tämä on C- hakkerismia eikä mikään tavoite helposti luettavalta ohjelmalta. Itse asiassa hyvä kääntäjä tekee automaattisesti tämän kaltaista optimointia (mitä muka voitiin säästää?).

8.5.9 Aliohjelmien testaaminen

Esimerkiksi kerhon jäsenrekisterin päämenun tulostamista varten voisimme kirjoittaa aliohjelman nimeltä paamenu. Tämä päämenu voitaisiin sitten testata vaikkapa seuraavalla testipääohjelmalla:

c-muut\menutest.cpp - päämenun testaus

	// menutest.cpp 
	#include "paamenu.cpp" // HUOM! "Oikeasti" aliohjemia ei INCLUDEta 
	                       // vaan paamenu.h ja tehdään projekti tai MAKEFILE! 
	int main(void)
	{
	  paamenu(10);
	  return 0;
	}

c-muut\paamenu.h - päämenun otsikkotiedosto

	/* paamenu.h */
	#ifndef PAAMENU_H
	#define PAAMENU_H
	void paamenu(int jasenia);
	#endif /* PAAMENU_H */

c-muut\paamenu.cpp - päämenun totetutus

	// paamenu.cpp 
	#include <iostream.h>
	#include "paamenu.h"
	
	void paamenu(int jasenia)
	{
	  cout << "\n\n\n\n\n";
	  cout << "Jäsenrekisteri\n";
	  cout << "==============\n";
	  cout << "\n";
	  cout << "Kerhossa on " << jasenia << " jäsentä.\n";
	  cout << "\n";
	  cout << "Valitse:\n";
	  cout << "   ?  = avustus\n";
	  cout << "   0  = lopetus\n";
	  cout << "   1  = lisää uusi jäsen\n";
	  cout << "   2  = etsi jäsenen tiedot\n";
	  cout << "   3  = tulosteet\n";
	  cout << "   4  = tietojen korjailu\n";
	  cout << "   5  = päivitä jäsenmaksuja" << endl;
	  cout << "   :";
	}

c-muut\paamenu2.cpp - toteutus vähillä cout-kutsuilla

	// paamenu2.cpp 
	#include <iostream.h>
	#include "paamenu.h"
	
	void paamenu(int jasenia)
	{
	  cout << "\n\n\n\n\n"
	  "Jäsenrekisteri\n"
	  "==============\n"
	  "\n"
	  "Kerhossa on " << jasenia << " jäsentä.\n"
	  "\n"
	  "Valitse:\n"
	  "   ?  = avustus\n"
	  "   0  = lopetus\n"
	  "   1  = lisää uusi jäsen\n"
	  "   2  = etsi jäsenen tiedot\n"
	  "   3  = tulosteet\n"
	  "   4  = tietojen korjailu\n"
	  "   5  = päivitä jäsenmaksuja" << endl <<
	  "   :";
	}

c-muut\paamenu3.cpp - rivin jatkaminen

	#include <iostream.h>
	#include "paamenu.h"
	
	void paamenu(int jasenia)
	{
	cout << "\n\n\n\n\n\
	Jäsenrekisteri\n\
	==============\n\
	\n\
	Kerhossa on " << jasenia << " jäsentä.\n\
	\n\
	Valitse:\n\
	   ?  = avustus\n\
	   0  = lopetus\n\
	   1  = lisää uusi jäsen\n\
	   2  = etsi jäsenen tiedot\n\
	   3  = tulosteet\n\
	   4  = tietojen korjailu\n\
	   5  = päivitä jäsenmaksuja" << endl << "\
	   :";
	}

Huomattakoon, että aliohjelma on saatu kopioiduksi suoraan aikaisemmasta ohjelman suunnitelmasta lisäämällä vain kunkin rivin alkuun cout <<"ja loppuun \n";. Tällaiset toimenpiteet voidaan automatisoida tekstinkäsittelyn avulla.

8.6 Lisää aliohjelmista

8.6.1 Useita parametreja

Ottakaamme esimerkiksi mittakaava_muunnos - funktio. Mikäli ohjelma haluttaisiin muuttaa siten, että myös mittakaavaa olisi mahdollista muuttaa, pitäisi myös mittakaava voida välittää muunnos- aliohjelmalle parametrina. Kutsussa tämä voisi näyttää esim. tältä:

	  matka_km = mittakaava_muunnos(10000.0,32); 

	double mittakaava_muunnos(double mittakaava,int matka_mm)
	{
	  return matka_mm*mittakaava/MM_KM;
	}

	mittakaava = 10000.0;
	matka_mm   = 32; 

	  matka_km = mittakaava_muunnos(MITTAKAAVA,matka_mm); 

	mittakaava = MITTAKAAVA; /* Ohjelman vakio                */
	matka_mm   = matka_mm;   /* Pääohjelman muuttuja matka_mm */

Parametreista osa, ei yhtään tai kaikki voivat olla myös osoitteita tai referenssejä.

Huom! Vaikka kaikilla aliohjelman parametreilla olisikin sama tyyppi, täytyy jokaisen parametrin tyyppi mainita silti erikseen:

	double nelion_ala(double korkeus, double leveys) 

Tehtävä 8.69 Toisen asteen yhtälön juuri

Kirjoita funktio root_1(a,b,c), joka palauttaa jomman kumman toisen asteen yhtälön ax²+bx+c=0 juurista (oletetaan tällä kertaa, että a<>0 ja D = b²- 4ac >= 0. Miksi oletetaan?).

Tehtävä 8.70 Toisen asteen polynomi, root_1

Kirjoita funktio root_1 joka palauttaa toisen asteen polynomin P(x) = ax²+bx+c arvon (muista viedä parametrina myös a,b ja c).

Tehtävä 8.71 root_1 testaus

Kirjoita pääohjelma, jolla voidaan testata root_1 - aliohjelma (jotenkin myös se, että tulos toteuttaa yhtälön).

8.6.2 Muuttujien lokaalisuus

Vastaavasti ulkomaailma ei tiedä mitään aliohjelman omista muuttujista. Näitä aliohjelman lokaaleja muuttujia on esim. seuraavassa:

	void kysy_matka(int *pMatka_mm)
	{
	  int mm;
	  printf("Anna matka millimetreinä>");
	  scanf("%d",&mm);
	  *pMatka_mm = mm;
	}

	pMatka_mm   -  aliohjelman parametrimuuttuja (tässä tapauksessa osoitinmuuttuja).
	mm          -  aliohjelman lokaali apumuuttuja matkan lukemiseksi.

Yleensäkin C- kielessä lausesulut { ja } muodostavat lohkon, jonka ulkopuolelle mikään lohkon sisällä määritelty muuttuja tai tyyppimääritys ei näy. Näkyvyysalueesta käytetään englanninkielisessä kirjallisuudessa nimitystä scope. Lokaaleilla muuttujilla voi olla vastaava nimi, joka on jo aiemmin esiintynyt jossakin toisessa yhteydessä. Lohkon sisällä käytetään sitä määrittelyä, joka esiintyy lohkossa:

c-muut\lokaali.c - lokaalien muuttujien näkyvyys

	#include <stdio.h>             	
	int main(void)
	{
	   char ch='A';
	   printf("Kirjain %c",ch);
	   {
	     int ch = 5;
	     printf(" kokonaisluku %d",ch);
	     {
	       double ch = 4.5;
	       printf(" reaaliluku %5.2lf\n",ch);
	     }
	   }
	   return 0;
	}

Tehtävä 8.72 Eri nimet

Korjaa edellinen ohjelma siten, että kullakin erityyppisellä muuttujalla on eri nimi.

8.6.3 auto ja register

	{
	  int mm;        /* sama kirjoitetaanko näin */
	  auto int mm;   /* vai näin                 */

Joskus kääntäjän työn helpottamiseksi voidaan kääntäjälle ehdottaa jonkin lokaalin muuttujan sijoittamista prosessorin (CPU) rekisteriin ja näin saadaan muuttujan käyttö nopeammaksi. Tämä tehdään varatulla sanalla register.

c-muut\register.c - muuttujat prosessorin rekistereihin

	#include <stdio.h>
	int main(void)
	{
	  register int i;
	  for (i=0; i<4; i++) printf("i=%d\n",i);
	  /* Seuraava ei toimi koska rekisteristä ei saada osoitetta */
	/*  printf("i:n osoite on %p\n",&i); */
	  return 0;
	}

8.6.4 Parametrinvälitysmekanismi

c-muut\aikalisa.cpp - yritys lisätä arvoja

	#include <iostream.h>
	void lisaa(int h, int m, int lisa_min) 	
	{
	  int yht_min = h*60 + m + lisa_min;
	  h = yht_min / 60;
	  m = yht_min % 60;
	}
	
	void tulosta(int h, int m)
	{
	  cout << h << ":" << m << endl;
	}
	
	int main(void)
	{
	  int h=12,m=15;
	  lisaa(h,m,55);
	  tulosta(h,m);
	  return 0;
	}

	Warn :  aikalisa.cpp(8,2):'m' is assigned a value that is never used
	Warn :  aikalisa.cpp(7,2):'h' is assigned a value that is never used

	lisaa(h,m,55);
	
	muistiosoite assembler         selitys
	-------------------------------------------------------------------------
	004010F9     push 0x37           pinoon 55
	004010FB     push [ebp-0x08]     pinoon m:n arvo 
	004010FE     push [ebp-0x04]     pinoon h:n arvo
	00401101     call lisaa          mennään aliohjelmaan lisää
	00401106     add esp,0x0c        poistetaan pinosta 12 tavua (3 x int)

	muistiosoite  sisältö          selitys
	------------------------------------------------------------------------
	064FDEC       00401106 <-ESP   paluuosoite kun aliohjelma on suoritettu
	064FDF0       0000000C         h:n arvo, eli 12
	064FDF4       0000000F         m:n arvo, eli 15
	064FDF8       00000037         lisa_min, eli 55

Muutetaanpa ohjelmaan parametrin välitys osoitteiden avulla:

c-muut\aikalis2.cpp - parametrin välitys osoittimilla

	#include <iostream.h>
	
	void lisaa(int *ph, int *pm, int lisa_min)
	{
	  int yht_min = *ph * 60 + *pm + lisa_min;
	  *ph = yht_min / 60;
	  *pm = yht_min % 60;
	}
	
	void tulosta(int h, int m)
	{
	  cout << h << ":" << m << endl;
	}
	
	int main(void)
	{
	  int h=12,m=15;
	  lisaa(&h,&m,55);
	  tulosta(h,m);
	  return 0;
	}

	lisaa(&h,&m,55);
	
	muistiosoite assembler         selitys
	-------------------------------------------------------------------------
	0040111D     push 0x37           pinoon 55
	0040111F     lea eax,[ebp-0x08]  m:osoite rekisteriin eax
	00401122     push eax            ja tämä pinoon (0064FDFC) 
	00401123     lea edx,[ebp-0x04]  h:n osoite rekisteriin edx
	00401126     push edx            ja tämä pinoon (0064FE00)
	00401127     call lisaa          mennään aliohjelmaan lisää
	0040112C     add esp,0x0c        poistetaan pinosta 12 tavua (2 x int)

	muistiosoite assembler         selitys
	------------------------------------------------------------------------
	0064FDEC      0040112C <-ESP   paluuosoite kun aliohjelma on suoritettu
	0064FDF0      0064FE00         h:n osoite,  eli ph:n arvo
	0064FDF4      0064FDFC         m:n osoite,  eli pm:n arvo
	0064FDF8      00000037         lisa_min, eli 55

	muistiosoite assembler         selitys
	-------------------------------------------------------------------------
	0040107C     push ebp            pinoon talteen rekisterin ebp arvo
	0040107D     mov  ebp,esp        ebp:hn pinon pinnan osoite
	0040107F     push ecx            pinoon tilaa yhdelle kokonaisluvulle (min)

	muistiosoite  sisältö          selitys
	------------------------------------------------------------------------
	0064FDE4  -04 00000000 <-ESP   aliohjelman oma tila, eli min-muuttuja
	0064FDE8  +00 0064FE04 <-EBP   vanha EBP:n arvo, johon EBP nyt osoittaa
	0064FDEC  +04 0040112C         paluuosoite kun aliohjelma on suoritettu
	0064FDF0  +08 0064FE00         h:n osoite,  eli ph:n arvo
	0064FDF4  +0C 0064FDFC         m:n osoite,  eli pm:n arvo
	0064FDF8  +10 00000037         lisa_min, eli 55

	*pm = yht_min % 60;
	
	muistiosoite assembler         selitys
	-------------------------------------------------------------------------
	004010A1     mov  eax,[ebp-0x04] eax:ään yht_min muuttujan arvo        
	004010A4     mov  ecx,0x0000003c ecx:ään 60 jakajaksi          
	004010A9     cdq                 konvertoidaan eax 64 bitiksi edx:eax      
	004010AA     idiv ecx            jaetaan edx:eax/ecx:llä tulos eax, jakoj. edx
	004010AC     mov  eax,[ebp+0x0c] eax:ään m:n osoite (eli pm:n arvo)
	004010AF     mov  [eax],edx      sinne muistipaikkaan, jonne eax asoittaa,
	                                 eli 0064FDFC, eli pääohjelman m:ään kopioidaan
	                                 edx, eli 10.  HUOM!  Pääohjelman m:n arvo
	                                 muuttui juuri tällä hetkellä!
	}                                aliohjelmasta poistuminen
	004010B1     pop  ecx            pinosta pois aliohjelman omat muuttujat
	004010B2     pop  ebp            alkuperäinen ebp:n arvo talteen
	004010B3     ret                 ja paluu osoitteeseen joko on pinon päällä nyt
	                                 eli 0040112C, eli pääohjelmaan call-lauseen
	                                 jälkeen

Takaisin asiaan. Nyt siis aliohjelmalla oli pelkkien 12,15,55 arvojen sijasta käytössä osoitteet pääohjelman h:hon ja m:ään sekä arvo 55. Näin aliohjelma pystyi muuttamaan kutsuneen ohjelman muuttujien arvoja. Sama kuvana ennen *pm- sijoitusta:

Tehtävä 8.73 aikalis3.cpp

Kirjoita aikalis2.cpp:stä viitemuuttujia käyttävä versio. Sisäisesti ohjelma kääntyy täsmälleen samanlaiseksi kuin osoittimilla, eli osoittimet ja viitemuuttujat ovat sisäisesti todellakin sama asia.

Tehtävä 8.74 Muotoilu?

Kokeilepa lisätä aikaan esimerkiksi 50 min. Mitä tulostuu? Miten vian voisi korjata?

Tehtävä 8.75 Tiedon lukeminen

Kirjoita aliohjelma lue, joka kysyy ja lukee arvon kellonajalle, syöttö muodossa 12:15.

8.6.5 Aliohjelmien kirjoittaminen

8.6.6 Globaalit muuttujat

c-muut\alisotku.c - parametrin välitystä

	/* 01 */ /* alisotku.c */
	/* 02 */ /* Mitä ohjelma tulostaa?? */
	/* 03 */ #include <stdio.h>
	/* 04 */
	/* 05 */ int a,b,c;
	/* 06 */
	/* 07 */ void ali_1(int *a, int b)
	/* 08 */ {
	/* 09 */   int d;
	/* 10 */   d  = *a;
	/* 11 */   c  = b + 3;
	/* 12 */   b  = d -  1;
	/* 13 */   *a = c -  5;
	/* 14 */ }
	/* 15 */
	/* 16 */ void ali_2(int *a, int *b)
	/* 17 */ {
	/* 18 */   int c;
	/* 19 */   c  = *a + *b;
	/* 20 */   *a = 9 -  c;
	/* 21 */   *b = 32;
	/* 22 */ }
	/* 23 */
	/* 24 */ int main(void)
	/* 25 */ {
	/* 26 */   int d;
	/* 27 */   a=1; b=2; c=3; d=4;
	/* 28 */   ali_1(&d,c);
	/* 29 */   ali_2(&b,&a);
	/* 30 */   ali_1(&c,3+d);
	/* 31 */   printf("%d %d %d %d\n",a,b,c,d);
	/* 32 */   return 0;
	/* 33 */ }

globaalit 

main

ali_1

ali_2

laskuja

*   

*   

*   

   lause  

 a 

 b 

 c 

  d 

  a 

 b 

 d 

  a 

  b 

 c 

27 a=1; b=2

 1 

 2 

 3 

  4 

28 ali_1(&d

&m.d

 3 

 ? 

ali_1(&m.d,3)

10 d = *a; 

 4 

= m.d = 4

11 c = b+3;

 6 

= 3+3 = 6

12 b = d-1;

 3 

= 4-1 = 3

13 *a= c-5;

  1 

 <-o

m.d = g.c-5 = 6-5 = 1

29 ali_2(&b

&g.b

&g.a

 ? 

ali_2(&g.b,&g.a)

19 c =*a+*b

 3 

= g.b+g.a = 2+1 = 3

20 *a= 9-c;

 6 

<-o

g.b = 9-3 = 6 

21 *b= 32; 

32 

<-o

g.a = 32

30 ali_1(&c

&g.c

 4 

 ? 

ali_1(&g.c,3+1)

10 d = *a; 

 6 

= g.c = 6

11 c = b+3;

 7 

= 4+3 = 7

12 b = d-1;

 5 

= 6-1 = 5

13 *a= c-5;

 2 

 <-o

g.c = c-5 = 7-5 = 2

31 printf("

Tulostus: 32 6 2 1

32 return 0

          ========= 

Tehtävä 8.76 Muuttujien näkyvyys

Pöytätestaa seuraava ohjelma:

c-muut\alisotk2.cpp - parametrin välitystä

	/* 01 */ /* alisotk2.c */ /* Mitä ohjelma tulostaa?? */
	/* 02 */ #include <stdio.h>
	/* 03 */
	/* 04 */ int b,c;
	/* 05 */
	/* 06 */ void s_1(int *a, int b)
	/* 07 */ {
	/* 08 */   int d;
	/* 09 */   d  = *a;
	/* 10 */   c  = b + 3;
	/* 11 */   b  = d -  1;
	/* 12 */   *a = c -  5;
	/* 13 */ }
	/* 14 */
	/* 15 */ void a_2(int *a, int &b)
	/* 16 */ {
	/* 17 */   c  = *a + b;
	/* 18 */   { int c; c = b;
	/* 19 */   *a = 8 * c; }
	/* 20 */   b = 175;
	/* 21 */ }
	/* 22 */
	/* 23 */ int main(void)
	/* 24 */ {
	/* 25 */   int a,d;
	/* 26 */   a=4; b=3; c=2; d=1;
	/* 27 */   s_1(&b,c);
	/* 28 */   a_2(&d,a);
	/* 29 */   s_1(&d,3+d);
	/* 30 */   printf("%d %d %d %d\n",a,b,c,d);
	/* 31 */   return 0;
	/* 31 */ }