Pascal – #4 Práce s datovými typy, textové funkce

V dnešní lekci si ukážeme použití proměnných a základní práci s datovými typy k tomuto si také představíme některé textové funkce. Nejprve si však osvětlíme pár věcí, které nám to umožní.

Začneme tím, že si řekneme, jak jsme schopni uložit data do proměnné. Docílíme toho kombinací znaků := aby jste lépe pochopili vypadá to takhle promenna:=hodnota (například číslo, znak, řetězec znaků, atd. záleží jak jsme si proměnnou deklarovali, čili jaký očekává datový typ). Kompletně si to ukážeme se všemi datovými typy na následujícím příkladu. V tomto příkladu nic nevypisujeme pouze přiřazujeme hodnoty nebuďte tedy překvapení pokud po jeho spuštění neuvidíte žádný vystup. Je to čistě pro procvičení a aby jste pochopili užití datových typu a rozdíly mezi nimi.

program dat_typy;

uses crt;
var cele_cislo : integer;
var desetine_cislo : real;
var a : boolean;
var znak : char;
var veta : string;

Begin

       cele_cislo:=5;
       desetine_cislo:=4.5;
       a:=TRUE;
       znak:='A';
       veta:='ahoj toto je muj dalsi program';

end.

Načítání vstupních dat funkce Readln

Dále se naučíme načítat vstupní data od uživatele. Využijeme k tomu funkci Readln. Tato funkce očekává jeden argument, kterým bude název proměnné, do které má načtená data uložit. Syntaxe vypadá takto Readln(promenna);  Za chodu programu to tedy vypadá takto. Blikající kurzor čeká na zadaní dat jakmile k tomu dojde uloží Vámi zadané vstupní data do promenné. Musíme si však dát opět pozor aby jsme zadávali data, která se shodují s datovým typem proměnné do které se bude ukládat tzn. nemohu na vstupu zadat číslo a chtít pro funkci Readln aby ho uložila do proměnné string(textový řetězec) toto by zahlásilo chybu.

Dále pak bude možnost vypsat si v pascalu znak na příslušné pozici v textu. Uděláme to následovně. Předpokládejme, že v proměnné znaky máme uložen text „ahoj“, potom tedy tento řádek Writeln(znaky[1]); by nám vypsal znak ‘a’ jinými slovy vypíše první znak z proměnné „znaky“. Na následujícím příkladu si vše ukážeme praktický i s použitím funkce Readln.

Program znak;
uses crt.

var veta : string;
var pozice : byte;
var vysledek:char;

begin

  Writeln('zadej libovolnou větu');
  Readln(veta);
  Writeln('zadej pozici kterou chceš vypsat');
  Readln(pozice);
  vysledek:=veta[pozice];
  Writeln(vysledek);
repeat until keypressed;
end.

Funkce ord

Další co potřebujeme vědět, jsou funkce ord a chr. Funkce ord očekává jeden argument v podobě jednoho znaku a na svém výstupu vrací jeho hodnotu v ASCII tabulce. Pokud si toto aplikujeme znovu na naši ukázku, vypadalo by to takto:

Writeln(ord(znaky[1])) jelikož první znak našeho textu je písmenko ‚a‘ bude tedy funkce ord převádět tento znak na jeho hodnotu. Hodnota ‚a‘ je 97. Zde naleznete veškeré znaky a jejich hodnoty. http://www.theasciicode.com.ar/

Funkce chr

Funkce chr dělá přesný opak očekává jeden argument v podobě číselné hodnoty a na svém výstupu vrátí znak odpovídající zadané hodnotě. Na příkladu by vypadlo následovně. Writeln(chr(97)) toto by vypsalo na obrazovku ‚a‘.

Délka textového řetězce funkce lenght

Pojďme si ukázat ještě funkci lenght. V překladu by se tato funkce jmenovala ‚délka‘. Jak již tedy název napovídá, funkce bude vracet délku zadaného řetězce. Funkce očekává jediný argument v podobě řetězce znaků. Syntaxe je a:=length(retezec); vysvětlení – do proměnné ‚a‘ se uloží délka řetězce.  Pokud chceme vypsat na obrazovku, použijeme Writeln(length(retezec));

Příklad

Pojďme si to tedy ukázat na příkladu. Uživatel zadá libovolný znak a poté zadá číslo od 1 do 10, o které se posune hodnota znaku. Výsledný znak se poté vypíše. Jedná se tedy o jakýsi super jednoduchý šifrovací prográmek. Lépe to pochopíme při pohledu na zdrojový kód.

program sifra;

 uses crt;
 type cisla = 1..10;
 var posun: cisla;
 var vstup: char;
 vystup: char;
 hodnota:byte;
 begin clrscr;
 write('Vlozte znak k šifrování');
 readln(vstup);
 write('Vlozte posun v rozsahu od 1 do 10: ');
 readln(posun);
 hodnota:=ord(vstup) + posun vystup:= chr(hodnota);
 writeln('Znak ', vstup, ' posunuty o ', posun, ' znaku je ', vystup);
 repeat until keypressed;
 end.

Abychom si kód mohli lépe vysvětlit, předpokládejme, že uživatel zadal znak ‚a‘ a posun nastavil na hodnotu 3. V této chvíli nás tedy čeká řádek hodnota:=ord(vstup) + posun zde funkce ord očekává jeden argument, dostane se mu písmene ‚a‘, které převede na číslo 97, které potom sečte s číslem 3 výsledek tohoto, se uloží do proměnné hodnota.  Na dalším řádku vystup:= chr(hodnota); očekává funkce chr jeden číselný parametr k převedení na znak, dostane se mu číslo 100, které se rovná písmenku d, to celé se uloží do proměnné výstup.

Tyto dva řádky by šly nahradit jedním, který by vypadal takto, vystup:= chr(ord(vstup) + posun);

Avšak pro přehlednost jsem to raději rozepsal do dvou řádků, aby byla jasně vidět posloupnost jednotlivých kroků a bylo to lépe představitelné.

Příklad 2

Pojďme si ukázat další příklad. Tentokrát se bude jednat o primitivní kalkulačku.  Zadáme programu dvě čísla. Jako výsledek nám vypíše jejich součet rozdíl podíl a součin.

program kalkulacka;
uses crt;
var x: byte;
y: byte;
soucet: byte;
rozdil: byte;
soucin: byte;
podil: real;
begin clrscr;
write('Zadejte hodnotu promenne x: ');
readln(x);
write('Zadejte hodnotu promenne y: ');
readln(y);
z1:= x + y;
z2:= x - y;
z3:= x * y;
z4:= x / y;
writeln('Soucet hodnot: ', soucet);
writeln('Rozdil hodnot: ', rozdil);
writeln('Soucet hodnot: ', soucet);
writeln('Podil hodnot: ', podil:5:2); //uprava poctu znaku a desetiných míst
repeat until keypressed;
end.

Zde se jedná o v podstatě jednoduchý příklad. Jediné co si vysvětlíme je výpis proměnné podíl, kde nalezneme tento řádek. writeln(‚Podil hodnot: ‚, podil:5:2); jak si můžete všimnout za proměnnou podíl jsou ještě dvě hodnoty oddělené znakem ‘:‘ jelikož se jedná o typ real,který obsahuje desetinou čárkou tak mu určíme kolik má vypsat čísel celkově to je to první číslo a kolik čísel za desetinou čárkou to je to druhé číslo. Můžete si vyzkoušet, jak by to vypadalo bez tohoto.

Závěr

V této lekci jsme si ukázali začátky práce s textem a čísly. Byla to trochu více praktická lekce také proto, abychom si zažili syntaxi jazyka a vývojové prostředí. Měli by jste tedy s přehledem zvládat zadávání dat od uživatele čili funkci READLN a jejich uložení do proměnné, dále pak funkci ord, str a lenght a v neposlední řadě také vypsat znak na určité pozici v textu. Měli by jste také pochopit princip datových typů tzn. vědět jaké data vstupují a přizpůsobit tomu proměnné.

