C++ - 2. lekce

• typy celočíselné, reálné
• proměnné - definice, inicializace a volání
• operátory, inkrementace, dekrementace
• přetypování
• zkracování zápisů
• postraní efekty
• vstupy
• úkol č. 2

Dnes si probereme, jak definovat proměnné, jaké můžou být typy a jednoduchou práci s nimi, dále také vstup (komunikace s uživatelem).

Celočíselné, reálné a jiné typy

Celočíselné typy

Hlavním celočíselným typem je int. Je dobré ho preferovat, protože je optimalizovaný pro co nejrychlejší práci. Dalším typem je short int - nebo-li short. Int má velikost někdy 2 někdy 4 byty, v závislosti na překladači. Short by měl vyhovovat požadavkům na 2 byty. V přehledné tabulce uvidíte, jaké jsou limity. Když určujeme proměnnou, musíme určit její typ. (Zda je celočíselný, jakou může mít maximální velikost, zda obsahuje desetinnou část...)

Nyní se ale zabývejme pouze typem proměnné. Pro celočíselné typy je to :

typ - typ proměnné
dolní mez - nejmenší číslo, které unese daný typ
horní mez - nejvyšší číslo, které unese daný typ
velikost - velikost výsledné proměnné v paměti [b]

signed - znaménkovost typu, signed = vynucení znaménka (+ -)
unsigned - neznaménkovost typu, unsigned = výsledný typ bude nezaménkový
char - nejmenší typ, uchovává právě pouze 1 znak

Reálné typy

Existují tři - jak ukazuje tabulka:

maximum - max. velikost čísla
přesnost - maximální počet čísel za desetinnou čárkou

Stejně jako u celočíselných typů preferujeme int, zde preferujeme double.

Poznámka: pokud neuvedeme signed či unsigned, budou typy int, short a long považovány za signed - budou mít znaménko.

U char je to jiné, zde záleží na překladači.

Nebojte se, hned pochopíte k čemu nám toto je.

Proměnné

Definice

Když už známe typy, pojďme si vytvořit proměnné. Je to velmi jednoduché. Nejprve si řekněme, k čemu by nám měla proměnná sloužit. Dejme tomu, že chceme získat z uživatele jeho věk; to je celočíselný typ - nepotřebuje desetinnou část. Máme na výběr z typů int, short a long. I když můžeme požít short, použijeme raději preferovaný int. Jak by tedy vypadala definice proměnné, kterou si nazveme vek?

int vek;  // toť vše ;)

Nyní jsme vytvořili proměnnou s názvem vek a typem int. Pokud se na ni budete odkazovat, volat ji apod., stačí napsat jen název proměnné, překladač si již bude pamatovat, že proměnná vek je typu int. Ovšem proměnná je vytvořena, ale není inicializována (= nemá žádnou hodnotu).

V našem případě ji mít nemusí, protože ji tam zadá uživatel až při vykonávání programu. Ale o tom až dále, nyní se pojďme podívat na samotné inicializování. Uvažujme následující kód:

Inicializace

#include <iostream>
using namespace std;
int main()
{
  cout << "Ahoj.\n";
  int vek;  // tady ji vytváříme
  vek = 18; // zde inicializujeme
  cin.get();
  return 0;
}

Ale jde to udělat i jednodušeji:

#include <iostream>
using namespace std;
int main()
{
  cout << "Ahoj.\n";
  int vek = 18;  // tady ji vytváříme a rovnou inicializujeme
  cin.get();
  return 0;
}

Máme proměnnou. Ovšem když si program spustíme, napíše pouze

Ahoj.

Nikde se nám neukáže naše proměnná, proč? Protože jsme ji nezavolali.

#include <iostream>
using namespace std;
int main()
{
  cout << "Ahoj.\n";
  int vek = 18;
  cout << vek;  // cout dosadí hodnotu proměnné vek (18)
  cin.get();
  return 0;
}

Výstup:

