Späť na blog
Tipy a triky

Ako zistiť, či je číslo zadané zo vstupu prvočíslom?

Skillmea
16.10.2019
9 minút čítania
Ako zistiť, či je číslo zadané zo vstupu prvočíslom?
V 15. kapitole online kurzu vyššieho programovacieho jazyka C++ úrovne Elementary II nájdete medzi zadaniami praktických príkladov na domáce precvičenie aj úlohu, v ktorej máte nájsť najväčší spoločný deliteľ dvoch čísel a taktiež úlohu, v ktorej máte nájsť najmenší spoločný násobok dvoch čísel alebo ich najväčší spoločný deliteľ. Ak siahnete do osnov matematiky druhého stupňa základnej školy niekde do 6. alebo 7. ročníka, zistíte, že kľúčom k vyriešeniu týchto dvoch úloh je rozklad obidvoch čísel na súčin prvočísel.
Úlohy patria z hľadiska logiky a analytického myslenia medzi začiatočnícke. Napriek tomu viem, že sú náročnejšie. Práve preto som sa rozhodol napísať tento blog. 
V tomto blogu nechcem riešiť túto úlohu za vás, ale aspoň by som vám rád podal návod, ako zistiť, či je načítané číslo zo vstupu prvočíslom. Táto úloha je jedna z čiastkových úloh, ktoré je potrebné riešiť pri dvoch spomenutých príkladoch, ktorých riešenie ste dostali za úlohu nájsť. 
Tí, ktorí zabudli, čo je prvočíslo, ozrejmím aj tento pojem. Prvočíslo je celé kladné číslo, ktoré je deliteľné len jednotkou a svojou vlastnou hodnotou. Budeme sa teda pohybovať iba v množine kladných celých čísel. Príkladom prvočísla môže byť napr. číslo 5, pretože je deliteľné len číslom 1 a 5. ďalšími príkladmi sú 2, 3, 7, 11, 13, 17 atď. Samotné číslo 1 sa za prvočíslo nepovažuje. Povedzme, že máme číslo 60, jeho rozklad na súčin prvočísel je 2 x 2 x 3 x 5. Už z rozkladu je zrejmé, že ho môžeme vynásobiť číslom 1, nič by to totiž nezmenilo na výsledku, stále by ste dostali číslo 60. Vidíte, a práve preto sa matematici dohodli, že 1 prvočíslom nebude, nemá totiž už žiadny vplyv v súčine prvočísel, ktorého výsledkom je nejaké číslo. Takže bez zbytočných ďalších prázdnych fráz prejdem rovno k veci. Nasleduje teda zdrojový kód v jazyku C++, ktorý rieši titulok tohto blogu:
01:  #include <iostream>
02:  using namespace std;
03:
04:  int main()
05:  {
06:     int iNumb;
07:
08:     cout << "Zadaj lubovolne cele kladne cislo: ";
09:     cin >> iNumb;
10:     cout << endl;
11:
12:     bool flag = true;
13: 
14:     if (iNumb == 1)
15:     {
16:         flag = false;
17:     }
18:     else
19:     {
20:         for (int i = 2; i <= iNumb / 2; i++)
21:        {
22:            if (iNumb % i == 0)
23:            {
24:                flag = false;
25:                break;
26:            }
27:         }
28:     }
29:
30:     if (flag)
31:     {
32:         cout << "Cislo " << iNumb << " je prvocislo !" << endl;
33:     }
34:     else
35:     {
36:         cout << "Cislo " << iNumb << " nie je prvocislo !" << endl;
37:     }
38:
39:     cout << endl;
40:
41:     cin.get();
42:     cin.get();
43:
44:     return 0;
45:  }