V sekci ke stažení bude také dostupný ještě jeden program k dalšímu procvičování a ukrácení času při čekání na další lekci, která se bude zabývat tentokrát cykly.

#5 Pole a ukazatel

V dnešním článku se podíváme na velice důležitou část v céčku, ukazatel nebo také pointer. Jak ukazatel funguje, si ukážeme hned na několika příkladech. S ukazateli se budeme potýkat i v dalších lekcích, takže se pokusím co nejlépe vysvětlit jak s nimi pracovat. V druhé části si ukážeme využití pole.

Ukazatel

Ukazatele uchovávají adresu na nějaké místo v paměti. Při deklaraci proměnné typu ukazatel se specifikuje i datový typ, tento typ je totožný s hodnotou místa paměti, na kterou ukazuje, tzn. že ukazuje na hodnotu určitého datového typu.

Deklarace ukazatele na datový typ:

int* nazev_ukazatele

Operátor reference (&)

Vrací adresu (pozici v paměti) svého parametru, následná hodnota lze přiřadit do ukazatele.

int cislo = 5;
int*pCislo = &cislo;

Konvence o pojmenovávání ukazatelů: Název proměnné typu ukazatel se skládá z písmene p (od slova pointer) a z názvu proměnné (bude začínat velkým písmenem) na kterou ukazuje.

Operátor dereference (*)

Vrací hodnotu na určitém místě paměti, adresa toho místa je uložena v argumentu.

Nyní si ukážeme jak správně vypsat hodnotu ukazatele. Použijeme deklarace, které jsou znázorněny na obrázku.

printf("%d\n", *pCislo); //vypise hodnotu promenne cislo, tedy 5
printf("%d\n", pCislo); //vypise adresu v pameti promenne cislo

Více ukazatelů může ukazovat na stejné místo v paměti. Následující zápis je správný pokud používáme předešlé deklarace.

int* pCislo2 = &cislo;

 

Pole

Jedná se o skupinu proměnných, které mají stejný datový typ a jsou označený stejným názvem. Pro přístup k jednotlivým prvkům v poli se využívají tzv. indexy, kterými jsou všechny prvky v poli identifikovány. V paměti je pole uloženo souvisle.

Jazyk C nehlídá meze polí, z důvodu rychlosti, proto pokud budete zapisovat mimo pole, obvykle to vede k chybě a program spadne.

Jednorozměrné pole

  • K prvkům pole se přistupuje pomocí operátoru [] (hranaté závorky)
  • Indexy prvků začínají vždy od nuly.

Obecná deklarace jednorozměrného pole:

datovy_typ nazevpole[velikost_pole]; //velikost_pole urcuje pocet prvku v poli.

Pokud bychom chtěli již při deklaraci proměnné inicializovat i jednotlivé prvky pole, použijeme tento zápis:

int array[5] = {8,6,9,-1,25};

Jestli použijeme takto plně inicializované pole, je možné vynechat hodnotu, která určuje velikost pole, velikost se automaticky zjistí z počtu inicializovaných prvků.

Pokud neinicializujeme všechny prvky v poli, ale např. pouze 2, tak se ostatní prvky nastaví na hodnotu 0. Pokud bychom chtěli mít celé pole vynulované, použijeme tento zápis:

int array[5] = {0};

Pro zápis konkrétního prvku v poli použijeme následující zápis, ostatní neinicializované hodnoty se opět nastaví na hodnotu 0.

int array[5] = {[1] = 5, [4] = 10};

Inicializace prvku pole se většinou neprovádí ihned při samotné deklaraci pole, ale později v kódu na základě vstupu ze souboru či z klávesnice. Pro procházení prvku se nejlépe použije cyklus. Aritmetika nad prvcích pole je stejná jako u obycejné proměnné.

int array[10];
for (int i = 0; i < 10; i++)
    array[i] = i; //zapis do pole

for (int i = 0; i < 10; i++)
    printf("%d\n", array[i]); //vypis prvku z pole

Vícerozměrné pole

  • Deklarace je stejná jako u jednorozměrného pole, pouze za názvem pole tolik určení velikosti, kolik chceme rozměru. Velikosti se zapisují za sebou, opět do hranatých závorek.
  • Přístup k prvkům je stejný, opět musíme uvést tolik hodnot v hranatých závorkách, kolik je rozměrů.

Deklarace dvourozměrného pole, jedná se v podstatě o matici prvků:

int array[2][3];
int array2D[2][3];
for (int i = 0; i < 2; i++)
    for (int j = 0; j < 3; j++)
        array2D[i][j] = i + j;

for (int i = 0; i < 2; i++)
    for (int j = 0; j < 3; j++)
        printf("%d\n", array2D[i][j]);

Nejčastěji z vícerozměrných polí se používá právě matice. Jednoduší je ale realizovat dvourozměrné pole jako jednorozměrné a o správný zápis do pole řešit později v programu. Deklarace je jednoduchá, stačí provést násobení mezi oběma rozměry. Přístup k prvku je o něco složitější:

array1D[radek * pocet_sloupcu + sloupec];

Převod naší matice 2 x 3 na jednorozměrné pole.

int array1D[2*3];
for (int i = 0; i < 2; i++)
    for (int j = 0; j < 3; j++)
        array1D[i * 3 + j] = i + j;

for (int i = 0; i < 2; i++)
    for (int j = 0; j < 3; j++)
        printf("%d\n", array1D[i * 3 + j]);

Pole a ukazatel

Vztah mezi ukazateli a poli je velmi blízky, totiž pole je možno realizovat pomoci ukazatele, tento způsob je rychlejší ale asi o trošku hůř pochopitelný.

    int array[10];
    for (int i = 0; i < 10; i++)
        array[i] = i;

    int* pArray = array; //pArray ukazuje na prvni prvek v poli

    printf("%d\n", *pArray); //vypise prvni prvek
    printf("%d\n", *(pArray + 5));

    pArray++; //posun na prvek nasledujici
    //*pArray++; //spatny posun prvku (warning)
    *pArray = -20; // prirazeni hodnoty do aktualniho prvku
    *(pArray + 3) = -10; // prirazeni hodnoty do aktualniho prvku + 3

    printf("Vypis pole: ");
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", array[i]); //vypis vsech prvku
    }

    pArray++;
    pArray++;
    printf("\n%d\n", pArray - array); //vypise pocet prvku mezi zacatkem pole a aktualnim prvkem

K dnešní lekci to bude vše doufám, že jsem vám dostatečně vysvětlil práci s ukazateli. Příště se podíváme na různé funkce vstupu.

Pascal #3 Proměnná a datové typy

Proměnná

Začneme tím, že si vysvětlíme co je to proměnná. Proměnná je v podstatě místo kam si náš program ukládá nějaké data, ať už to jsou mezivýsledky, výsledky nebo hodnoty čekající na zpracování. Chápejme to tedy, jako jistý prostor kam jsme schopni ukládat data, následně k nim přistupovat a dále s nimi pracovat.

Datové typy

již tedy víme, že do proměnných můžeme ukládat nějaké data ale program, potřebuje vědět přesně, jaká data budeme ukládat, a v této chvíli přichází na scénu datové typy. V zásadě rozlišujeme tři hlavní typy

  1. Textové pod tímto si představíme jakýkoliv text nebo jeden znak.
  2. Číselné jakýkoliv údaj, se kterým jsme schopni počítat.
  3. Logické, které nabývají jenom logických hodnot TRUE nebo FALSE

Vše co jsme si doposud řekli, využijeme u deklarace proměnné. Deklaraci chápej jako vyhradit prostor. V pascalu to vypadá následovně: var nazev_promenne : prislušny_datový_typ; Na tomto řádku jsme programu řekli vše, co potřebuje. Slovně by to šlo říci nějak takhle. Vyhraď si prostor pro proměnnou nazev_promenne do které budu ukládat příslušný_datový_typ.

