english version while1 - stránky o programování

Zápis programu

Popis

Zápisem programu odlišujeme jednotlivé jazyky. Zápis odpovídá formě, z jaké je překladač schopen převést zdrojový kód (Pascal, C++,... ) na kód cílový (strojový kód, bytecode). U interpretů (JavaScript, PHP) je zápis interpretovatelnou formou.

Kaľdý program má právě jeden vstupní bod (začátek).

Vývojový diagram

Graf.

Přirozený jazyk

Slovní popis. Typickým popisem úlohy v přirozeném jazyce jsou přípravy jídel v kuchařkách:

  • vstup(ingredience: vařič, pánev, vejce)
  • algoritmus
    1. zapni vařič
    2. na vařič dej pánev
    3. je pánev rozpálená ? ne - jdi do bodu 3. / ano - jdi do bodu 4.
    4. přidej vejce
    5. čekej 3 minuty
    6. vypni vařič
  • výstup (jídlo: smažené vejce)

Na předchozím příkladu si můžeme vysvětlit vlastnosti algoritmu:

  1. Determinovanost - jednotlivé kroky a jejich pořadí jsou přesně určeny. Smažené vejce (výstup) nezískáme pokud prohodíme body 1. a 6. Navíc prohozením 1. a 6. porušíme i vlastnost Rezultativnosti - vytvoříme tak totiž zacyklený program kde budeme v bodě 3. donekonečna čekat na rozpálenou pánev.
  2. Hromadnost - algoritmus lze použít pro řešení obecné úlohy. Podle stejného algoritmu usmažíme libovolný počet vajec.
  3. Rezultativnost - algoritmus vede po konečném počtu kroků k výsledku. Provedením algoritmu získáme smažené vejce [transformujeme vejce (vstup) na smažené vejce (výstup)].

JSA

Textové soubory (.asm) nebo vkládaný assembler v některém vyšším programovacím jazyce. Zápis odpovídá strojovým instrukcím vyjádřených symbolickým jménem. Například symbolické mov eax, 2 odpovídá 10111000 00000010 00000000 00000000 00000000 ve strojovém kódu (jde o přesun 32-bitového celého čísla do 32-bit registru eax).

Pro zápis existují dvě konvence: Intel a AT&T. Vkládaný Intel používá MS Visual C++ a AT&T zase překladače gcc (MinGW, Dev-C++). Opomineme-li obrácený zápis, má assembler AT&T "blíže" ke strojovému kódu než Intel a programování v něm dá více práce: například je nutné explicitně uvádět formát operandů instrukce (AT&T movb/movd/movl jako přesuň bajt/slovo/dvojslovo vs. Intel mov pro přesun bajtu, slova i dvojslova).

Dva následující kódy uloží hodnotu 2 do registru eax:

  • Intel: operace cíl, zdroj (mov eax, 2)
  • AT&T: operace zdroj, cíl (movl 2, %eax)

Věnujeme se procesorům s instrukční sadou x86 (386, 486, Pentium...) včetně klonů AMD. Jiné procesory budou mít zpravidla odlišnou instrukční sadu a uvedené příklady na ně nebudou přenositelné.

.asm

Zdrojové soubory lze překládat například překladačem NASM (Netwide Assembler pro Windows, Linux, Unix, FreeBSD).



kostra programu[ program.asm ]
;16-bitovy model
  bits 16

;zacatek casti s instrukcemi
  segment code 
	
;zacatek programu
..start: 
    ;nastaveni segmentu
    mov ax,DATA
    mov ds,ax       ;data segment
    mov ax,stack 
    mov ss,ax       ;stack segment
    mov sp,stacktop ;stack pointer

    ;TODO : vlozte svuj kod...
     mov ax, 2
     add ax, 2 ;v ax je 4 = 2 + 2

    mov ah,4ch      ;ukonceni programu
    int 21h

;data programu
  segment DATA

;rezervace pameti pro zasobnik
  segment stack stack 
        resb 1000
         
;vrchol zasobniku = adresa konce rezervovane pameti pro zasobnik
stacktop:	  

Vkládaný assembler Intel

Vkládaný assembler v MS Visual Studio C++ uzavřeme do bloku __asm { } .



__asm { }[ intel.cpp ]
#include <stdio.h>
int main(int argc, char *argv[]) {
  int c;
  
  __asm {
    mov eax, 2  ; eax = 2
    add eax, 2  ; eax = eax + 2
    mov c, eax  ; c   = eax
  }
  
  printf("vysledek 2+2=%d", c);
  return 0;
}

Vkládaný assembler AT&T

Vkládaný assembler pro překladače GCC uzavřeme do bloku asm ( );.



