Oppaat: C++-ohjelmointi: Osa 3 - Ehdot, silmukat ja poikkeukset

if (luku % 2 == 1) std::cout << "Luku on pariton!" << std::endl;

if (luku >= 0 && luku <= 10 && luku % 2 == 1) {
	// Tähän päästään, jos ehto toteutuu.
	std::cout << "Luku on pariton ja välillä 0 - 10!" << std::endl;
	std::cout << "Kuinkas nyt suu pannaan?" << std::endl;
}
// Muuten hypätään suoraan tänne.

#include <iostream>

int main() {
	std::cout << "Pelataanpa jalkapalloa. Montako pelaajaa on?" << std::endl;
	int pelaajia;
	std::cin >> pelaajia;
	if (pelaajia < 6) {
		// Tähän päästään, jos luku on alle 6.
		std::cout << "Pelaajia on aika vähän!" << std::endl;
	} else if (pelaajia % 2 == 0 || pelaajia > 10) {
		// Nyt else-lohko koostuu vain yhdestä if-lauseesta.
		// Jos siis ensimmäinen ehto ei toteudu, kokeillaan tätä ehtoa:
		// parillinen määrä tai yli 10 pelaajaa.
		std::cout << "Näillä pelaajilla saadaan jo aika tasaiset joukkueet." << std::endl;
	} else {
		// Tämä on jälkimmäisen if-lauseen else-lohko, johon päästään,
		// jos toinenkaan ehto ei toteudu.
		std::cout << pelaajia << " pelaajaa riittää kyllä peliin." << std::endl;
		std::cout << "Toiselle puolelle jää kuitenkin yhden ylivoima." << std::endl;
	}
	// Kaikkien vaihtoehtojen jälkeen päädytään lopulta tänne.
}

#include <iostream>

int main() {
	// Ohjelmassa tarvitaan kaksi lukua ja laskutoimituksen merkki.
	double a, b;
	char toimitus;

	// Esitetään pyyntö ja luetaan syötteet.
	std::cout << "Anna kahden luvun lauseke, esim. 5 / 7." << std::endl;
	std::cin >> a >> toimitus >> b;

	// Tarkistetaan, onnistuiko lukeminen.
	if (!std::cin.good()) {
		// Ei onnistunut, lopetetaan ohjelma tähän ja palautetaan 1.
		std::cout << "Virhe lausekkeessa!" << std::endl;
		return 1;
	}
	// Tarkistetaan if-lauseilla, mikä lasku pitää tehdä, ja lasketaan se.
	if (toimitus == '+') {
		std::cout << "Tulos: " << (a + b) << std::endl;
	} else if (toimitus == '-') {
		std::cout << "Tulos: " << (a - b) << std::endl;
	} else if (toimitus == '*') {
		std::cout << "Tulos: " << (a * b) << std::endl;
	} else if (toimitus == '/') {
		std::cout << "Tulos: " << (a / b) << std::endl;
	} else {
		// Mikään aikaisempi lasku ei osunut, aina on jouduttu
		// else-lohkoon. Ilmoitetaan virheestä ja palautetaan 2.
		std::cout << "Tuntematon laskutoimitus!" << std::endl;
		return 2;
	}
}

// "switch (lauseke)" aloittaa switch-lauseen.
switch (luku) {
// "case arvo:" merkitsee kohdan, johon tietyllä muuttujan arvolla päädytään.
case 0:
	std::cout << "Luku on nolla!" << std::endl;
	// break hyppää ulos switch-lauseesta
	break;
case 1:
	std::cout << "Luku on yksi!" << std::endl;
	break;
// "default:" merkitsee kohdan niille arvoille, joille ei ole omaa paikkaa.
default:
	std::cout << "Luku on " << luku << "!" << std::endl;
}

if (luku == 0) {
	std::cout << "Luku on nolla!" << std::endl;
} else if (luku == 1) {
	std::cout << "Luku on yksi!" << std::endl;
} else {
	std::cout << "Luku on " << luku << "!" << std::endl;
}

#include <iostream>