Jinými slovy „var“ je klíčové slovo tak aby kompilátor věděl, že deklarujete (zavádíte) novou proměnnou. Druhé slovo je „nazev“ je název proměnné může byt libovolný (pro pozdější přehlednost programu je doporučeno využívat vždy jednoznačné informativní názvy proměnných) za dvojtečkou poté následuje datový typ zjednodušeně řečeno jaké data se mohou do proměnné uložit více v následující kapitole. Abychom si to mohli napsat víc konkrétněji  pojďme se podívat na jednotlivé datové typy a jejich charakteristiky.

TEXTOVÉ datové typy

Zde se řadí typy, kde zadáváme jakékoliv znaky z ASCII tabulky. Tedy i čísla není možno však s nimi počítat, program je bere jen jako textový řetězec. Textový řetězec se v pascalu ohraničuje apostrofy ‘příklad textového řetězce !! ?? 1234‘

Rozlišujeme zde dva typy

  •     CHAR zde můžeme uložit jen a pouze jeden jediný znak. Příklad ‚A‘
  •     STRING zde můžeme uložit textový řetězec o maximální délce 255 znaků. Příklad ‚příklad textového řetězce !! ?? 1234‘

ČÍSELÉ datové typy

Do těchto datových typů budeme ukládat údaje, se kterými budeme počítat. Dělí se na:

Celočíselné (ukládáme pouze celá čísla)

  •  Byte jeho rozsah je od 0 do 255
  •  Shortint jeho rozsah je od -128 do 127
  •  Word jeho rozsah je od 0 do 65535
  •  Integer jeho rozsah je od -32768 do 32767
  •  Longint jeho rozsah je od -2147483648 do 2147483647
  •  Comp jeho rozsah je od -263+1  do 263-1

Neceločíselné (možno ukládat i čísla s desetinnou čárkou)

  •  Real jeho rozsah je od 2,9*10-39 do 1,7*1038
  •  Single jeho rozsah je od 1,5*10-45 do 3,4*1038
  •  Double jeho rozsah je od 5,0*10-324 do 1,7*10308
  •  Extended jeho rozsah je od 3,4*10-4932 do  1,1*104932

LOGICKÉ datové typy.

Do tohoto typu dat můžeme ukládat hodnoty pouze dvou stavu True a False respektive 1 a 0. Mají pouze jeden typ a tím je BOOLEAN.

Tímto jsme si tedy ukázali všechny dostupné datové typy. Teď malý příklad toho jak by to mohlo vypadat. Samozřejmě by se daly použít i jiné typy u celého čísla například typ byte. Avšak pro ukázku nám postačí:

  •   Proměnná, do které chceme uložit text  var a :string;
  •   Proměnná, do které chceme uložit znak var a :char;
  •   Proměnná, do které chceme uložit celé číslo var a:integer;
  •   Proměnná, do které chceme uložit číslo s desetinou čárkou var a :double;
  •   Proměnná, do které chceme uložit pravdivostní hodnotu var a :boolean;

V pascalu se také můžeme setkat s vlastním datovým typem interval. Proměnná v tomto datovém typu obsahuje námi již nadefinovaná data (tedy buď číslo znak, nebo logický datový typ) avšak pouze v určitém intervalu. Obecný příklad vypadá následovně.

Type x= min..max;

Var a : x;

na prvním řádku jsme si deklarovali vlastní datový typ interval. Na druhém poté deklarujeme novou proměnnou, která bude nabírat hodnot námi vytvořeného datového typu. V praxi to může vypadat takto

Type rozsah = 1..100;

Var cislo : rozsah;

Nebo

Type rozsah = ’a‘ .. ’g‘;

Var znak : rozsah;

Vidíme tedy, že do proměnné číslo můžeme zapsat čísla pouze od 1 do 100 a do proměnné pouze znaky od ‚a‘ do ‚g‘.

Ordinalita

Za zmínku také ještě stojí říct si, jaké datové typy jsou ordinální. Pojďme však od začátku a nejdříve si zaveďme pojem ordinální. Je to ve své podstatě velice jednoduché.

Ordinální prvek je takový, který má svého předchůdce a následovníka. Ordinální jsou tedy celočíselné datové typy, u kterých můžeme z jistou říct, co předchází například před číslem 10 a jaké číslo stojí za ním. Jelikož se jedná o celočíselný datový typ, je jasné, že předchůdce je 9 a následovník je 11.

Kdybychom měli to samé číslo v datovém typu neceločíselném, nemůžeme s určitostí tvrdit jaké má předchůdce a následovníky. Protože po 10 může následovat 10.1 nebo například 10.567. Neceločíselné typy jsou tedy neordinální.  Datový typ Char je také ordinální protože všichni víme, že například před písmenkem ‚B‘ přijde na řadu ‚A‘ a následovník ‚B‘ je zase ‚C‘. Posledním ordinálním typem je typ boolean jelikož nabývá pouze dvou hodnot je to jednoduché. Když nabude 1 je jasné že předchůdce je 0 a naopak.

Příště si projdeme pár příkladu týkajících se právě datových typu a ordinálních hodnot.

 

#4 Řídící Struktury

V této lekci, v pořadí 4. se podíváme na řídící struktury. Patří zde podmíněné příkazy a cykly. Zařadíme zde i přepínač (příkaz switch), jeho využití je minimální. Použití jednotlivých struktur si znázorníme na příkladech.

Podmínky

Podmínka s IF

Podmíněné výrazy se tvoří pomocí klíčového slova if. Je možné použít i else ale není to nutnost.

Obecný tvar:

if (podminka)
{
	prikazy
}
else
{
	Prikazy
}

Syntaxe dovoluje zapsat podmínku i bez složených závorek, které ohraničují příkazy jak pro splněnou tak pro nesplněnou podmínku.

int vysledek = 0;

if (5 > 6)
    vysledek += 10;
    vysledek += 15;

printf("Vysledek: %d\n", vysledek);

Jak bude vypadat výpis toho programu?

Vysledek: 15

Pokud nepoužíváme složené závorky, tak ke splněné či nesplněné podmínce přiřadí pouze první příkaz. V tomto programu se podmínka nesplní. Přiřazení +10 se neprovede a else větev neexistuje. Následná operace +15 již není součásti podmíněného příkazu a je provedena.

Na následujícím příkladu vidíme použití více větví:

    
int den = 7; //predpokladejme prirazeni v rozmezi 1 až 7

if (den == 6)
    printf("je vikend\n");
else if (den == 7)
    printf("je vikend\n");
else
    printf("je pracovni den\n");

Vidíme ale, že první 2 větve mají stejný výstup je možné je spojit do jedné za použití správného operátoru:

if (den == 6 || den == 7)
    printf("je vikend\n");
else
    printf("je pracovni den\n");

Příkaz switch

Pokud máme podmínku, která obsahuje mnoho větví, je jednoduší a přehlednější použít příkaz switch.

Obecný tvar:

switch(celociselna_promenna)
{
	case konst_vyraz_1 : prikazy_1;
	case konst_vyraz_n : prikazy_n;
	default : prikazy_vychozi;
}

Následující program vypisuje slovně den v týdnu. Každý den je charakterizovaný číslem, zadán v proměnné den. Klauzule default se provede, pokud výčet neobsahuje konkrétní hodnotu, ale tento příkaz není povinný.

int den = 5;

switch(den)
{
    case 1 : printf("pondeli\n");break;
    case 2 : printf("utery\n");break;
    case 3 : printf("streda\n");break;
    case 4 : printf("ctvrtek\n");break;
    case 5 : printf("patek\n");break;
    case 6 : printf("sobota\n");break;
    case 7 : printf("nedele\n");break;
    default : printf("neznamy den\n");break;
}

Tento příklad obsahuje stejné zadání, jako příklad u podmínky s if, abyste mohli srovnat syntaxi.