Na riadku 01 je uvedená direktíva preprocesora #include, ktorej parametrom je štandardná knižnica iostream. Potrebujeme ju z dôvodu používania objektov cout, cin a manipulátora endl. Na riadku 02 uvádzame do platnosti menný priestor std pre celý zdrojový súbor .cpp. Spomenuté objekty cout, cin a manipulátor endl je zároveň súčasťou tohto priestoru. Na riadku 04 je uvedená funkcia main aj so svojim návratovým typom, ktorým je int (integer). Túto funkciu volá operačný systém. Na riadku 05 je uvedená ľavá programová zátvorka, ktorou sa začína telo funkcie main. Na riadku 06 je deklarovaná premenná iNumb na údajový typ int. Táto premenná reprezentuje hodnotu celého kladného čísla, o ktorom chceme zistiť, či patrí medzi prvočísla. Na riadku 08 je pomocou objektu cout zapísaný na výstup konzolovej aplikácie textový reťazec, ktorý vyzve používateľa na zadanie hodnoty kladného celého čísla, ktorého vlastnosť prvočísla testujeme. Na riadku 09 je prostredníctvom objektu cin načítaná táto hodnota do premennej iNumb. Na riadku 10 je prostredníctvom objektu cout a manipulátora endl presunutý kurzor konzolovej aplikácie na ďalší riadok. Na riadku 12 je deklarovaná premenná flag a zároveň inicializovaná na hodnotu true. Táto premenná nám bude po otestovaní načítaného čísla ukladať informáciu, či je číslo prvočíslom alebo nie. Z hľadiska logiky algoritmu je nutné premennú flag inicializovať pred testovaním na hodnotu true. Algoritmom budeme totiž testovať, či načítané číslo medzi prvočísla nepatrí. Používa sa tu teda postup vylučovací. Na riadku 14 je testovaná podmienka, či v premennej iNumb nie je hodnota 1. Ak áno, program pokračuje kladnou vetvou a do premennej flag sa na riadku 16 zapíše hodnota false, ktorá reprezentuje stav, kedy načítané číslo prvočíslom nie je. Na riadku 13 a 15 sú len uvedené programové zátvorky, ktoré uzatvárajú blok kódu uvedený v kladnej vetve. Ak spomínaná podmienka splnená nie je, pokračuje sa zápornou vetvou. Blok kódu v zápornej vetve uzatvorený programovými zátvorkami na riadkoch 19 a 29. Na riadku 2027 je uvedené jadro algoritmu, ktorý testuje vlastnosť prvočísla u čísel väčších ako 1. 
A v čom spočíva idea jadra algoritmu ? V každej iterácii cyklu zisťujeme, či je číslo deliteľné hodnotou v premennej i. Najmenšie číslo, ktorým môže byť načítané testované deliteľné, je číslo 2 (viď. riadok 20 – for slučka) a preto iterujeme od tejto hodnoty. Premennú i postupne inkrementujeme (viď. riadok 20 – for slučka) a testujeme, či je hodnota premennej iNumb deliteľná bez zvyšku pomocou operácie modulo na riadku 22, ktorá je umiestnená v príkaze if. Ak je číslo deliteľné hodnotou v premennej i bez zvyšku, tak sa na riadku 24 uloží do premennej flag hodnota false, čo reprezentuje stav, kedy načítané číslo nie je prvočíslom. Premenná i sa inkrementuje po iNumb / 2 (viď. riadok 20 – for slučka). Dôvodom je fakt, že žiadne celé kladné číslo nemôže byť predsa deliteľné bez zvyšku číslom väčším ako je jeho polovica. 
Ak sa teda nenájde číslo, ktorým je načítaná hodnota testovaného čísla deliteľná bez zvyšku, neuloží sa do premennej flag hodnota false, čiže po ukončení v nej bude uložená hodnota true, čo reprezentuje stav, kedy je načítané testované číslo prvočíslom. Na riadku 25 je uvedené kľúčové slovo break a to z toho dôvodu, že v prípade nájdenia jedného čísla, ktoré delí načítané testované číslo bez zvyšku, nie je nutné hľadať ďalšie delitele. Testované číslo už prvočíslo totiž byť nemôže a preto násilne ukončíme slučku for, urýchlime program, ktorý následne prejde až na riadok 30. Tu sa už len testuje hodnota v premennej flag. Ak je v tejto premennej uložená hodnota true, tak sa zapíše na výstup konzolovej aplikácie pomocou objektu cout informácia o tom, že je načítané testované číslo prvočíslom (viď. riadok 32), ak false tak informácia, že prvočíslom nie je. 
Na riadku 41 a 42 je už len načítavaný vstup z konzolovej aplikácie pomocou objektu cin, čo slúži na to, aby sa hneď program neukončil a bol zobrazený výsledok v okne konzole, pokým používateľ nezatlačí ľubovoľná kláves. Na riadku 44 vracia funkcia main operačnému systému hodnotu 0, ktorá indikuje stav správneho ukončenia aplikácie. Na riadku 45 je ukončené telo programu pravou programovou zátvorkou. Algoritmus, ktorý som navrhol a implementoval v jazyku C++ nie je ešte optimálny. Je však pre účely kurzu úrovne začiatočník postačujúci. Medzi prvočíslami sa dajú ešte sledovať určité vlastnosti, nebudem ich však tomto bloku spomínať, aby som príliš poslucháča úrovne začiatočník zbytočne nadmerne nezaťažil. Optimálny algoritmus však budem ešte publikovať a rozoberať v ďalšom bloku a v kurze, ktorý bude zameraný aj na matematiku.