int main() {
	std::cout << "Mistä asti pitäisi laskea kolmeen?" << std::endl;
	int alku;
	std::cin >> alku;
	switch (alku) {
	default:
		std::cout << "Vai että " << alku << "? Taidanpa aloittaa ykkösestä." << std::endl;
		// Koska break puuttuu, suoritus jatkuu...
	case 1:
		std::cout << "Yksi..." << std::endl;
	case 2:
		std::cout << "Kaksi..." << std::endl;
	case 3:
		std::cout << "Kolme! Laskettu." << std::endl;
		// Vasta break-riviltä hypätään switch-rakenteen loppuun.
		break;
	case 4:
		// Tänne päästään vain, jos alku == 4.
		std::cout << "Nelonenhan tulee kolmosen jälkeen!" << std::endl;
		// Lopussa ei tarvita break-riviä.
	}
}

int a = 1, b = 2, c = 3;
// jos a < 10, d = b, muuten d = c;
int d = (a < 10 ? b : c);
// lasketaan itseisarvo lausekkeen keskellä
std::cout << "Luvun " << d << " itseisarvo on " << (d < 0 ? -d : d) << std::endl;

#include <iostream>

int main() {
	const int luku = 10;
	int arvaus;
	std::cout << "Arvaa luku!" << std::endl;
	std::cin >> arvaus;
	while (luku != arvaus) {
		if (luku < arvaus) {
			std::cout << "Luku on pienempi!";
		} else {
			std::cout << "Luku on suurempi!";
		}
		std::cout << " Arvaa uudestaan." << std::endl;
		std::cin >> arvaus;
	}
	std::cout << "Arvasit oikein, luku oli " << luku << "." << std::endl;
}

#include <iostream>

int main() {
	const int luku = 10;
	int arvaus;
	do {
		std::cout << "Arvaa luku!" << std::endl;
		std::cin >> arvaus;
		if (luku < arvaus) {
			std::cout << "Luku on pienempi!" << std::endl;
		} else if (luku > arvaus) {
			std::cout << "Luku on suurempi!" << std::endl;
		}
	} while (luku != arvaus);
	std::cout << "Arvasit oikein, luku oli " << luku << "." << std::endl;
}

for (int i = 0; i < 10; ++i) {
	std::cout << i << std::endl;
}

// Jos silmukassa on vain ehto, se vastaa täysin while-silmukkaa.
for (; i < 10;) { }
while (i < 10) { }

// Ilman ehtoa silmukasta tulee ns. ikuinen silmukka.
for (;;) { }
for (; true;) { }
while (true) { }

for (alku; ehto; loppu) {
	koodi;
}

{
	alku;
	while (ehto) {
		koodi;
		loppu;
	}
}

#include <iostream>

int main() {
	double kanta;
	int eksponentti;
	std::cout << "Anna kantaluku ja kokonaiseksponentti: ";
	std::cin >> kanta >> eksponentti;

	// 0 potenssiin 0 on määrittelemätön, joten käsitellään se erikseen.
	if (kanta == 0 && eksponentti == 0) {
		// Tulostetaan virheilmoitus ja lopetetaan ohjelma.
		std::cout << "Laskulle ei ole tulosta!" << std::endl;
		return 0;
	}

	// Lasketaan negatiivinen potenssi käänteisluvun avulla.
	// n**(-e) = (1/n)**e, missä ** on potenssilasku.
	if (eksponentti < 0) {
		eksponentti = -eksponentti;
		kanta = 1 / kanta;
	}

	// Nollas potenssi on aina yksi.
	double tulos = 1;

	// Eksponentti määrää, montako kertaa kantaluku pitää kertoa.
	for (int i = 0; i < eksponentti; ++i) {
		tulos *= kanta;
	}

	std::cout << "Potenssilaskun tulos on " << tulos << std::endl;
}
/**
 * Tehtävä:
 * Keksitkö, miten potenssifunktiota saisi parannettua niin, että silmukassa
 * ei tarvitsisi suurellakaan eksponentilla kiertää kuin muutama kierros?
 *
 * Vihje: a**9  ==  a * a**8  ==  a * (((a**2)**2)**2)
 */

#include <iostream>

int main() {
	const int luku = 10;
	while (true) {
		std::cout << "Arvaa luku!" << std::endl;
		int arvaus;
		std::cin >> arvaus;
		if (luku < arvaus) {
			std::cout << "Luku on pienempi!" << std::endl;
			continue;
		}
		if (luku > arvaus) {
			std::cout << "Luku on suurempi!" << std::endl;
			continue;
		}
		std::cout << "Arvasit oikein, luku oli " << luku << "." << std::endl;
		break;
	}
}

if (int luku = 10) {
	koodi;
}

{
	int luku = 10;
	if (luku) {
		koodi;
	}
}