int den = 5; //opet predpokladame ze prirazeni je v rozmezi 1 až 7
switch (den)
{
    case 6 :
    case 7 :
    printf("je vikend\n"); break;
    default : printf("je pracovni den\n"); break;
}

Cykly

Cyklus musí vždy obsahovat podmínku, podle které se cyklus ukončí. V těle cyklu musí být výraz, který souvisí s ukončovací podmínkou cyklu. Na základě výpočtu tohoto výrazu, se podmínka v určitém kroku nesplní a dojde k ukončení cyklu. V jazyce C existují 2 typy cyklů. Jako u podmínek i v cyklech je možné nevyužít složené závorky, ale cyklus se bude vztahovat pouze k prvnímu příkazu (posloupnost znaků oddělená nejbližším středníkem).

1. For

Obecný tvar:

for (pocatecni_hodnota;podminka;inkrementace)
{
	prikazy
}

Zde vidíme základní použití cyklu for. Program vypisuje jednotkovou matici, za pomoci 2 cyklu.

#include <stdio.h>

int main(void)
{
    unsigned char rozmer = 6; //rozmer matice

    for (int i = 0; i < rozmer; i++)
    {
        for (int j = 0; j < rozmer; j++)
        {
            if (i == j)
                printf("1 "); //vypisuje 1 na hlavni diagonale
            else
                printf("0 ");
        }
        printf("\n");
    }

    return 0;
}

Tento program vypočítává faktoriál ze zadaného čísla (proměnná cislo), je vhodné si na tomto programu vyzkoušet debugger. Pokud neumíte s debuggerem v Qt Creatoru pracovat, zde je návod k použití.

#include <stdio.h>

int main(void)
{
    unsigned int cislo = 6;
    unsigned int faktorial = 1;

    for (unsigned int i = cislo; i > 0; i--)
    {
        faktorial *= i;
    }

    printf("Vysledek: %u\n", faktorial);
    return 0;
}

Tento ukázkový příklad zobrazuje nekonečný cyklus. Ukončení běhu programu v konzoli se provede pomocí klávesové zkratky CTRL + C.

for (int i = 0; i < 1; i++)
{
    i = 0; //ridici promenna je vynulovana a podminka cyklu je s kazdou iteraci cyklu splnena
    printf("%d", i);
}

2. While

Tento cyklus může být dvojího typu, záleží jestli je podmínka cyklu na začátku nebo na konci.

Obecný tvar s podmínkou na začátku:

while (podminka)
{
	prikazy
}

Obecný tvar s podmínkou na konci:

Do
{
	Prikazy
} while (podminka);

Na tomto triviálním příkladu vidíme rozdíly mezi oběma typy cyklu while:

do
{
    printf("Cyklus while s podminkou na kocni\n");
} while(1 == 2);

while(1 == 2)
{
    printf("Cyklus while s podminkou na zacatku\n");
}

Zde můžeme srovnat syntaxe obou dvou typu cyklu (for i while)

#include <stdio.h>

int main(void)
{
    printf("Zde je vypis cyklu for\n");
    for (int i = 0; i < 3; i++) //v tomto radku vidime inicializaci pocatecni hodnoty, podminku i inkrementaci 
    {
        printf("for: %d\n", i);
    }

    printf("\nZde je vypis cyklu while\n");
    int j = 0; //zde je inicializace pocatecni hodnoty
    while (j < 3) //zde je podminka cyklu
    {
        printf("while: %d\n", j);
        j++; // zde je inkrementace
    }

    return 0;
}

Pomocné příkazy v řídících strukturách

break

S tímto příkazem jsme se již setkali u switch, kde byl použit u každého výčtu. Pokud by příkaz break nebyl pouzit ani u jednoho výčtu, příkaz switch by se nechoval jako podmíněný výraz a byl by naprosto zbytečný. Pokud upravíme příklad, který jsme si uvedli právě u příkazu switch, tak že odstraníme všechny příkazy break, můžeme pozorovat změnu ve výpisu pro všechny hodnoty 1 až 7.

Obecně příkaz break předčasně ukončuje cykly for či while. V daném programu se postoupí na příkaz, který se nachází bezprostředně za tímto cyklem. Použití si znázorníme na ukázkovém příkladu:

#include <stdio.h>

int main(void)
{
    unsigned char cislo = 250;
    for (int i = 1; i < 100; i++)
    {
        cislo++;
        printf("%d. iterace cyklu | cislo = %d\n", i, cislo);
        if (cislo == 255) //pokud dojde k preteceni datoveho typu, cyklus se zastavi
            break;
    }

    return 0;
}

continue

Tento příkaz funguje podobně jako break, s tím rozdílem, že neukončí celý cyklus, ale pouze právě prováděnou iteraci.

goto

Příkaz provede přesun na určitý řádek kódu, který je označen tzv. štítkem. Tento štítek musí mít stejný název jak pro označení řádku tak jako hodnota příkazu goto, aby příkaz fungoval správně

goto stitek
...
stitek : prikazy

Tento příkaz je možné použít i ke zkonstruování cyklu:

int i = 0;

iterace : if (i < 10)
{
    printf("%d. iterace\n",i);
    i++;
    goto iterace;
}

Všechny tyto 3 příkazy je možné nahradit, je vhodné je používat co nejméně a příkaz break používat pouze u switch.

Poznámka

Nepleťte si operátory = a == první slouží k přiřazení a druhý porovnává 2 hodnoty.

To je vše k dnešní lekci o řídících strukturách v jazyce C. Příště se podíváme na využití polí a také na ukazatele.

Pascal – #2 Obecná struktura, první příklad

V této lekci si ukážeme, obecnou strukturu jazyka Pascal. Podíváme se také na pár syntaktických pravidel. Vše budeme demonstrovat na jednoduchém příkladu. Tak tedy začneme, spustíme si naše vývojové prostředí, které jsme si nainstalovali v minulé lekci a přepíšeme následující příklad.

První příklad

Program ahoj;
 Uses crt;
 Begin Clrscr;
 Writeln(‘ahoj muj první vypis na obrazovku‘);
 Repeat until keypressed;
 End.

Kompilace

Ještě před tím než si daný program popíšeme tak si ukážeme jak program spustít. Nejdříve musíme příklad zkompilovat. Pod pojmem kompilace si představíme přeložení. Celý tento úkon děláme proto, abychom přeložili námi napsané řádky v jazyce pascal do jazyku, který bude srozumitelný našemu počítači (tzn. Překlad do strojového kódu) aby mohl dané příkazy vykonat a vrátit nám požadovaný výsledek. Kompilaci provedeme tak, že klikneme v menu na položku ‚compile‘ -> ‚build‘ pokud jsme byli úspěšní a compilator nenašel žádnou syntaktickou chybu, objeví se Vám tabulka informací čekající na potvrzení jakoukoliv klávesou. Nyní již můžeme s klidem spustit náš mini program přes položku ‚run‘ -> ‚run‘. Nyní by se Vám měl objevit výpis na obrazovku.

Popis Kódu

A teď jak to tedy celé vlastně funguje. Každý program napsaný v pascalu začíná příkazem Program a následuje jeho název. K tomuto se vztahují jistá omezení :

  • nesmí začínat číslem
  • nesmí obsahovat mezery
  • musí být ukončet středníkem
  • nesmí se shodovat s žádným interním příkazem jazyku Pascal například jako název programu nesmíme zvolit název Readln.

Na druhém řádku vidíme uses crt; v příkazu USES se uvádí seznam jednotek (knihoven), se kterými má překladač programu(compilator) pracovat při sestavování programu. Toto si zatím představíme tak, že pokud potřebujeme v programu použít výpis na obrazovku (jakože budeme potřebovat téměř vždy) napíšeme uses crt; Prozatím si s tímto nebudeme nijak lámat hlavu.  Jen pro úplnost uvádím ostatní základní jednotky(knihovny)

  • CRT – řízení systému zobrazení, vstupu z klávesnice, práce s okny
  • DOS – komunikace mezi aplikačním programem a OS
  • SYSTEM  – standardní procedury a funkce
  • GRAPH – grafické možnosti
  • Další : STRINGS, OVERLAY, PRINTER