asm ( )[ att.cpp ]
#include <stdio.h>
int main(int argc, char *argv[]) {
    int c;
    
    asm (
          " movl $2, %%eax ; " /*  eax = 2         */
          " addl $2, %%eax ; " /*  eax = eax + 2   */
          " movl %%eax, %0 ; " /*  c   = eax       */   
             
          :"=r"(c)             /*  vystup do c     */
          :                    /*  vstup (prazdne) */
          :"%eax"              /*  pouzity registr */
        ); 
             
        
    printf("vysledek 2+2=%d", c);
    
  return 0;
}

Pascal

Pascal je jako vyšší programovací jazyk také modulární. Program se skladá z jednoho hlavního programu a libovolného počtu modulů (=jednotek). Jednotky mohou pro svou činnost používat další jednotky. Zdrojové souboy programu a jednotek mají příponu .pas.

Hlavní program



program[ fact1.pas ]
program faktorial; {nepovinne uvedeni jmena programu}

const         {deklarace konstant}
   X = 5;

type          {deklarace typu}
   TTyp = integer;

var           {deklarace promennych}
   vysledek : TTyp; {vysledek je typu integer}


{funkce  identifikator (parametry)   : typ funkce }
function fk            (n : integer) : integer;
 { lokalni deklarace const,type,var,function,procedure }
begin
  {rekurzivni zapis vypoctu faktorialu}
  if n = 0 then
    fk := 1
  else
    fk := fk(n-1) * n;
end;


{zacatek programu ... prikazova cast}
begin
  { vypocet faktorialu hodnoty konstanty X }
  vysledek := fk( X );

  {vypis vysledku (pro X=5 je fk(X)=5*4*3*2*1*1=120) }
  writeln('faktorial (',X,') = ',vysledek)
end.

Hlavní program používající jednotku



program[ fact.pas ]
program faktorial; {nepovinne uvedeni jmena programu}

uses func; {pripojeni jednotky s funkci fk() }

const         {deklarace konstant}
   X = 5;

type          {deklarace typu}
   TTyp = integer;

var           {deklarace promennych}
   vysledek : TTyp; {vysledek je typu integer}


{zacatek programu ... prikazova cast}
begin
  { vypocet faktorialu hodnoty konstanty X }
  vysledek := fk( X );

  {vypis vysledku (pro X=5 je fk(X)=5*4*3*2*1*1=120) }
  writeln('faktorial (',X,') = ',vysledek)
end.



jednotka[ func.pas ]
unit func;

{rozhrani jednotky : bude dostupne mimo jednotky }
interface

function fk (n : integer) : integer;



{implementace rozhrani jednotky}
implementation

{funkce  identifikator (parametry)   : typ funkce }
function fk            (n : integer) : integer;
 { lokalni deklarace const,type,var,function,procedure }
begin
  {rekurzivni zapis vypoctu faktorialu}
  if n = 0 then
    fk := 1
  else
    fk := fk(n-1) * n;
end;


{prikazova cast}
begin
  {pripadna inicializace jednotky}
end.

C/C++

Jazyk C je typický zástupce modulárních jazyků. Samotné C má jen minimální počet příkazů a všechny ostatní poskytují knihovny.

Právě jeden z modulů musí obsahovat funkci main() jako vstupní bod (=začátek) programu. Funkce main() bude zavolána jako první při spuštění programu.

Každý modul má své rozhraní (.h) kde je deklarováno co modul "nabízí". Pro C++ jako nástupce C platí to samé.

C

Moduly mají příponu .c.

C++

Moduly mají příponu .cc, .cpp, .cxx, .c++, .C podle překladače.

main()[ main.cpp ]
#include <stdio.h> //knihovna s funkci printf() 
#include "power.h" //knihovna s funkci power() 

// konstanty
const int X = 2;
const int E = 8;

int main (int argc, char *argv[]) {
   int vysledek;
   vysledek = power(X, E);   
   printf(" power(%d, %d) = %d", X, E, vysledek);
}



modul[ power.cpp ]
#include "power.h" //rozhrani knihovny

int power (int n, int e) {
   int r = 1;  
   while(e--) {
     r = r*n;
   }      
   return r;
}



rozhrani modulu power.cpp[ power.h ]
/* nasledujici dva radky zajisti, ze se rozhrani
   vlozi pouze jednou */
#ifndef POWER_H  
#define POWER_H

extern int power (int n, int e);

#endif  // POWER_H

Java

Program tvoří skupina tříd. Z nich má právě jedna metodu main (vstupní bod programu). Každá třída je zpravidla (i pro lepší přehlednost) v samostatném souboru .java. V jednom .java zdrojovém souboru může být nejvýše jedna třída veřejná (public).



main()[ hello.java ]
public class Main {
    
    /** Prazdny konstruktor tridy Main */
    public Main() {
    }
    