Autorom blogu je Marek Šurka, lektor online kurzov jazyka C++ na Learn2Code
Skillmea
🥇 Sme jednotka v online vzdelávaní na Slovensku.
Na našom webe nájdeš viac ako 300 rôznych videokurzov z oblastí ako programovanie, tvorba hier, testovanie softwaru, grafika, UX dizajn, online marketing, MS Office a pod. 
Vyber si kurz, ktorý ťa posunie vpred ⏩

Mohlo by ťa zaujímať

Lambda výrazy v Jave - časť III.
Tipy a triky
03.10.2019
Skillmea

Lambda výrazy v Jave - časť III.

Lambda a vnútorné anonymné triedyVeľmi sa nám žiada povedať, že lambda výrazy sú len skratky ako napísať vnútorné anonymné triedy. Ale pamätaj si, nie je to tak. Vyzerá to podobne ale lambda nie je implementácia rozhrania. Lambda je sama osobe nezávislá iná vec.   Pozrime sa na príklad. Namiesto toho aby sme použili implementačnú triedu nášho rozhrania IHelloWord, vytvoríme si vnútornú anonymnú triedu. IHelloWord helloWord3 = new IHelloWord() { @Override public void sayHello() { System.out.println("HelloWord impls inner anonymous class"); } };Všetky 3 možnosti, ktoré majú ako návratovú hodnotu rozhranie IHelloWord môžeme podsunúť do metody printHelloWord(IHelloWord helloWord). helloWord.printHelloWord(helloWord1); helloWord.printHelloWord(helloWord2); helloWord.printHelloWord(helloWord3); Ako to, ako to? Ako java vie, aký má použiť typ pre lamba výraz? Aby sme tomu porozumeli, vytvoríme si novú triedu, kde budeme pracovať s lambda výrazom. Vytvorme si rozhranie, ktoré bude mať jednu metódu, ktorá bude vracať int a na vstupe bude tiež int. interface Nasob{ int nasob(int a); } Ako by vyerala implementácia tohto rozhrania? class NasobPiatimi implements Nasob{ public int nasob(int a){ return a*5; } }Teraz si navrhnime lambda výraz, ktorý zodpovedá danej metóde. Nepotrebujeme návratovú hodnotu int, lebo java vie na ňu prísť sama a nepotrebujeme ani názov metódy a ani modifikátor prístupu public. Náš lambda výraz bude vyzerať takto: (int a) -> a*5;Teraz použime tento lambda výraz: public static void main(String[] args) { Nasob nasobPiatimi = (int a) -> a*5; System.out.println(nasobPiatimi.nasob(10)); }Na výstupe bude 50. V tomto príklade sa lambda tvári ako instancia rozhrania Nasob. V predchádzajúcich príkladoch, keď sme používali HelloWord sme takúto premennú vkladali ako parameter metódy printHelloWord (HelloWord3 v IDEi). Namiesto toho sme mohli túto lambdu vložiť priamo do metódy. helloWord.printHelloWord(() -> System.out.println("HelloWord impls lambda");); Java kompilátor vezme tento lambda výraz a pozrie sa kam ide. Ide to metódy printHelloWord a pozrie sa, čo akceptuje na vstupe. Akceptuje rozhranie HelloWord. Ak lambda sedí s požiadavkou, že dané rozhranie obsahuje len jednu metódu a tá vracia void a na vstupe nemá žiaden parameter, tak java povie, že daná lambda je typu HelloWord. Toto sa volá Type inference. Java si sama zistí typ. Teraz, keď vieš ako java dokáže zistiť typy, vrátime sa ku príkladu, ktorý sme začali písať v tejto kapitole. V našom príklade vieme ešte viacej skrátiť zápis nášho lambda výrazu. Nasob nasobPiatimi = (int a) -> a*5; System.out.println(nasobPiatimi.nasob(10));Keďže naša lamba ide do metódy rozhrania, ktorú poznáme interface Nasob{ int nasob(int a); } Tak vieme presne povedať aký typ má vstupný paramter metódy. Je to int. interface Nasob{ int nasob(int a); }Keď to vieme, tak nemusíme pri písaní lambda výrazu znovu špecifikovať typ vstupného parametru. Nasob nasobPiatimi = (a) -> a*5; A keďže máme len jeden parameter, nemusíme písať ani zátvorky. Nasob nasobPiatimi = a -> a*5; Už nebudeme nič mazať, lebo by nám už nič neostalo 😃 Teraz môžeme napísať metódu, ktorá bude na vstupe očakávať rozhranie Nasob a keď ju použijeme, tak do nej vložíme na vstup náš lambda výraz. public static void printNasob(Nasob nasob){ System.out.println(nasob.nasob(10)); } public static void main(String[] args) { printNasob(a -> a*5); }V jave mohli kľudne vytvoriť nový typ pre tieto lambda výrazy. Ale nespravili to a jedným z dôvodov je aj spätná kompatibilita so starším kódom. Ako už vieme, tak lambda výrazy môžeme použiť všade tam, kde máme vyhovujúce rozhranie. Vo vnútorných anonymných triedach, v metódach kde je na vstupe interface a podobne. Príklad: HelloWord helloWord3 = new HelloWord() { @Override public void sayHello() { System.out.println("HelloWord impls inner anonymous class"); } }; HelloWord helloWord3 = () -> System.out.println("HelloWord impls inner anonymous class"); Pri tomto musíme pamätať, aby rozhrania boli jedno metódové alebo aby ostatné metódy rozhrania boli default. A dané metódy v rozhraniach, aby sa zhodovali s lambda výrazom. Takéto rozhranie s jednou abstraktnou metódou (metóda, ktorá poskytuje opis nie implemntáciu) sa nazýva Functional interface. Predstav si, že používaš rozhranie, ktorý má len jednu metódu a používaš ho pre lambda výrazy. Teraz by niekto cudzí prišiel a do tohto rozhrania by pridal ďalšiu abstraktnú metódu, presnejšie jej opis bez implementácie. Takéto rozhranie by už viac nebolo functional interface a preto by sa nemohlo použiť pre lambda výraz a nastala by chyba – napriek tomu, že rozhranie by bolo v poriadku. Treba na to myslieť a ak chceme niečo pridať do functional interfac, tak len ako default metódy. Aby sme upozornili kohokoľvek, kto by chcel niečo pridať do nášho rozhrania, tak máme možnosť pridať anotáciu @FunctionalInterface. K anotáciam sa ešte dostaneme, tak sa nebojte. Teraz je dôležité vedieť, že je to pomôcka – táto pomôcka nám spraví to, že hneď ako napíšeme ďalšiu metódu do nášho rozhrania, tak nastane chyba. Danú anotáciu nemusíme písať, ale je to super. @FunctionalInterface public interface HelloWord { void sayHello(); }Príklady na vyskúšanie: 1. vytvor si zoznam miest  2. zotrieď zoznam  3. napíš metódu, ktorá vypíše všetko zo zoznamu miest  4. urob si metódu, ktorá vypíše len tie mestá, ktoré sa skladajú z jedného slova nepoužívaj pri tom lambda výrazy Pokračovanie nabudúce 👋 Články a online kurzy o Jave pre teba pripravuje Jaro Beňo.
Lambda výrazy v Jave - časť II.
Tipy a triky
23.08.2019
Skillmea

