Cyklus for – Java – Fórum – Programujte.com

/*Vytvorenie triedy Moc  ktora vypocita vysledok umocneneho cisla nejakym celym cislom   */
class Moc{
	double z;
	int e;
	double hodn;
	
	Moc(double zaklad, int exp){
		z = zaklad;
		e = exp;
		hodn = 1;
		if(exp == 0) return;
		for( ; exp > 0; exp--) hodn = hodn * zaklad;    /* Moze mi prosim vas niekto 
		                                                   vysvetlit tento riadok ?
		                                                   Dakujem  
		                                                */
	}
	double zjisti_moc(){
		return hodn;
	}
}
public class UkazMoc {

	public static void main(String[] args) {
		Moc x = new Moc(4.0, 2);
		
		System.out.println(x.z + " umocnene cislom " + x.e + " sa rovna "
		+ x.zjisti_moc());

	}

}

for(
;      //neni zadny prikaz, pred vstupem do cyklu se neprovede nic
exp > 0;   //ukoncovaci podminka cyklu, cyklus se provadi dokud je exp > 0
exp--      //pri kazde iteraci cyklu se exp zmnesi o 1
) hodn = hodn * zaklad; //v tele cyklu je jediny prikaz

mocninu spočítáš takto:
a^2 = a*a
a^5 = a*a*a*a*a
atd.

... a to dělá ten cyklus.

hu

#2 hlucheucho
Rozumiem cyklu for len mi nejde do hlavy ak hodnota  = 1. Zaklad dajme ze sa rovna 4 . A exp rozumiem tomu ze je ako umocnovatel   jemu pridelim hodnotu napr. 2 .
prikaz:

hodn = hodn * zaklad   // hodn = 1;

                                    // zaklad = 4;

//Ako sa umocni ta 4 na druhu ked to nieje vo vzorci ?   

Před vstupem do cyklu je hodn = 1. To odpovídá mocnině v případě, že exp = 0. Dále 1 je z pohledu násobení neutrální, číslo násobeno jedničkou je číslo samé. V cyklu se hodn násobí základem a uloží se zpět do hodn tolikrát, kolik je exponent. Takže pokud je exponent 1, proběhne 1 iterace cyklu, 1x se provede hodn = hodn * zaklad - výsledek je hodn = 1*základ. Podobně to je pro exp =  např 3 - proběhnou 3 iterace cyklu:
1. nyní je hodn = 1, provede hodn = 1*základ
2. nyní je hodn = základ, provede se hodn = zaklad*zaklad
3. nyní je hodn = zaklad*zaklad, provede se hodn = (zaklad*zaklad) * zaklad

Vždy je v hodn výsledek součinu po předchozí iteraci cyklu, cyklus začne první mocninou a dekrementuje exp, v další iteraci ji vynásobí základem - vznikne druhá mocnina a dekrementuje exp, tu v další iteraci násobí základem - vznikne třetí mocnina a dekrementuje exp .... až po okamžik, kdy vznikne požadovaná mocnina, v tu chvíli exp dosáhne hodnotu 0 a cyklus je ukončen.

Cyklus s dekrementací je šikovnější, nepotřebuje vytvářet další proměnnou jako řídící proměnnou cyklu a uvádí se, že dekrementace je rychlejší než inkrementace. Cyklus s inkrementací by vypadal takto:

for(int i = 0; i < exp; i++) hodn = hodn * zaklad;

hu

#4 hlucheucho
Dakujem velmi pekne