Funkció a Kezdő
int sum (int n) // A paraméter kerül átvitelre a hívás helyek száma változó n
ha (n == 1) return 1; // ha az új érték 1, akkor majd tedd 1 helyett az előzőtől. mert korábbi - nulla. és hozzáadunk 1 + 0 lesz végtelen.
else return összege (n - 1) + N; // de ha n> 1, akkor hozzáadja az előző érték, összegével egyenlő az összes elem, hogy N
rendszer ( "CLS"); // világos képernyő
cout < Tekintsük a programot részletesebben. Ez egy fontos pillanat. Rekurzív fnktsii nem tudjuk, mikor hagyja abba maguk okoznak, így biztos, hogy írjon nekik olyan állapotban, hogy hagyja abba. Ebben a példában, az ilyen állapot egy elkövetkező egy paraméter n egységek. Ha n vett egyet, majd visszatért az egység, különben a függvény saját magát hívja. Itt ebben a pillanatban, és fontos, hogy utolérjék a pillanatot, és az úgynevezett rekurzív. Ahhoz, hogy működjön valami megfelelően figyelembe, először meg kell adni a belsejében a megfelelő értékeket. Nos, ha az érték egy bizonyos, de néha kell egy kis fonalat, és kiszámítja ezt az értéket kódot csak a számítási adni. Itt van egy számítása kódot itt-ott. És most megnézzük, mi történik: 1) n == 1. Utoljára létre egy példányt a kijárat. Ad 1. Összefoglalva, emlékszünk, hogyan kell megírni a programot. Rekurzív függvény belül maga utasította maga végzett, ami miatt a fordító, hogy hozzon létre egy másolatot ilyen funkciója, és végezze el a másolatot. Minden memóriában tárolt, és a fő élvezettel a folyamat a munka kezdődik a végrehajtása a legújabb létrehozott másolás funkció fokozatosan jön az eredeti funkció, ami a sok példányban is. Jó napot, uporotyh nem érti, hogy ez a funkció elvégzi a számítást Igen, szinte minden, mert tudtam (az utolsó bekezdés már látható a rekurzió))), de a kérdés továbbra is milyen az az összeg, akkor majd hajtott a képernyőn? (5) // A függvény adott 5, ellenőrizze az egyenlőség az identitással. nem egyenlő, akkor meghívja a függvényt újra, így ez 5-1 2-1 == 1, befejezte a hívót. Igen igen igen nem volt ideje, hogy írjon, megértettem, rendben, hogy nem rögtön rájött. Köszönöm a jó oldalon)) És kiderül, nem egészen logikus, a 8. sor változás, ha visszatér a visszatérés 1-2, az összeg változik 16 ez a feltétel kapcsolódik a 9. sorban?
Első írásos a fő funkció: int main (). Ez az üres programot C ++ nyelven íródott. Megírása után egy üres program kezdődik az írás egy rekurzív függvény. Ebben a példában, azt elemzi az új funkciót int összege (int n)
A funkció kiszámításához elemek összege. Egyszerűsítése take egészek. A funkció lenne valami, hogy fontolja ebben az esetben fog szolgálni hozzáadásával számokat. Az eredmény hozzáadjuk a funkciót kap, aminek eredményeként az erőfeszítéseiket. Ez az eredmény is felvette bármely kívánt pillanatban kívülről funkciókat. Mivel a néhány kiválasztott egész, az eredmény összege az egész - egy egész szám, így az eredmény iránt alkalmazzák olyan típusú beszélgetés funkció, akkor vissza az int.
Sum függvény elfogad minden számot. Engedje meg, hogy egynél nagyobb szám (ez a magyarázat), a funkció látja, hogy az egység nem jön n, és végrehajt egy példányát is. Létrehoz egy másik funkció, amely egyszerűen átmásolja a jelenlegi és vyponyaetsya magát. És ezért létrehoz egy példányt minden funkció. Öt hívások - öt példányban a funkciókat hoznak létre a memóriában egy adott időpontban.
Bent a funkció számát tekintve 5. A funkció hívják, és elkezdett dolgozni. n kapott 5, van egy csekket, hogy n, ahol kiderül, hogy n nem egy, így hát néhány számot. Ha emlékszel, mi választottuk az egész és a kapott eredmény is felvette bármely kívánt pillanatban kívülről funkciókat. Az eredmény vett megaskhozhey függvény valójában egy új funkció, hogy lesz egy másolatot a. Ez a funkció, ami nem másolat, még megkapja a munkát, ez vár annak fontosságát, hogy meg kell fizetni. Akkor feltételezhető, hogy ez nem egy másolat megfogta. Elindítja másolni. Nézze meg, mi ez jön ki, akkor jön a (n-1). Ahogy jön a 5-1, azaz 4. Az első funkció várja érték, egy példányt az első függvény egy készenléti állapotban kell várni a kiindulási értéket, amely vissza kell egy másolatot példányt. És így ismétlődik, amíg, amíg van 2-1, miért n fog jönni 1. Amint az n 1 jön, munka visszatérés utolsó létre abban az időpontban példányban. A jelenlegi program, rámutatott, hogy ha n 1 érkezik, akkor visszatér 1. Ezúttal megszűnése rekurzió elején a számítás. Ez annyira okos kerül sorra.
2) Előtte lóg memória másolás válik a legújabb. (Az egyes létrehozott példányt n értéke eggyel csökken, így most kezdik hozzá, volt 1, volt 2. A jelenlegi másolási n == 2). Ez utóbbi már egy példányát a hozamok (1) 2, ahol (1) - ez az egység, amely eredményeként hozott a kitöltött példányát. A képletekben bővíthető kb, mint: ((összege (n-1) + n) ==> (1 + n) ==> (1 + 2) ==> 3)
3) a folyamat megismétlődik. n == 3. ((sum (n-1) + n) ==> (3 + n) ==> (3 + 3) ==> 6)
4) a folyamat megismétlődik. n == 4. ((sum (n-1) + n) ==> (6 + n) ==> (6 + 4) ==> 10)
5) Az eljárást megismételjük. n == 5. ((sum (n-1) + n) ==> (10 + n) ==> (10 + 5) ==> 15)
1) Az írás egy üres blokk a fő program.
2) írása egy rekurzív függvény.
3) Hívja a rekurzív függvény a főprogram blokk.
ha (n == 1) return 1; // ha az új érték 1, akkor majd tedd 1 helyett az előzőtől. mert korábbi - nulla. és hozzáadunk 1 + 0 lesz végtelen.
else return összege (n-1) + N; // de ha n> 1, akkor hozzáadja az előző érték, összegével egyenlő az összes elem, hogy N
>
Tudomásom szerint, hogy 5 n nem egyezik azzal a feltétellel, ha az összeg kódot hajt végre (n-1) + n 5, hogy hozzá kell adni, hogy a levontuk a zárójelek de (5 - 1) 5, és ha igen, mi ez a megálló számtani művelet. Mi az előző érték, honnan származik, hogy ugyanaz.
Dolgozom Dev C ++ van ez például visszatér az összeget == 15, ha minősül írta például a kapott összeget más.
Írtam fent, ami figyelembe (5-1) = 5 + 4 + 5 = 9
És kiderül, nem egészen logikus, a 8. sor változás, ha visszatér a visszatérés 1-2, az összeg változik 16 ez a feltétel kapcsolódik a 9. sorban?
(+ 5-1 (5)) //.
(4-1 + (5-1 + (5)))
(3-1 + (4-1 + (5-1 + (5))))
(2-1 + (3-1 + (4-1 + (5-1 + (5)))))
(2-1 + (3-1 + (4-1 + (5-1 + (5))))) == 15
ez az eredmény.
Itt az eredménye a funkció - a különbség az első két szám, és n - a többi a jobb
__________________________________
Csak azt kell a megfelelő működéshez érthető és elfogadható, mint a számított érték, és nem gondolni rá, mint egy változó. Úgy néz ki, mint egy változó, de közelebb a számított állandó. bár állandó, és nem egyszerűen tartják sokkal kényelmesebb.
Ezzel is minden világos egyszerűen vissza 2 növeli az összeget úgy beszélni a nélkülözés Lucifer.Kapcsolódó cikkek