#include <iostream>

// Aivan kuten tulostusta (std::cout yms.) varten tarvitaan iostream-otsikko,
// matemaattisia funktioita (sqrt eli neliöjuuri, pow eli potenssilasku yms.)
// varten tarvitaan cmath-otsikko. Esimerkissä käytetään funktioita std::floor
// ja std::pow.
#include <cmath>

int main() {
	double a, b;
	char m;
	try {
		std::cout << "Kirjoita lasku, esim. 1.4 / 2.2." << std::endl;
		std::cin >> a >> m >> b;
		if (!std::cin.good()) {
			// Suoritus siirtyy throw-riviltä sopivaan catch-lohkoon.
			throw "viallinen syöte";
		}
		std::cout << a << ' ' << m << ' ' << b << std::endl;
		switch (m) {
			// Palautetaan laskun tulos heittämällä.
			// Tämä ei ole hyvä ohjelmointitapa!
			case '+': throw a + b;
			case '-': throw a - b;
			case '*': throw a * b;
			case '/':
				// Virhetilanteissa heitetään virheteksti.
				// Tämä on järkevä tapa käyttää poikkeuksia.
				if (b == 0) {
					throw "jakaja on nolla";
				}
				throw a / b;
			case '^':
				if (a == 0 && b == 0) {
					throw "nolla potenssiin nolla, määrittelemätön";
				}
				// std::floor pyöristää luvun alaspäin
				if (a < 0 && std::floor(b) != b) {
					throw "negatiivinen luku ja desimaalieksponentti";
				}
				// std::pow(a, b) laskee laskun a potenssiin b.
				throw std::pow(a, b);
			default:
				throw "tuntematon lasku";
		}
		// Suoritus siirtyy try-lohkon lopusta rakenteen loppuun,
		// eli seuraava suoritettava rivi on lopun tulostusrivi.
	} catch (double vastaus) {
		// Otetaan double-arvo kiinni.
		// Tätä nyt käytettiin vastauksen toimittamiseen.
		std::cout << "Tulos: " << vastaus << std::endl;
		// Suoritus siirtyy catch-lohkosta rakenteen loppuun,
		// eli seuraava suoritettava rivi on lopun tulostusrivi.
	} catch (const char* teksti) {
		// Otetaan tekstivakio eli const char* kiinni.
		// Tulostetaan virheilmoitus ja lopetetaan. Kun main-funktiossa
		// suoritetaan return-lause, koko ohjelma sulkeutuu.
		// Paluuarvo 1 viestii, että ohjelmassa on tapahtunut virhe.
		std::cout << "Virhe: " << teksti << std::endl;
		return 1;
	} catch (...) {
		// Tämä käsittelijä käsittelee poikkeukset, jotka eivät
		// sopineet muiden käsittelijöiden tyyppeihin.
		std::cout << "Tuntematon virhe tuntemattomasta lähteestä!" << std::endl;

		// Poikkeuksen voi aina heittää eteenpäin tyhjällä throw'lla.
		// Jos try-lohkoja on monta sisäkkäin, sopivaa käsittelijää
		// etsitään seuraavaksi ulommista try-lohkoista.
		// Nyt ollaan kuitenkin uloimmassa (ainoassa) try-lohkossa,
		// joten ohjelman suoritus päättyisi virheeseen. Tänne ei
		// kuitenkaan tässä ohjelmassa jouduta, koska kaikki heitetyt
		// poikkeukset ovat double- tai const char* -tyyppisiä.
		throw;
	}
	std::cout << "Jos haluat laskea lisää, aja ohjelma uudestaan." << std::endl;
}

#include <iostream>

int main() {
	// Taulukko; näistä kerrotaan lisää myöhemmin.
	int taulu[10][10] = {{0}, {0, 0, 13}};

	int i, j;
	for (i = 0; i < 10; ++i) {
		for (j = 0; j < 10; ++j) {
			// Verrataan taulukon lukua kohdassa (i, j) lukuun 13.
			if (taulu[i][j] == 13) {
				// Hypätään pois, jos luku on 13.
				goto loytyi_13;
			}
		}
	}
	// Tämä ehtolause on aina epätosi.
	if (false) {
		// Sisään pääsee kuitenkin hyppäämällä.
		loytyi_13:
		std::cout << "Luku 13 löytyi kohdasta (" << i << ", " << j << ")!" << std::endl;
	}
}