Ahoj.18

Když vyvoláváme proměnnou, nedáváme ji do uvozovek a nikdy nesmíme vyvolat proměnnou, která nebyla před voláním inicializována (nenabyla hodnotu před zavoláním.). Tedy:

  cout << "Ahoj.\n";
  int vek;
  cout << vek;  // NENÍ hodnota! chyba (buď ji napíše kompilátor nebo ve výsledku se objeví nesmyslné číslo)
  cin.get();
  return 0;

Zkoušejte si vytvářet proměnné různých typů a naučte se s nimi pracovat!

Inicializovat se dá samozřejmě i způsobem, jaký známe z matematiky.

  cout << "Ahoj.\n";
  int vek = 18;
  cout << vek + 2;
  cin.get();
  return 0;

Výstup:

Ahoj.20

Operátory

Kromě klasických operátorů, které jistě znáte (doufám ;)) z matematiky, se nabízejí i jiná řešení.

Myslím, že k tomu není co dodat.

Zde se jedná jen o zvětšení či zmenšení o 1. Používá se v podmíněných cyklech (tedy za nějaké podmínky udělej to, jinak to - o tom až později ;))

Příklad:

  int a, b=10, c; // inic. proměnné stejného typu (jako v Pascalu)
  ++b;  // nyní b = 11
  c = b;  // přiřadili jsme hodnotu b do proměnné cb--;  // b má nyní hodnotu 10
  a = b;  // a má stejnou hodnotu jako b (10)

Jaký je rozdíl v použití --x a x--?

Oba operátory se dají použít jak před svým operandem, tak za ním. Význam je však pokaždé jiný. Pokud operátor uvedeme před operandem, jedná se o tzv. preinkrementaci. To znamená, že hodnota operandu se nejprve zvýší a tato zvýšená hodnota je vrácena jako výsledek operace. Naopak při postinkrementaci je jako hodnota celého výrazu vrácena původní hodnota operandu a pak je teprve operand samotný zvýšen o 1.

  int a,b=1;
  a = b++;// Postinkrementace. Výraz b++ je nejdříve vyhodnocen (a jeho hodnota přiřazena proměnné a) a pak je teprve inkrementována proměnná b. Proměnná a teď tedy má hodnotu 1 a b je rovno 2.
  a = ++b;// Preinkrementace. Nejdříve je inkrementováno b na hodnotu 3. Tato hodnota je i výsledkem vyhodnocení výrazu ++b a tedy je přiřazena proměnné a. Hodnota a je 3.

Přetypování

int a=15;

Máme proměnnou a, a její hodnota je 15. Nyní chceme, aby byla jako typ v desetinné čárce. Zápis vypadá takto:

jméno_typu(název_proměnné);

Příklad:

double(a);   // konvertuje proměnnou a na typ double

Zkracování

Někdy se můžete setkat s následujícím zápisem:

a*=a;

Nebojte, není to nic jiného, než:

a = a * a;

A těchto operátorů je celá řada: +=; -=; *=; /=; %=

Tedy:

int a=10; // a=10
a+=a; // a=20 
a = a + a;   // a=20

Postranní efekty

V souvislosti s operátory v C++ je třeba zmínit se také o jejich postranních efektech. Výsledkem použití operátoru na operandy získáme nějakou konkrétní hodnotu. Například použitím '+' na čísla 2 a 3 získáme hodnotu 5. Operátory ale mohou mít i postranní efekt, který je však u některých operátorů jejich hlavním účelem. Například vyhodnocením výrazu a=2 získáme hodnotu 2, protože výsledkem operace přiřazení je sama hodnota přiřazovaného výrazu. Postranním efektem je pak uložení hodnoty 2 do proměnné a. Problém nastává, když v jednom výrazu aplikujeme na jednu proměnnou více operací s postranním efektem. To proto, že jazyk C++ nezaručuje pořadí vyhodnocování operandů u většiny binárních operátorů.

  int i=2;