Příkaz BEGIN ohraničuje samotné tělo programu. A píšeme ho vždy.

Příkaz CLRSCR; nám tzv. vyčistí obrazovku bude tam tedy jen ta naše zpráva. Na funkčnost programu to nemá vliv, ale vypsaná data na obrazovce jsou potom přehlednější. Schválně si zkuste příklad bez tohoto příkazu a uvidíte rozdíly ve výstupu.

Na dalším řádku se již dostáváme k samotnému výpisu. Ten nám zajišťuje příkaz Writeln. Tento příkaz znamená, vypiš zprávu na obrazovku. Avšak požaduje argument v podobě „co mám vypsat“ vždy tedy musíme do závorky napsat buď proměnnou, nebo textový řetězec ohraničený apostrofy (ty vypadají takhle ‚). Toto musíme udělat aby měl Writeln vůbec co vypisovat.C

Další řádek je jakýsi cyklus a vypadá takto repeat until keypressed; Toto však budeme probírat až pár kapitol dále. Nyní Vám stačí vědět, že pozdrží Vámi vypsanou zprávu na obrazovce do té doby, než zmáčknete libovolnou klávesu. Program by fungoval i bez tohoto avšak provedl by se na pozadí, respektive nebyla by vidět Vámi vypsaná zpráva. Znovu si to můžete vyzkoušet a tento řádek umazat a pozorovat rozdíl.

Poslední příkaz je příkaz end. který ukončuje celý program.

Jak jste si již mohli všimnout, za každým příkazem se musí udělat středník až na výjimku begin kde není nic a end na konci programu kde se uvádí závěrečná tečka. Těchto vyjímek je však více my si je budeme ukazovat postupně jak na ně budeme narážet.

Samostatná práce

Za domácí úkol si zkuste náš program napsat bez příkazu clrscr; a poté bez repeat until keypressed;

Závěr

Toto je tečka za naší první lekci příště se podíváme na proměnné a datové typy. Po této lekci by jste tedy měli umět základní strukturu programu a znát příkaz writeln, který budeme používat v každé další lekci.

VBA – #3 Lekce – Proměnné a datové typy

V této lekci se podíváme na proměnné (bez nichž by se neobešel žádný programovací jazyk) a jejich datové typy. Každý program potřebuje své mezi výpočty nebo již hotové výsledky někam ukládat aby s nimi později mohl jakkoliv dál pracovat například vypsat na obrazovku, znovu počítat nebo cokoliv jiného proto byly vymyšleny proměnné.

Proměnná

je dočasný prostor pro ukládání dat při chodu programu. Každá proměnná se musí deklarovat (chápej jako vyhradit prostor) .

Příklad explicitně deklarované proměnné:

Dim a as integer

  1. Dim – je klíčové slovo deklarace
  2. a – je název proměnné
  3. as integer – tímto programu určujeme jaká data se budou do proměnné ukládat (datový typ)

Datové typy

každé data mají svůj typ. Některá jsou celo číselná některá jsou necelo číselná a některé jsou textová. Žádné jiné data neexistují. Každý program potřebuje znát typ dat s jakými bude pracovat a proto je rozlišujeme do několika skupin. A už při deklaraci proměnné musíme uvést jaký typ dat do ní budeme ukládat. Toto je velice důležité.

Celočíselné datové typy

Pokud budeme chtít uložit celočíselná data, použijeme jednu z následujících tří variant:

Byte

  • zabírá v paměti 1 B
  • rozsah je 0 až 255
  • Používá se tam, kde uvedený rozsah stačí.

Integer

  • Zabírá v paměti 2 B
  • rozsah je od -32768 do 32767

Long

  • Zabírá v paměti 4 B
  • Rozsah je od –2 * 109 do –2 * 109
  • tyto datové typy by se daly použít v jednoduchém příkladu
Sub soucet()
 Dim a As Integer
 Dim b As Integer
 Dim c As Integer
 a = 5
 b = 2
 c = a + b
 MsgBox c, vbOKOnly + vbInformation, "Vysledek 
End Sub 

Prvními třemi řádky jsme si deklarovali proměnné a určili jejich datový typ další dva řádky zajistili načtení hodnot (dat) do proměnných další řádek zajistil jejich výpočet a jeho načtení do proměnné c další řádek zajistil jeho vypsání pomocí msgboxu. Msgbox zvládne také vypsání proměnné to se dělá bez uvozovek (MsgBox c).

Neceločíselné datové typy

Tyto datové typy využijeme, pokud budeme vědět, že data budou s desetinou čárkou

Single

  • Reálné celé číslo s plovoucí čárkou zabírající nejvýše čtyři bajty.

Double

  • Reálné kladné číslo s plovoucí čárkou zabírající nejvýše osm bajtů. Nabízí dvojnásobnou přesnost oproti Single a větší rozsah.

Currency

  • Reálné číslo se čtyřmi desetinnými místy zabírající nejvíce osm bajtů.

Zase si je vysvětlíme na jednoduchém příkladu:

Sub Podil() 
Dim a as integer
Dim b as integer
Dim c as double
a=5
b=3
c=a/b
MsgBox c, vbOKOnly + vbInformation, "Vysledek" 
End Sub

Tím, že jsme u třetího řádku nastavili proměnnou jako double si zajistíme, že se výsledek nezaokrouhlí (což by se stalo kdyby jsme použili datový typ integer) ale vypíše se i s desetinou čárkou.

Textové (řetězcové) datové typy

String

Používáme jej k uložení textových řetězců. Řetězec musí být uzavřen do uvozovek. Do textového řetězce můžeme napsat i čísla ale nebude s nimi možno počítat. Budou brány jako znak.

Příklad:

Sub zprava()
Dim zprava as string
zprava=“libovolný textový řetězec sdělující informace uživateli“ 
MsgBox zprava, vbOKOnly + vbInformation, "Zpráva" 
End Sub

Příklad čísla ve stringu:

Sub zajimavost()
Dim a as string
Dim b as string
Dim vysledek as string
a="2"
b="3"
Vysledek=a+b
MsgBox vysledek
End Sub