Lambda výrazy v Jave - časť II.

Typy lambda výrazovTento článok je pokračovaním prvej časti tutoriálu o Lambda výrazoch. Vráťme sa k nášmu príkladu na začiatku, kde sme do metódy vložili implementáciu rozhrania a zavolali sme metódu. Toto si teraz skúsime spolu prerobiť, tak aby sme použili lamba výraz.  HelloWord2.  Prepíšme metódu implementácie na lambda výraz. public void sayHello() { System.out.println("HelloWord impls"); } () -> System.out.println("HelloWord impls"); Znovu tá istá otázka, aký typ má lamba výraz ak ho chcem priradiť do premennej?  lambdaFunkcia = () -> System.out.println("HelloWord impls");Počkať! V Jave predsa máme možnosť ako deklarovať, vymenúvať metódy a tú použijeme. Tou možnosťou je použiť rozhrania.  1. vytvorenie rozhrania s jednou deklaráciou metódy  2. vytvorenie metódy, ktorá odpovedá našemu lambda výrazu  1. v našom prípade nemá žiadne argumenty a návratová hodnota je void  Ak by sme vytvorili rozhranie, kde budeme uvádzať viacero metód, tak to bude chyba. Jedine ak budú default – teda implementované. Viď sekciu o rozhraniach.  ILambda lambdaFunkcia = () -> System.out.println("HelloWord impls"); … public interface ILambda { void metoda(); // void metoda2(String s); // bude error } Použime lambda výraz s bezpečným delením. Napíšme si k tomu interface a premennú: bezpecneDelenieFunkcia = (int a, int b) -> { if(b==0) { return 0 ; } return a/b; }; public static void main(String[] args) { Hocijako hocijako = (int a, int b) -> { if(b==0){ return 0; } return a/b; }; double d = hocijako.hocico(10, 2); System.out.println(d); } interface Hocijako{ double hocico(int x, int y); }Tu si môžeme povedať, že názov rozhrania a názov metódy v rozhraní nie je dôležitý. Dôležité je, aby sedeli vlastnosti. Teda rozhranie má len jednu metódu (mimo default metód) a metóde sedí typ návratovej hodnoty a parametre metódy. Implemetačnú triedu už teda nepotrebujeme, lebo akoby implementáciou je lambda výraz. Môžem si to nechať, ak to potrebujem takto používať, ale v našom prípade nepotrebujem implementačnú triedu.  Lambda výraz sa správa ako implemtnácia rozhrania. Ale nie je to implementácia. Tento príklad bude fungovať:  HelloWord3 helloWord = new HelloWord3(); IHelloWord helloWord1 = new HelloWordImpl(); IHelloWord helloWord2 = () -> System.out.println("HelloWord impls lambda"); helloWord1.sayHello(); helloWord2.sayHello();Na výstupe bude:  HelloWord impls  HelloWord impls lambda Pokračovanie nabudúce 😗 Mrkni zatiaľ moje kurzy o Java programovaní alebo videá, ktoré máme na Youtube o Lambda výrazoch: https://www.youtube.com/watch?v=tzSFOgnDZZo&list=PL5dKLQR6-HyU7jyoTuZGFmPLAEFpIumi4
Tipy, triky a chyby v jazyku C++ pre začiatočníkov
Tipy a triky
04.08.2019
Skillmea

Tipy, triky a chyby v jazyku C++ pre začiatočníkov

Týmto článkom by som vám chcel predstaviť zaujímavé tipy a triky v jazyku C++, ktoré by ste mohli použiť vo vašom kóde. Sú veľmi jednoduché, pretože sú určené pre začiatočníkov. Navyše by som vás chcel upozorniť na niektoré často sa opakujúce chyby, ktoré sa vo vašom kóde môžu na začiatku vyskytovať. Nejedná sa o chybu v pravom zmysle slova, teda nie takú, po ktorej by bol váš kód nepreložiteľný, skôr sa jedná o obrúsenie vášho programátorského štýlu, či vytvorenie takého kódu, ktorý bude rýchlo vykonávaný. Poslednú spomínanú vlastnosť dosiahnete s C++ ľahko, pretože kódy, ktoré navrhnete v C++ sa vykonajú oveľa rýchlejšie ako tie, ktoré navrhnete v iných jazykoch. Viem programovať vo viacerých jazykoch a preto to mám skutočne odskúšané. Pamätajte, že C++ to však nevykoná za vás, pretože aj tam sa dá vytvoriť veľmi špatný kód. Zámerne so použil termín špatný, hoci nie je odborný. Myslím tým kód, v ktorom zlým štýlom a technikou nedosiahnete požiadavky, ktoré sa na kód kladú. Príkladom môže byť práve rýchlosť vykonávania spustiteľného kódu, jeho prehľadnosť, či ľahká udržiavateľnosť. V nasledujúcich riadkoch vám to na pár príkladoch ozrejmím. Príklady tipov, trikov a chýbUrčite ste sa už v programovaní pokúšali naprogramovať jednoduché matematické operácie. Majme teda nasledovný kód: #include <iostream> int main() { int a; int b = -1; int c; int d = 4; int e = 2; int f = 3; int g; a = b + c; d = e - f; g = a * d; std::cout << "g = " << std::endl; std::cin.get(); std::cin.get(); return 0; }Najprv by som sa vás chcel spýtať, či sa vám takto napísaný kód na prvý pohľad páči. Myslím tým po koncepčnej stránke. Prvou chybou je, že začínajúci programátori neodsadzujú bloky kódu. Tak napríklad tento kód by sa dal pekne odsadiť pomocou nasledujúcich pravidiel. Oddeľte direktívy preprocesora od hlavičky funkcii main(). Oddeľte deklarácie a definície premenných od zvyšku kódu. Niekedy, keď budete používať veľa premenných, môžete aj jednotlivé deklarácie premenných usporiadať do logických celkov. Môžete vytvoriť bloky kódu podľa typu premennej. Navyše, jazyk C++ vám umožňuje deklarovať a inicializovať premennú namieste, kde to skutočne potrebujete, čiže predtým, ako ju použijete. Ďalej, v tomto kóde oddeľte nosnú časť kódu a to vytvorte blok kódu, kde sa vykonávajú jednotlivé matematické operácie. Nakoniec, oddeľte zápis na obrazovku a tiež načítanie zo vstupu klávesnice. Potom už len oddelíte kľúčové slovo return s jeho návratovou hodnotou. Po spomenutých úpravách vám vznikne čitateľný kód, ktorý vyzerá nasledovne: #include <iostream> int main() { int a; int b = -1; int c; int d = 4; int e = 2; int f = 3; int g; a = b + c; d = e - f; g = a * d; std::cout << "g = " << std::endl; std::cin.get(); std::cin.get(); return 0; }Keď sa ďalej pozrieme na kód, môžeme niektoré deklarácie umiestniť na jeden riadok. Konkrétne prevedenie nechám na vás, ale ja by som odporúčal deklarovať na jednom riadku premenné, ktoré sa neinicializujú hneď na začiatku súčasne s deklaráciou. Na druhý riadok by som umiestnil premenné, ktoré sa inicializujú súčasne s deklaráciou. Takto získate ešte väčší prehľad v kóde a ušetríte 4 riadky kódu. Kód bude vyzerať nasledovne: #include <iostream> int main() { int a, c, g; int b = -1, d = 4, e = 2, f = 3; a = b + c; d = e - f; g = a * d; std::cout << "g = " << std::endl; std::cin.get(); std::cin.get(); return 0; }Teraz prejdeme k spomínanej rýchlosti. Je mi jasné, že pri tak krátkom kóde ušetríme relatívne málo času, ale keby sa nosná časť kódu, čiže tri matematické operácie s priraďovaním, vykonávali v cykle napr. 1 000 000 krát, videli by ste zaručene rozdiel. V uvedenom príklade nie je nutné použiť 7 premenných a výsledok vyhodnocovať na trikrát. Výsledky  b + c a  e - f  sa vynásobia a priradia do ďalšej premennej. Tak, ako to je naprogramované, je to zbytočné. Skúste všetko vyhodnotiť ako jeden výraz a priradiť na jednom riadku. Vznikne nám kód, ktorý bude mať o dva riadky menej a bude vykonávať to isté. A v čom je vlastne problém. No v operátore priradenia. Táto operácia je príliš časovo náročná. V podstate sa musí presunúť hodnota premennej uložená na jednom pamäťovom mieste do pamäťového miesta, ktoré je určené pre inú premennú. A po kurze už viete, že počítač pozná len 0 a 1. Organizačne existuje najmenej jeden bajt. Nespomínal som síce, čo je zásobník, ale keď sa pohybujeme v jeho pamäti, trvá to ešte dlhšie. Vráťme sa ale späť, po úprave bude kód vyzerať nasledovne: #include <iostream> int main() { int g; int b = -1, d = 4, e = 2, f = 3; g = (b + c) * (e - f); std::cout << "g = " << std::endl; std::cin.get(); std::cin.get(); return 0; } A poďme ešte ďalej. Na čo vôbec v tomto kóde používame premenné, keď ich nenačítavame s vstupu. Výsledok kombinácie matematických operácií môžeme predsa zapísať rovno na obrazovku, bez toho, aby sme hodnoty priraďovali do premenných. Odstránime tým aj deklarácie. Po konečnej úprave, bude kód vyzerať nasledovne: #include <iostream> int main() { std::cout << "res = " << (-1 + 4) * (2 - 3) << std::endl; std::cin.get(); std::cin.get(); return 0; }Záverom by som teda znovu chcel zdôrazniť, aké sú programátorský štýl a technika dôležité. Vidíte, že z 18 riadkového kódu, ktorý sme získali odsadením pôvodného kódu, nám po niekoľkých úpravách zostal kód, ktorý má 8 riadkov.  A tento kód, hoci je malý, je laicky povedané, pekný. To znamená, že sa jeho spustiteľný kód vykoná rýchlo, je prehľadný a ľahko udržiavateľný. Autorom blogu je Marek Šurka, ktorý má na Learn2Code online kurz C++ pre začiatočníkov.

Nezmeškaj info o nových kurzoch a špeciálnych ponukách