i + ++i;

Příklad demonstruje nebezpečnost podobných zápisů. Před vyhodnocením celého výrazu má proměnná i hodnotu 2. Bohužel ale nevíme, který z operandů operátoru + bude vyhodnocen dříve. Bude-li to levý operand, bude mít celý výraz hodnotu 5. Pokud však bude jako první vyhodnocen pravý operand, bude hodnotou výrazu číslo 6. Proto je dobré takovéto výrazy nepoužívat a radši je rozepsat do více kroků tak, aby na jednu proměnnou byl aplikován vždy maximálně jeden operátor s postranním efektem.

Vstupy

Nyní se dostáváme konečně pod kůži tomu, aby uživatel při běhu programu zadával hodnoty.

K tomu je zapotřebí f-ce cin, která přikáže počkat, dokud uživatel něco nenapíše a jakmile zmáčkne ENTER, bude text uložen tam, kam mu přikážeme.

Není nad příklad! ;)

#include <iostream>
using namespace std;
int main()
{
  cout << "Zadej prosim tvuj vek: ";
  int vek;  // vytváříme proměnnou, ale nemusíme ji inicializovat (je to zbytečné)
  cin >> vek; // nechá uživatele napsat věk a po zmáčknutí ENTERu uloží hodnotu do proměnné vek
  cout << "\nVas vek je: " << vek;
  cin.get();
  cin.get();
  return 0;
}

Všimněte si, že zatímco << přepošlou text zprava do f-ce cout (a tím se zobrazí na obrazovce), >> vezme hodnotu (nyní zapsanou někde v dočasné proměnné u f-ce cin) z cin a uloží ji do proměnné vek. #############

Poté jsme chtěli vypsat větu, kolik nám je (výsledek, co uživatel zapsal).

Berte to tak, jako byste chtěli napsat:

cout << "\nVas vek je :";cout << vek;

To je to samé! Jen to zkrátíme, abychom nemuseli psát znova cout. Tzn, že napíšeme vše jak normálně, ale na stejný řádek a bez cout a ;:

cout << "\nVas vek je: " << vek; // nám říká, vezmi text Vas vek je:  a pošli ho na výstup, poté vezmi proměnnou vek a pošli ji na výstup.

A mohli bychom pokračovat:

cout << "\nVas vek je: " << vek << "\nDekujeme.";  // to samé jako:

// cout << "\nVas vek je: ";
// cout << vek;
// cout << "\nDekujeme.";

// neboli:
// cout << "\nVas vek je: ";
// cout << vek;
// cout << "\nDekujeme.";

Není jednoduší i praktičtější zkrácený zápis? Je, proto ho prosím používejte.

Zapomněl jsem v první lekci něco říct. Je jedno, jak bude program vypadat. Tedy např.:

cout << "ahoj";
cout << "cau";
cout << "bye";

nebo

cout << "ahoj"; cout << "cau"; cout << "bye";

Pokud je tam vše potřebné, překladač to nakompiluje správně. Spíše jak vidíte, z estetického hlediska a pro pozdější úpravy je to velmi nepřehledné, nehledě v těžších věcech.

V příští lekci si budeme povídat o uložení znaků do proměnné (tedy ne jen čísel) pomocí typu char a asi začneme podmíněnými výrazy if, while, do while...

Úkol č.2:

Vytvořte program, který na prvních třech řádcích (!) pozdraví uživatele, oznámí mu, kdo je tvůrcem programu a požádá ho o věk, výšku a váhu.

Výsledek by měl vypadat přibližně takto:

Vase vyska je x cm. Vas vek je x let. Vase vaha je x kg.

kde x je to, co uživatel zadá (jedná se tady o více proměnných a musíte tedy použít vícekrát cin a cout).

Poznámka: Je mi jedno, jak bude vypadat kód, ale musí fungovat. Proto si vyberte takový styl zápisu, které vyhovuje právě vám.