Sami budete překvapení, jaký bude výsledek. Pokud program pracuje s datovým typem string, nepoužívá plus k matematickým úlohám (3+2=5) ale pouze „postaví“ dva textové řetězce za sebe (slepí je dohromady (2+3=23).

poznámka: čísla v proměnných a , b by se daly zapsat i bez uvozovek ale pro pochopení, že se jedná o datový typ string jsem raději uvedl uvozovky.

Závěr

Toto je konec 2 lekce. Můžete si vyzkoušet různé kombinování s typy proměnných a sledovat změny v chodu programu. V příští lekci se podíváme na využití dalšího windows příkazu inputbox.

#3 Operátory a operandy

V další lekci programování v C se podíváme pouze na všechny možné operátory, které v jazyce C existují. Na některých z nich si ukážeme několik příkladů.

Dodatek k deklaraci proměnné

V předchozí lekci jsme se zapomněli zmínit o tom, že jméno funkce nemůže obsahovat jakékoliv slovo. V jako každém jiném programovacím jazyce i v C existují určitá rezervovaná slova, která nelze použít jako jméno pro proměnné, či názvy vlastních funkcí. Zde je výčet všech těchto rezervovaných slov:

auto break case char const
continue default do double else
enum extern float for goto
if inline int long register
return short signed sizeof static
struct switch typedef union unsigned
void volatile while _Bool _Complex

Příklad:

int return; // tento nazev nelze pouzit
int Return; // tento nazev je mozne pouzit

Tři pojmy na úvod

  • Výraz = posloupnost operandů a operátorů
  • Operand = proměnná či hodnota
  • Operátor = určuje druh operace, která bude ve výrazu provedena nad operandy

Operátory

V jazyce C existuje 15 prioritních skupin, do kterých se jednotlivé operátory řadí. Směr sdružení nebo také asociativita může být buď zleva nebo zprava. Operátory dělíme do skupin podle toho, kolik potřebují operandů.

Unární operátory

OPERÁTOR POPIS PRIORITA ASOCIATIVITA
+ hodnota operandu se nemění 2 zprava
změní hodnotu operandu na z kladné na zápornou a opačně 2 zprava
++ inkrementace 2 zprava
dekrementace 2 zprava
! logická negace 2 zprava
~ změna bitu z 0 na 1 a opačně 2 zprava
& reference 2 zprava
* dereference 2 zprava
(datovy_typ) přetypování operandu 2 zprava
sizeof počet bytů které operand zabírá v paměti 2 zprava

Na příkladu si ukážeme využití operátoru přetypování:

#include <stdio.h>

int main(void)
{
    int x = 5, y = 2;
    float vysledek;

    vysledek = x / y;
    printf("%.1f\n", vysledek); //presnost na 1 desetinne misto
    /*
    pokud delime celociselne promenne vysledek take bude
    celociselny a tim ze jej priradime do realneho typu
    tak se vypise i s desetinnou carkou ale vysledek bude
    vypocitan spatne nebo spise jinak nez jsme chteli
    */

    vysledek = (float)x / y;
    printf("%.1f\n", vysledek);

    vysledek = x / (float)y;
    printf("%.1f\n", vysledek);

    vysledek = (float)x / (float)y;
    printf("%.1f\n", vysledek);
    /*
    pokud alespon jeden operand x nebo y pretypujeme na realny tak vysledek bude spravny  
    */
    
    return 0;
}

Binární operátory

Aritmetické

OPERÁTOR POPIS PRIORITA ASOCIATIVITA
* násobení 3 zleva
/ dělení 3 zleva
% modulo (zbytek po dělení) 3 zleva
+ sčítání 4 zleva
odčítání 4 zleva

Můžeme si také ukázat, jak vlastně funguje priorita operátorů. Použijeme stejný kód jako u předešlého příkladu.

#include <stdio.h>

int main(void)
{
    int x = 5, y = 2;
    float vysledek;

    vysledek = (float)x / y;
    printf("%.1f\n", vysledek);
    /* vime ze pretypovani ma vetsi prioritu nez deleni
      takze se tento vyraz vyhodnoti spravne, pokud
      bychom ale vynutili aby se deleni provedlo nejdrive
      tak uz vysledek bude jiny
      */

    vysledek = (float)(x / y); //vynuceni priority pomoci zavorek
    printf("%.1f\n", vysledek); //chybny vysledek, vidime ze priorita operatoru je dulezita

    return 0;
}

Přiřazovací

OPERÁTOR PRIORITA ASOCIATIVITA
= 14 zprava
+= 14 zprava
-= 14 zprava
*= 14 zprava
/= 14 zprava
%= 14 zprava
<<= 14 zprava
>>= 14 zprava
&= 14 zprava
^= 14 zprava
|= 14 zprava

U těchto operátoru dojde nejprve k provedení operace, která se nachází před (=) a následně se tento výpočet přiřadí do hodnoty která je vlevo.

Příklad:

int cislo1 = 11;
int cislo2 = 2;
cislo1 %= cislo2; //zmena promennych: cislo1 = 1 a cislo2 = 2 (zustane stejne)

Porovnávací

OPERÁTOR POPIS PRIORITA ASOCIATIVITA
< menší než 6 zleva
> větší než 6 zleva
<= menší nebo rovno než 6 zleva
>= větší nebo rovno než 6 zleva
== rovnost 7 zleva
!= nerovnost 7 zleva

Logické

OPERÁTOR POPIS PRIORITA ASOCIATIVITA
<< bitový posun vlevo 5 zleva
>> bitový posun vpravo 5 zleva
& logický součet po bitech 8 zleva
^ nonekvivalence po bitech 9 zleva
| logický součin po bitech 10 zleva
&& logický součet 11 zleva
|| logický součin 12 zleva

Ternární operátory

Existuje pouze jeden operátor, který potřebuje 3 operandy a tím je Podmíněný výraz. Sdružuje zprava a priorita je 13. Zápis vypadá takto:

podminka ? hodnota1 : hodnota2

Nejprve se vyhodnotí podmínka, pokud je splněna (hodnota <> 0), výsledkem bude hodnota1, při nesplněné podmínce (hodnota = 0), výsledkem bude hodnota2.

Ostatní operátory

OPERÁTOR POPIS PRIORITA ASOCIATIVITA
() zavolání funkce 1 zleva
[] výběr hodnoty z pole 1 zleva
. výběr prvku ze struktury 1 zleva
-> výběr prvku ze struktury zadané pomocí ukazatele 1 zleva
, jednotné provedení výrazů 15 zleva

Operátor (,) čárka slouží k jednotnému provedení výrazů. Občas potřebujeme operaci kde je více výrazů, ale syntaxe dovoluje pouze jeden výraz. Operátor čárka tyto jednotlivé výrazy odděluje a v podstatě je sloučí do jednoho. Používá se například u cyklů.

Operandy

  • Proměnná – známe již z předchozí lekce
  • Konstanta – definují se pomocí direktivy preprocesoru #define nebo lze použít klíčové slovo const při deklaraci proměnné
  • Výpočet funkce – samotné zavolání funkce je možné použít jako operand, za podmínky, že funkce nemá návratový typ void

Vysvětlíme si používání konstantních operandů:

Konstanta pomocí  #define

  • obecný tvar = #define NAZEV hodnota
  • podle konvence by název konstanty měl být velkými písmeny
#include <stdio.h>
#define PI 3.14

int main(void)
{
    int polomer = 10;
    float objem;

    objem = 4.0/3.0 * PI * polomer;
    printf("Objem koule o polomeru %d je %.2f\n", polomer, objem);

    return 0;
}

Pomocí direktivy #define se dají vytvářet i makra:

#include <stdio.h>
#define PLUS(a,b) ((a)+(b))

int main(void)
{
    printf("Soucet = %d\n", PLUS(1,2));
    return 0;
}

Konstanta pomocí const

Pokud použijeme klíčové slovo const, tak jediná možnost jak proměnnou inicializovat je ihned při její deklaraci, pozdější inicializace není možná.

#include <stdio.h>

int main(void)
{
    const int cislo = 10;
    cislo = 15; //error
    printf("%d\n", cislo);
    return 0;
}

Program neprojde překladem, kvůli chybnému přiřazení do konstantní proměnné na řádku 6

main.c:6: error: assignment of read-only variable 'cislo'

To by bylo vše k této lekci o operátorech a operandech. Příště se naučíme pracovat s podmíněnými výrazy a cykly.

Debugging ladeni v QT creatoru

Debugger je velice užitečný nástroj pro programátory. Mnohdy odhalí, proč program pracuje tak jak nemá a ušetří spoustu času při řešení takových nesrozumitelných chybách či překlepech v kódu. Postup ladění si ukážeme v programu QT Creator.

Na vyzkoušení debuggeru použijeme následující kód:

#include <stdio.h>

int main(void)
{
    int cislo1 = 10;
    int cislo2 = 20;

    printf("%d\n", cislo1);
    printf("%d\n", cislo2);

    return 0;
}

Postup ladění programu v QT creatoru

Nyní na určitý řádek v kódu musíme vložit Breakpoint. Klikneme na řádek, kde jej chceme vložit a klávesou F9 jej přidáme. Dá se přidat také kliknutím do volného šedého prostoru nalevo od čísla řádku. Breakpoint vložíme na 5. řádek.

Breakpoint

Při spuštění debuggeru F5 se vývojové prostředí automaticky přepne z editace (Edit Mode) do debuggeru (Debug Mode), zobrazí se konzole a program by se měl zaseknout na řádku, kde máme první breakpoint, v tomto případě 5. řádek.

QT Creator - Debugging

Prostředí debuggeru vidíte na obrázku, oproti Edit Modu zde navíc máte 3 okna. Vpravo nahoře seznam proměnných. Pod tímto oknem je seznam všech Breakpointu použitých v kódu. Nalevo od tohoto okna je zobrazeno kde v kódu se právě nacházíme (= řádek 5, funkce main). V okně se zdrojovým kódem je také navíc žlutá šipka (u čísla řádku) ta také informuje, kde se nacházíme. Můžeme vidět, že již jsou deklarovány proměnné aniž by debugger přes ně prošel, ale inicializace rozhodně nejsou správné. Hodnoty proměnných jsou načtený z paměti, kde jsou uloženy. Tuto stejnou paměť mohla využívat jiná aplikace v počítači, proto je hodnota proměnných takto nesmyslná.

Ovládání ladění je jednoduché,  budou nám stačit tyto 3 operace:

  • Step Into (F11) – operace která krokuje všechny operace, které se provedou při výpočtu (= nic nepřeskakuje)
  • Step Over (F10) – tato operace pracuje obdobně jako Step Into, akorát se nevnořuje do funkcí, které jsou volány v kódu
  • Step Out (Shift + F11) – pokud bychom se nacházeli ve vnořené funkci, která je příliš dlouhá tak tato operace nám pomůže se dostat nakonec a pokračovat v kódu kde funkce byla zavolána

Zkusíme si použití operací ukázat na příkladu.

QT Creator - Debugging

Nyní jsme použili 2x operaci Step Over (operace Step Into by se chovala stejně) a inicializace proměnné nyní máme správně. Nacházíme se na řádku 8.

  • Pokud bychom nyní použili Step Into dostali bychom se do funkce printf a museli bychom odkrokovat všechny řádky, které funkce obsahuje, taky bychom mohli z funkce vyskočit pomoci Step Out.
  • Pokud bychom použili Step Over, vůbec bychom se do funkce printf nedostali, ale její výpočet se provede. Operace Step Into se může hodit, právě pokud bychom se potřebovali dostat do funkcí, které jsme si sami naimplementovali, procházet vestavěné funkce nemá smysl, víme, že pracují správně.

Od předchozího obrázku jsme použili 5x Step Over a dostali jsme se nakonec výpočtu celého programu.

QT Creator - Debugging

Doufám, že tento tutoriál byl pro vás aspoň trochu užitečný.

#2 Struktura kodu, datové typy a proměnna

V druhé lekci kurzu o programování v jazyce C se podíváme na strukturu zdrojového kódu, využívání komentářů ve zdrojovém kódu, datové typy a jak správně zapsat deklaraci proměnné a také jak se proměnná inicializuje. V bonusové lekci je popsáno jak využít Debugger v IDE Qt Creator.

Struktura kódu v C

Rozbor si ukážeme na kódu, který se vygeneruje při vytvoření nového projektu v Qt Creatoru.

Direktivy preprocesoru

V horní části (řádek #include <stdio.h>), zde se vkládají tzv. direktivy preprocesoru, každý řádek začínající „#“ je považován za direktivu preprocesoru. Existuje několik operací:

  • #define, #undef – slouží pro definování maker v jazyce C
  • #include – vkládá hlavičkové soubory (tyto soubory obsahují vestavěné funkce)
  • #if, #ifdef, #ifndef, #else, #elif, #endif – podmíněné příkazy, slouží k tomu, aby kompilátor přeložil určité části zdrojového kódu, daný právě těmito příkazy

Funkce main

Funkce main, jak už z názvu vyplývá, jedná se o hlavní funkci programu a je to funkce která se při spuštění programu zavolá jako první. Není možné ji smazat ani přejmenovat.

Obecná struktura funkce v jazyce C

navratovy_typ nazev_funkce (vstupni_parametry_funkce) 
{
	telo funkce
}
  • Popis návratových typů (resp. Datových typů) se nachází níže v tomto článku.
  • Název funkce – jednoznačný identifikátor, podle kterého je funkce volána
  • Vstupní parametry – seznam všech proměnných, se kterými se bude pracovat v dané funkci a jsou deklarována na jiném místě
  • Tělo funkce – zapsané ve složených závorkách, muže obsahovat lokální deklarace, posloupnost příkazů, které budou vyhodnoceny při zavolání funkce. Příkazy bývají zpravidla ukončeny středníkem, ale výjimku tvoří např.: složené příkazy

Rozbor na konkrétní funkci main:

  • int návratový typ – celé číslo (detailněji popsán níže)
  • název funkce – main
  • vstupní parametry – void = tento příkaz znamená, že funkce nemá žádné vstupní parametry
  • V těle funkce main najdeme 2 přikazy – printf a return

Funkce Printf

  • Funkce je deklarovaná v hlavičkovém souboru stdio.h
  • Funkce vypisuje na standardní výstup nekonečně mnoho hodnot, které mu zadáme, v tomto případě vypíše text:Hello World!, na konec textu vloží nový řádek, to značí příkaz \n

Ostatní příkazy, které jsou možné vložit do textu, jsou uvedený zpětným lomítkem (\)

Příkaz Popis
\n nový řádek
\t tabulátor
\“ uvozovky
\\ zpětné lomítko

Pokud se podíváme na deklaraci printf v hlavičkovém souboru tak zjistíme, že vypadá následovně:

int printf (const char *__format, ...)

Můžeme si všimnout, že funkce má návratový typ int, existují 2 typy výpisu:

  • Pří úspěšném = vrací počet znaků, které printf vypsal
  • Při neúspěšném = vrací zápornou hodnotu (typicky -1)

Dále vidíme, že vstupním parametrem je format a tři tečky značí, že parametrů může být nekonečně mnoho. Parametr format určuje, jakou hodnotu chcete vypsat, přesněji jaký datový typ má právě vypisovaná hodnota pomocí funkce printf. Ukážeme si to na příkladu, přikaz:

printf("Hello World!\n");

je možno zapsat také následujícím způsobem:

printf("%s","Hello World!\n");

Vidíme, že vnitřní parametry se rozdělily na 2 části oddělené čárkou, napravo jsou stále vstupní hodnoty, mohou byt zapsané i jako proměnné. Vlevo vidíme právě daný formát výstupu dané hodnoty. Počet těchto formátu se musí rovnat počtu vstupních hodnot, zde vidíme jak mužem vypsat více těchto hodnot v jednom příkazu printf:

printf("%s: %d","Cislo", 10);

Opět v první části vidíme výpis formátů, jsou zapsané všechny společně obalené do uvozovek, dále následuje vstup konkrétních hodnot, které chceme vypsat.

V této tabulce vidíte, jaké další možné formáty lze použít ve funkci printf:

specifikátor výstup příklad
d dekadické číslo se znaménkem -524
i dekadické číslo se znaménkem -524
u dekadické číslo bez znaménka 25
o oktalové číslo 76
x hexadecimální číslo (malé písmena) 3e
X hexadecimální číslo (velké písmena) 3E
f desetinné dekadické číslo 25.56
e vědecký zápis čísla (malé písmena) 3.9265e+2
E vědecký zápis čísla (velké písmena) 3.9265E+2
c znak a
s řetězec slovo

Příkaz return

Příkaz return vrací hodnotu, kterou daná funkce vypočítá, v jaké formě tato hodnota bude, určuje návratový typ funkce, v tomto případě int. Správný programátor by se měl držet určité konvence. U příkazu return ve funkci main, konvence říká:

  • rozsah hodnot, které příkaz return vrací: 0 – 255
  • return 0; = hodnota 0 se vrací, pokud chod programu byl úspěšný, jinak jakákoliv jiná hodnota v rozmezí 0 – 255, nepoužívají se záporné hodnoty

Příkaz return nemusí obsahovat každá funkce, ale musí být ve funkci main, Pokud vlastní funkce bude mít návratový typ void:

void moje_funkce (void)
{
    prikazy
}

Znamená to, že funkce nevrací žádny argument a nesmí obsahovat příkaz return, možná si někteří říkáte na co je funkce, která nevrací žádný vypočtený údaj, ale i takové funkce jsou užitečné, detailněji si takové funkce rozebereme v článku o funkcích v jazyce C.

Komentáře

Psaní komentářů je velice užitečné, kód se stává více přehledným. Pokud na daném projektu pracuje více programátoru, tak ať ostatní ví, co jste daným kódem chtěli vlastně říct, je dobré jej okomentovat. Využití je mnoho, takže se toho nebojte a určitě komentujte. Každá funkce by měla obsahovat popis (= komentář) co vlastně dělá.

Komentáře jdou zapsat dvěma způsoby:

  • Na jeden řádek
// komentář
  • Více řádkový
/* viceradkovy
komentar */

Příklad:

#include <stdio.h>
 
int main(void)
{
    printf("Hello World!\n"); //vypiste na strandardni vystup Hello World
    
    /*
    toto je vice radkovy komentar
    kod ktery je zde, prekladac preskakuje
    printf("Toto se nevypise");
    */
    
    return 0;
}

Datové typy

Celočíselné

Název rozsah velikost v paměti v Bytech
char (= signed char) -27 až 27 – 1 1
unsigned char 0 až 28 – 1 1
short int (= signed short int) -215 až 215 – 1 2
unsigned short int 0 až 216 – 1 2
int (= signed int) -231 až 231 – 1 4
unsigned int 0 až 232 – 1 4
long long int -263 až 263 – 1 8
unsigned long long int 0 až 264 – 1 8

signed = datový typ který rozlišuje kladná a záporná čísla

unsigned = tento příkaz určuje, že datový typ nepoužívá záporná čísla

  • typ short int lze zapsat jako short
  • typ int lze zapstat jako long int nebo i jako long
  • typ long long int lze zapsat jako long long
  • obdobně je to u typu, kde je použité slovo unsigned

Neceločíselné

název rozsah Počet desetinných míst velikost v paměti (v bytech)
float +/- 3.4 * 1038 8 4
double +/- 1.7 * 10308 16 8
long double +/- 1.7 * 10308 20 12

Řetězcový typ

Řetězcy se budeme zabývat v samostatné kapitole, společně s funkcemi které slouží pro práci s nimi.

Příkaz sizeof

Velikost paměti jednotlivých datových typů lze zjistit pomocí příkazu:

sizefof(datovy_typ)

Příklad:

#include <stdio.h>
int main(void)
{
    printf("%d\n", sizeof(int));
    return 0;
}

Velikost zabrané paměti se může lišit v závislosti na verzi systému, běžně int zabírá 4 B, ale na určitých operačních systémech může zabírat pouze 2 B.

Zápis proměnné

Deklarace proměnné

Obyčejná deklarace proměnné se skládá z datového typu a názvu proměnné:

int cislo;

Název proměnné může obsahovat znaky anglické abecedy a čísla a znak podtržítka (_). Jazyk C rozlišuje malá a velká písmena (= Case-sensitive)

int cislo; //promenna cislo
int Cislo; //promenna Cislo, ktera nema nic spolecneho s promenou cislo

Inicializace proměnné

Inicializace znamená přiřazení konkrétní hodnoty do proměnné. Je možné deklaraci a inicializaci proměnné provést zvláště:

int cislo;
cislo = 5;

nebo také společně na jeden řádek;

int cislo = 5;

Pokud bychom chtěli inicializovat maximalní možné číslo, které v jazyce C existuje tj. 264 – 1 kód by vypadal následovně:

#include <stdio.h>
int main(void)
{
    unsigned long long int cislo = 18446744073709551615LLU;
    printf("%llu\n", cislo);
}

U inicializace proměnné má číslo přidaný sufix LLU, jinak by kompilátor při překladu hlásil varování:

warning: integer constant is so large that it is unsigned

Shrnutí

Zde máme takový souhrn dnešní lekce a malý dodatek k funkci printf, jak vidíte na příkladu tak mezi % a formátem výstupu, jsou 2 čísla oddělené tečkou. První značí na kolikátou pozici se má vypsaná hodnota odsadit, druhé určuje přesnost výpisu (použitelné pouze u čísel s pohyblivou desetinou čárkou)

#include <stdio.h>
int main(void)
{
    int cislo = 15;
    int cislo2 = 215;
    float c_float = 0.12345678; //8
    double c_double = 0.1234567890123456; //16
    long double c_long_double = 0.12345678901234567890; //20

    printf("Velikost float: %d B\nVelikost double: %d B\nVelikost long double: %d B\n", sizeof(c_float), sizeof(c_double), sizeof(c_long_double));

    printf("%50.8f\n%50.16f\n%50.20lf\n", c_float, c_double, c_long_double);

    printf("%15d\n", cislo); //zarovna na 15. pozici zleva
    printf("%15d\n", cislo2); //zarovna na 15. pozici zleva
    printf("%15.10d\n", cislo); //zarovna na 15. pozici zleva pokud zadame presnot pro datovy typ int, nektere mezery se vyplni nulama
    
    char c1 = 'a';
    printf("%c - %d\n",c1,c1); //format c vypisuje znaky, pokud jej vypiseme jako cislo vrati znak a = 97 (podle pozice v ASCII tabulce)

    char c2 = 98;
    printf("%c - %d\n",c2,c2);

    return 0;
}

Jěště se podívejte na bonusový tutoriál, který se týká využití debuggeru ve IDE Qt Creator.

VBA – #2 Lekce – Výpis textu na obrazovku

V této lekci se naučíme používat msbgox. Jedná se o příkaz Windows a VBA ho pouze využívá. Msgbox využíváme pro zobrazení zprávy uživateli a jeho syntaxe je

MsgBox (prompt [, buttons + icons][ , title])

prompt (povinný) Zpráva zobrazená v okně hlášení

buttons (volitelný) Určuje tlačítka a ikony, které se v oknu hlášení objeví

upozornění windows

Tlačítka:

  • vbOKOnly
  • vbOKCancel
  • vbAbortRetryIgnore
  • vbYesNoCancel
  • vbYesNo
  • vbRetryCancel

Ikony:

  • vbCritical
  • vbQuestion
  • vbExclamation
  • vbInformation.

Pokud chceme buttons a title (obrázek viz ukázka vpravo) spojit dáme mezi ně + (tak jako je to použito v následujícím příkladu vbQuestion + vbOKOnly title se ukáže otazník a button bude vbOKOnly)

title (volitelný) Text, který se zobrazí v záhlaví okna hlášení. Standardní text je Microsoft Excel.

Příklad

Nejlépe si to vysvětlíme na jednoduchém příkladu:

Sub hello_world ()
MsgBox "Hello World", vbQuestion + vbOKOnly, "Tvůj první script"
End sub

Tento skript spustíme kliknutím v run > run macro nebo také f5. Po spuštění se vám vyskočí okno se zprávou hello world.

Vysvětlení kódu je jednoduché.

  1. Sub – v prvním řádku znamená že se jedna o subrutinu.
  2. Hello_world je název této subrutiny (v názvu nesmějí být mezery)
  3. MsgBox –příkaz který jsme si vyvolali
  4. „Hello World“, – zpráva (prompt)
  5.  vbQuestion + vbOKOnly , –to první je ikonka otazníku, a to druhé je tlačítko „ok“
  6.  „Tvůj první script“ – toto je zpráva v záhlaví bez toho by tam bylo „Microsoft Excel“
  7. End sub – nám ukazuje kde daná subrutina končí.

Závěr

Tímto končí  i naše první lekce sami si vyzkoušejte různé podoby msgboxu zkuste nakombinovat tlačítka a ikony a různé záhlaví okna. Příště se podíváme na proměnné a jejich datové typy.