    /**
     * @param args argumenty z prikazoveho radku
     */
    public static void main(String[] args) {
        System.out.println("ahoj svete!");
    }
}

JavaScript

Zápis v HTML

Vložený kód uvnitř <script> bude automaticky proveden v průběhu zobrazení stránky. </script>



v html[ zapis1.html ]
<html>            
  <head>
    <title>Zapis1</title>
  </head>
  
  <body>
    <script type="text/javascript">
      document.write("Vypsano JavaScriptem");
    </script>
  </body>
</html>

Externí soubor .js

Jméno souboru jako atribut <script>. Kód uvnitř .js souboru bude automaticky proveden v průběhu zobrazení stránky. Zápis je vhodný pro funkce.



skript[ den.js ]

document.write("Vypsano externim JavaScriptem");

function  den() {
   var date = new Date();
   window.alert('dnes je '+date.getDate()+'.'+(1 + date.getMonth())+'.');
}



atribut[ zapis2.html ]
<html>            
  <head>
    <title>Zapis2</title>
  </head>
  
  <body>
    <script type="text/javascript" src="den.js">
    </script>
  </body>
</html>

Událost (s funkcí v externím souboru)



udalost onclick[ zapis3.html ]
<html>            
  <head>
    <title>Zapis3</title>
  </head>
  
  <body>
    <script type="text/javascript" src="den.js">
    </script>
    
    <b onclick="den();">klikni mysi na tucny text</b>
  </body>
</html>

Matlab

Interaktivní režim

Postupný zápis příkazů do Command window. Středník za příkazem potlačí výstup výsledku příkazu. V následujícím příkladě přiřadíme do a součet 2+2. Matlab dosud proměnou a nezná a automaticky ji vytvoří (přidělí paměť) jako typ double (desetinné číslo s dvojitou přesností).

>> a = 2+2 a = 4

Dávkový soubor (.m)

Vytvořením nového souboru euklid.m se z něj pro Matlab stane nový příkaz euklid, spojený s funkcí euklid uvnitř .m souboru (jméno funkce a jméno souboru jsou shodné).



přidání nové funkce[ euklid.m ]
function max = euklid(a, b);
% funkce euklid (Eukliduv algoritmus)
% nejvetsi spolecny delitel cisel a,b
% ------------------------------------------------
% vstup   a,b ... povinne
% vystup  max ... nejvetsi spolecny delitel
% ------------------------------------------------
while b~=a      %dokud je b ruzne od a
   if a>b       %a je vetsi nez b
      a = a-b;  %sniz a o b
   else         %a je mensi nez b
      b = b-a;  %sniz b o a
   end
end
max = a;  %vysledek (a == b)

volání funkce
>> c = euklid(2,18) c = 2

Aplikace (.fig)

V Matlabu lze poměrně snadno vytvářet také aplikace s GUI (grafickým rozhraním). Následující ukázka aplikace počítá všechny největší společné dělitele zadaného čísla (editační pole) s číselnou osou 1 až 20. Návrh aplikace .fig obsahuje: editační pole, tlačítko a graf. Pro stisk tlačítka byl přidán krátký kód pro výpočet a výstup do grafu.

návrh aplikace
návrh aplikace
výsledná aplikace
výsledná aplikace
zdrojový kód aplikace [gui.m]
návrh aplikace [gui.fig]

PHP

Zápis pro HTML



html[ zapis1.php ]
<html>            
  <head>
    <title>Zapis1</title>
  </head>
  
  <body>
    <?php
      echo "Vygenerovano PHP skriptem";
    ?>
  </body>
</html>



html[ zapis2.php ]
<html>            
  <head>
    <title>Zapis2</title>
  </head>
  
  <body>
    <script language="php" >
      echo "Vygenerovano PHP skriptem";
    </script>
  </body>
</html>

Externí soubor s funkcemi



modul[ funkce.php ]
<?php

function GetIP() {
	    $ip1=getenv('REMOTE_ADDR');
	    $ip2=getenv('HTTP_X_FORWARDED_FOR');

	    if ($ip2!='' and ip2long($ip2)!=-1) 
		    $finalIP=$ip2; 
	    else 
		    $finalIP=$ip1;

	    $finalIP=substr($finalIP,0,15);
	    return $finalIP;
}

 ?>




html[ zapis3.php ]
<html>            
  <head>
    <title>Funkce</title>
  </head>
  
  <body>
    <?php
      include "funkce.php"; // pripojeni souboru s funkcemi
      
      $ip = GetIP();
      echo "Vase IP adresa je: <b>", $ip,"</b><br/>";
      echo "hostname : <b>", gethostbyaddr($ip),"</b>";
    ?>
  </body>
</html>

Kontakt
Prohlášení o dostupnosti
Tisk stránky
Autor: Václav Bubník © 2005
vbubnik@post.cz
XHTML 1.0| CSS