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

Strukturované datové typy

Popis

Strukturované datové typy používáme pro uchování více hodnot, mezi kterými jsou určité vazby. Způsob strukturování určuje možný počet složek, charakter typů složek a operace přístupu ke složkám.

Strukturované typy se dělí na homogení (všechny položky struktury jsou stejného typu: řetězec) a heterogení (položky mohou být různého typu: záznam).

Vývojový diagram

Přirozený jazyk

JSA

NASM direktivy (v datovém segmentu)

řetězec
Definice inicializovaných dat s identifikátorem řetězce a ukončením cr lf $. $ oznamuje konec řetězce.
     str  db 'hello world!', 13, 10, '$' ; C++("hello world!\n")
     
Definice inicializovaných dat s identifikátorem řetězce a ukončením cr lf. Výpočtem délky řetězce nepotřebujeme ukončující znak.
     str     db 'hello world!', 13, 10
     str_len $ - str ; str_len = aktualni_adresa ($) - adresa_zacatku (str)
     

Pascal

array
Homogení pole. Typ položky pole může být libovolný další typ včetně pole. Pole může mít jeden nebo více (n) rozměrů. Indexy prvků pole definujeme intervalem.

pole celých čísel[ array.pas ]
type          {deklarace typu}
     {pole indexovano od 2 do 4 = 3 prvky}
     TPole = array [2..4] of integer;

const
     {konstantni inicializovane pole 3 celych cisel}
     const_pole : TPole = (2, 4, 6);

var           {deklarace promennych}
     pole : TPole; {pole 3 celych cisel}

{zacatek programu ... prikazova cast}
begin
    {naplneni pole}
    pole[2] := 1; {prvni prvek}
    pole[3] := 7; {druhy prvek}
    pole[4] := 9; {treti prvek}

    writeln('druhy prvek pole[3] = ', pole[3]);
    writeln('const_pole[3]= ', const_pole[3]);
end.



dvou rozměrné pole celých čísel[ array2.pas ]
type          {deklarace typu}
     {2D pole indexovano od 2*(2 do 4) = 6 prvku}
     TPole = array [1..2, 2..4] of integer;

var           {deklarace promennych}
     pole : TPole; {dve pole 3 celych cisel}

{zacatek programu ... prikazova cast}
begin
    {naplneni prvniho pole}
    pole[1,2] := 1; {prvni prvek}
    pole[1,3] := 7; {druhy prvek}
    pole[1,4] := 9; {treti prvek}

    {naplneni druheho pole}
    pole[2,2] := 2; {prvni prvek}
    pole[2,3] := 4; {druhy prvek}
    pole[2,4] := 6; {treti prvek}

    {vypis (= 4)}
    writeln('druhy prvek druheho pole= ', pole[2,3]);
end.

string
Řetězec znaků o maximální délce 255 znaků. Ordinální hodnota prvního indexu řetězce udává jeho aktuální délku (tj. znak 0..255).

řetězec[ string.pas ]
var           {deklarace promennych}
     str  : string; {promenna typu string o 255 znacich}
     str2 : string[5]; {promenna typu string o 5 znacich}
     delka : integer;
{zacatek programu ... prikazova cast}
begin
    {       12345678901234567890 = 20 }
    str := 'delka retezce str = ';

    {delkou retezce je ordinalni hodnota prvniho znaku}
    delka := ord( str[0] );

    writeln(str, delka);
end.

record
Záznam, heterogení datový typ obsahující položky různých typů.

záznam[ struct.pas ]
type          {deklarace typu}
     TKniha = record
         jmeno : string;     {retezec 255 znaku}
         cena  : integer;
         autor : string[10]; {retezec deseti znaku}
     end;

var           {deklarace promennych}
     kniha : TKniha; {promenna typu TKniha}

{zacatek programu ... prikazova cast}
begin
    {naplneni zaznamu}
    kniha.jmeno := 'C++ programovaci jazyk';
    {naplneni zaznamu pres prikaz with}
    with kniha do begin
        cena := 699;
        autor := 'Bjarne Stroustrup';
    end;

    writeln('jmeno = ', kniha.jmeno);
    writeln('cena  = ', kniha.cena);
    writeln('autor = ', kniha.autor);
end.

object
Třída je abstraktní datový datový typ. Spojuje data a operace (které lze na data aplikovat) do jednoho celku. (Object je nešťastné pojmenování namísto správnějšího označení class).

třída[ object.pas ]
type          {deklarace typu}
     TAutor = string[10];    {typ retezce deseti znaku}
     TKniha = object
       {atributy}
         jmeno : string;     {retezec 255 znaku}
         cena  : integer;
         autor : TAutor;

       {metody}
         constructor init; {konstruktor}
         procedure zadej(jm:string; c:integer; au:TAutor);
         procedure vypis;
     end;

var           {deklarace promennych}
     kniha : TKniha; {instance tridy TKniha}

constructor TKniha.init;
begin
    jmeno := 'nezadane';
    cena  := 0;
    autor := 'nezadane';
end;

procedure TKniha.zadej (jm:string; c:integer; au:TAutor);
begin
    jmeno := jm;
    cena  := c;
    autor := au;
end;

procedure TKniha.vypis;
begin
    writeln('vypis');
    writeln('  jmeno = ', jmeno);
    writeln('  cena  = ', cena);
    writeln('  autor = ', autor);
end;

{zacatek programu ... prikazova cast}
begin
    {konstruktor se nevola automaticky !}
    kniha.init;   {zavolani konstruktoru}
    kniha.vypis;

    { vyplneni obsahu }
    kniha.zadej('C++ programovaci jazyk', 699,
                'Bjarne Stroustrup');

    kniha.vypis;
end.

C/C++

array
Pole je homogení datový typ s pevným počtem prvků definovaným deklarací. Protože má první prvek pole vždy index 0, bude index posledního prvku o jedna menší než byla deklarovaná velikost pole. Proměnná typu pole je zároveň ukazatelem na první prvek a po přiřazení bude cílová proměnná typu pole pouze ukazovat na stejný první prvek namísto kopírování všech prvků.

char str[4]


pole znaků[ array1.cpp ]
int main (int argc, char *argv[]) {
    char str[4]; // pole znaku delky 4
    
    // naplneni pole
    str[0] = 'a';
    str[1] = 'b';
    str[2] = 'c';
    str[3] = 'd';

    return 0;
}



pole celých čísel[ array3.cpp ]
#include <stdio.h>
int main (int argc, char *argv[]) {
    int num[3]; // pole celych cisel delky 3
    num[0] = 1;
    num[1] = 7;
    num[2] = 9;
    
    //vytvoreni stejneho pole 'num' jinym zpusobem 
    // delku pole do [] doplni prekladac automaticky
    int num2[] = { 1, 7, 9}; 
    
    //vypis prvniho prvku pole num
    printf("prvni num[0]=%d\n", num[0]);    
    
    //zmena a vypis druheho prvku pole num2
    num2[1] = 5;
    printf("druhy num2[1]=%d\n", num2[1]);    
    
    return 0;
}

Každý další rozměr pole zapisujeme do samostatných [] závorek.

dvou rozměrné pole[ array5.cpp ]
#include <stdio.h>
int main (int argc, char *argv[]) {
    int num[2][3]; // dve pole celych cisel delky 3
    num[0][0] = 1; num[1][0] = 2;
    num[0][1] = 7; num[1][1] = 4;
    num[0][2] = 9; num[1][2] = 6;
    
    //vytvoreni stejneho pole 'num' jinym zpusobem 
    // delku pole do prvnich [] doplni prekladac automaticky
    // u dalsich rozmeru je rozmer nutne definovat
    int num2[][3] = { {1, 7, 9}, {2, 4, 6} }; 
    
    //vypis prvniho prvku druheho pole num (=2)
    printf("prvni num[1][0]=%d\n", num[1][0]);    
    
    //zmena a vypis druheho prvku prvniho pole num2
    num2[0][1] = 5;
    printf("druhy num2[0][1]=%d\n", num2[0][1]);    
    
    return 0;
}

string
Řetězce jsou v C++ pole znaků ukončené nulou (binárně 00000000).

řetězec[ array2.cpp ]
#include <stdio.h>
int main (int argc, char *argv[]) {
    // pole znaku delky 5 (4 + 1 pro nulu)
    // nula na konci bude pridana automaticky
    // delku pole do [] doplni prekladac take automaticky
    char str[] = "abcd"; 
    
    // to same co predchozi pole
    char str2[5];
    str2[0] = 'a';
    str2[1] = 'b';
    str2[2] = 'c';
    str2[3] = 'd';
    str2[4] = '\0'; // pridani nuly !

    // vypis obsahu pro srovnani (0 se nevypisuje)    
    printf("str[%s] ~ str2[%s]", str, str2);
    return 0;
}

struct
Záznam může obsahovat položky téměř libovolných typů. Pro zpřístupnění položek se používá operátor . tečka.

záznam[ struct.cpp ]
#include <stdio.h>  // printf()
#include <string.h> // copystr(), copystrn()

#define JMENO_MAX 40  // konstanta preprocesoru
#define AUTOR_MAX 10  // bude dosazena na mista vyskytu

int main (int argc, char *argv[]) {
    // novy datovy typ TKniha
    struct TKniha {
        char jmeno[JMENO_MAX];
        int  cena;
        char autor[AUTOR_MAX];
    }; // strednik !
    
    TKniha kniha; // promenna kniha typu TKniha
    
    // kopirovani retezce "C++ pr.." do polozky jmeno
    strcpy(kniha.jmeno, "C++ programovaci jazyk");
    kniha.cena = 699;
    
    // kopirovani retezce "Bjarn.." do polozky autor
    // zkopirovano bude maximalne AUTOR_MAX znaku
    strncpy(kniha.autor, "Bjarne Stroustrup", AUTOR_MAX);
    // pro AUTOR_MAX(10) je obsah kniha.autor "Bjarne Str"
    // retezec je nutne ukoncit nulou !        0123456789
    kniha.autor[AUTOR_MAX-1] = '\0';    // autor[9] = 0
    
    printf("jmeno [%s] \n", kniha.jmeno);
    printf("cena  [%d] \n", kniha.cena);
    printf("autor [%s] \n", kniha.autor);
    return 0;
}

Proměnou lze přímo inicializovat.

inicializovaný záznam[ struct2.cpp ]
#include <stdio.h>  // printf()
int main (int argc, char *argv[]) {
    // novy datovy typ TKniha
    struct TKniha {
        char *jmeno; 
        int  cena;
        char *autor;
    }; // strednik !
    
    // promenna kniha typu TKniha s inicializaci
    TKniha kniha = {
        "C++ programovaci jazyk",
        699, "Bjarne Stroustrup"
    };        

    // vypis    
    printf("jmeno [%s] \n", kniha.jmeno);
    printf("cena  [%d] \n", kniha.cena);
    printf("autor [%s] \n", kniha.autor);
    return 0;
}

class
Třída je abstraktní datový datový typ. Spojuje data a operace (které lze na data aplikovat) do jednoho celku.

třída[ class1.cpp ]
#include <stdio.h>  // printf()
#include <string.h> // copystr(), copystrn()

#define JMENO_MAX 40  // konstanta preprocesoru
#define AUTOR_MAX 10  // bude dosazena na mista vyskytu

class Kniha {
// atributy (data) :
    char jmeno[JMENO_MAX];
    int  cena;
    char autor[AUTOR_MAX];    
    
public:
// metody (operace) :    
    Kniha(); // konstruktor
    
    // zadani obsahu
    void zadej(char *jm, int c, char *au);
    
    // vypis obsahu
    void vypis();    
}; // strednik !

Kniha::Kniha() {
    printf("konstruktor Kniha() \n");
    // inicializace promennych (atributu tridy)
    jmeno[0] = '\0'; 
    autor[0] = '\0';    
    cena = 0;
}

void Kniha::zadej(char *jm, int c, char *au) {
    // kopirovani obsahu parametru
    strncpy(jmeno, jm, JMENO_MAX);
    cena = c;
    strncpy(autor, au, AUTOR_MAX);
    
    // pro jistotu ukonceni nulou
    jmeno[JMENO_MAX-1] = '\0'; 
    autor[AUTOR_MAX-1] = '\0';
}

void Kniha::vypis() {
    printf("vypis() \n");
    printf("  jmeno [%s] \n", jmeno);
    printf("  cena  [%d] \n", cena);
    printf("  autor [%s] \n", autor);    
}

int main (int argc, char *argv[]) {
    // vytvoreni zavola automaticky konstruktor
    Kniha kniha; 
    kniha.vypis(); // vypis
    
    // zadani obsahu 
    kniha.zadej("C++ programovaci jazyk", 699,
                "Bjarne Stroustrup");
    
    // vypis
    kniha.vypis();
    return 0;
}

Java

String
Řetězec je třídou standartního balíčku java.lang. Obsahuje kolem 70 metod pro manipulaci s daty včetně zpracování regulárních výrazů.

znakový řetězec[ retezec.java ]
package type;
public class retezec {
    public retezec() {
    }
    public static void main(String[] args) {
        String str; // promenna str typu String
        str = "abcd";
        
        String str2 = "efgh"; // promenna str2 typu String
        
        String str3;
        str3 = str + str2; // spojeni retezcu operatorem +
        
        // vypis vysledku spojeni retezcu
        System.out.println(" retezec [" + str3 + "]");
        
        str3 = str3 + 128; // pripojeni cisla 128
        System.out.println(" retezec [" + str3 + "]");        
        
        // pripojeni cisla 3.14
        // zkracenym zapisem souctu a prirazeni
        str3 += 3.14;  // str3 = str3 + 3.14;
        System.out.println(" retezec [" + str3 + "]");                
    }     
}

array
Pole je homogení datový typ s pevným počtem prvků. Počet prvků nedefinujeme deklarací, ale voláním konstruktoru příkazem new. Pole je také možné inicializovat při deklaraci (bez new). Protože má první prvek pole vždy index 0, bude index posledního prvku o jedna menší než byla deklarovaná velikost pole.

pole celých čísel[ array.java ]
package type;
public class array {
    public array() { // konstruktor
    }
    public static void main(String[] args) {
        int pole[]; // promenna typu pole celych cisel
        pole = new int[3]; // vytvoreni pole 3 cisel
        
        // inicializovana promenna typu pole 3 celych cisel
        int pole2[] = { 1, 7, 9 }; 
        
        // naplneni pole
        pole[0] = 1;
        pole[1] = 7;
        pole[2] = 9;
        
        // zmena a vypis druheho prvku
        pole[1] = 5;
        System.out.println("druhy prvek pole[1] = " + pole[1]);
        
        // vypis celeho pole
        System.out.println("pole: "+pole[0]+", "+pole[1]+", "+pole[2]);
    }
}

class
Třída je abstraktní datový datový typ. Spojuje data a operace (které lze na data aplikovat) do jednoho celku.

třída kniha[ trida.java ]
package type;

class Kniha {
 //atributy:  
    String jmeno;
    int    cena;
    String autor;
    
 //metody:    
    /** konstruktor */
    public Kniha() {
        System.out.println("konstruktor Kniha()");                
        // nastaveni vychozich hodnot
        zadej("nezadano", 0, "nezadano"); 
    }    
    
    public void zadej(String jm, int c, String au) {
        jmeno = jm;
        cena  = c;
        autor = au;
    }    
    
    public void vypis() {
        System.out.println("vypis()");        
        System.out.println(" jmeno : " + jmeno);
        System.out.println(" cena  : " + cena);
        System.out.println(" autor : " + autor);
    }    
}

public class trida {
    public trida() {
    }
    public static void main(String[] args) {
        Kniha kniha = new Kniha(); // vytvoreni instance tridy Kniha        
        kniha.vypis(); // vypis       
        
        // zadani obsahu 
        kniha.zadej("C++ programovaci jazyk", 699,
                    "Bjarne Stroustrup");
    
        // vypis
        kniha.vypis();        
    }    
}

JavaScript

Typ proměnné neuvádíme. Zvolí jej interpret podle kontextu proměnné.

string
'Řetězec znaků uzavřený v apostrofech' nebo "v uvozovkách". Uvozovky lze "vnořovat pomocí \"zpětného\" lomítka".
array
Pole může obsahovat prvky různého typu, které lze navíc přidávat i za běhu programu (nebo odebírat). Pole tedy nemá pevný počet prvků.

typy[ typy2.html ]
<html>            
  <head>
    <title>Strukturované datové typy</title>
  </head>
  
  <body>
    <script type="text/javascript">
      var retezec = 'vypis druheho prvku pole[1] = ';
      document.write(retezec);
      
      pole = new Array( 1, 7, 9 ); // pole 3 celych cisel     
      document.write(pole[1]);     // vypis druheho prvku
      
      document.write('<br/>'); // novy radek dokumentu
      
      // jiny zapis
      pole2 = [ 1, 7, 9 ]; // pole 3 celych cisel     
      pole2[0] = 3;  // zmena prvniho prvku 
      pole2[3] = '"retezec"'; // pridani ctvrteho prvku
      
      document.write("vypis pole2: <b>"+pole2[0]);
      document.write(", "+pole2[1]);
      document.write(", "+pole2[2]);
      document.write(", "+pole2[3]+"</b>");
    </script>
  </body>
</html>

record
Indexování pole řetězci místo celých čísel umožňuje použít pole (heterogení) také jako záznam.

záznam[ typy3.html ]
<html>            
  <head>
    <title>Strukturované datové typy</title>
  </head>
  
  <body>
    <script type="text/javascript">
      var kniha = new Array(); // kniha je typu pole

      // pridavani polozek se znakovym indexem
      kniha['jmeno'] = "C++ programovaci jazyk";
      kniha['cena']  = 699;
      kniha["autor"] = 'Bjarne Stroustrup';
      
      document.write("vypis: <br/>");
      document.write(" jmeno : "+kniha['jmeno']+"<br/>");
      document.write(" cena  : "+kniha['cena']+"<br/>");
      document.write(" autor : "+kniha['autor']);
    </script>
  </body>
</html>

object
Třídu definujeme pomoci funkce, která je konstruktorem tohoto typu. Identifikátor funkce je jménem třídy. Instanci třídy (objekt) vytvoříme příkazem new.

třída[ typy4.html ]
<html>            
  <head>
    <title>Třída</title>
  </head>
  
  <body>
    <script type="text/javascript">
      // preddefinovani metody pro tridu Kniha
      function zadej(jmeno, cena, autor) {
          this.jmeno = jmeno;
          this.cena  = cena;
          this.autor = autor;
      }
      // preddefinovani metody pro tridu Kniha
      function vypis() {
          document.write("vypis() <br/>");
          document.write(" jmeno : "+this.jmeno+"<br/>");
          document.write(" cena  : "+this.cena+"<br/>");
          document.write(" autor : "+this.autor+"<br/>");
      }
      
      //-------------------------------------------------
      // trida Kniha
      //-------------------------------------------------
      function Kniha(jmeno, cena, autor) {
        // atributy
          this.jmeno = jmeno;
          this.cena  = cena;
          this.autor = autor;
          
        // metody  (napojeni na preddefinove funkce)
          this.zadej = zadej;
          this.vypis = vypis;
      }
      //-------------------------------------------------

      // vytvoreni instance tridy Kniha
      var kniha = new Kniha;
      kniha.zadej("C++ programovaci jazyk", 699,
                  'Bjarne Stroustrup');
      kniha.vypis();

      // vytvoreni dalsi instance tridy Kniha
      // volanim konstruktoru
      var kniha2 = new Kniha("ZEN", 100, "Kolektiv autorů");
      kniha2.vypis();
      
    </script>
  </body>
</html>

Matlab

char
Pole znaků. Řetězce jsou reprezentovány jako vektory znaků.
      s = 'hello world';
     
structure
Záznam je heterogení datový typ a jeho položky tak mohou obsahovat libovolné další typy. Struktura je v Matlabu reprezentována polem. Strukturu je možné vytvořit najednou, voláním funkce struct() nebo jednotlivé položky přidávat postupně (výhoda interpretů).

struktura[ struct.m ]
% vytvoreni zaznamu 'kniha'
kniha.jmeno = 'C++ programovaci jazyk';
kniha.cena  = 699;
kniha.autor = 'Bjarne Stroustrup';

% vypis informaci o knize
kniha

% vypis jmena
kniha.jmeno

matice
Matice je označení pro pole o dvou rozměrech (m * n). Protože je matice základním datovým typem Matlabu, má jednoduchý zápis a existují pro ni i speciální operátory.

matice[ matrix.m ]
% vytvoreni prazdne matice (0 * 0)
 a = []

% matice o jednom radku (1 * m) zde 1*3
 b = [1 1 2]

% generovani matice o jednom radku 
  % od 2 do 10 s prirustkem 1
   auto = 2:10
  % od -10 do 10 s prirustkem 5
   auto = -10:5:10
  % od 0.0 do 1.0 s prirustkem 0.3
   auto = 0:0.3:1

% matice o vice radcich (n * m) zde 2*3
 c = [1 1 2; 3 2 1]
 
% generovani matice o vice radcich
 auto = [1:3; 4:6]

% matice o vice radcich (n * m) zde 3*2
 d = [4 5; 2 2; 1 1]

% nasobeni matic (i * j)*(j * k)
 e = c * d

array

PHP

Typ prmoměnné neurčuje programátor (explicitně), ale rozhoduje o něm PHP podle kontextu použití proměnné.

string

Řetězec je posloupnost znaků kde každý znak má ASCII hodnotu 0..255. Řetězce mohou být libovolné délky. Znak zapíšeme jako řetězec o délce 1.

Znaky v řetězci lze indexovat jako pole operátorem {}. Pro konkatenaci (spojování) řetězců existuje operátor tečka .

array
Hodnotou v poli může být jakýkoliv typ včetně dalšího pole. Pole je reprezentováno jako uspořádaná mapa se strukturou (klíč - hodnota). Položky pole se indexují operátorem []. Jako u ostatních interpretovaných jazyků umožňuje i PHP uchovávat v poli prvky různých typů (heterogení typ) a přidávání prvků za běhu programu.

typy[ types2.php ]
<html>            
  <head>
    <title>Datové typy 2</title>
  </head>
  
  <body>
    <?php
      //float
      $f1 = 0.1;
      $f2 = 2.1e3;
      $f3 = -3E2;
      $f4 = -3E-2;
      
      //string
      echo '<h4>string</h4>';
      echo 'float:  $f1 | $f2 | $f3 | $f4 ';
      echo '(řetězec v apostrofech nerozgeneruje proměnné)<br/>';
      
      // spojeni retezcu
      $s = 'hello';
      $s2 = $s . ' world !<br/>';
      echo $s2;
      
      // index
      echo "druhe pismeno '$s' je [", $s{1}, ']<br/>';
      
      //array
      echo '<h4>array</h4>';
      $pole = array(1, 3, 7); // pole 3 celych cisel
             
      //zmena a vypis druheho prvku             
      $pole[1] = 5;
      echo "druhy prvek pole[1]=$pole[1] <br/>";
      
      //pridani ctvrteho prvku typu retezec
      $pole[3] = '"retezec"';
      
      //vypis pole
      echo "pole : $pole[0], $pole[1], $pole[2], $pole[3]";
    ?>
  </body>
</html>

class
Třída je abstraktní datový datový typ. Spojuje data a operace (které lze na data aplikovat) do jednoho celku.

třída[ types4.php ]
<html>            
  <head>
    <title>Datové typy: class</title>
  </head>
  
  <body>
    <?php
      //class
      echo '<h4>class</h4>';      
      
      // --------------------------------------------------------------------
      // trida Kniha
      // --------------------------------------------------------------------
      class Kniha {
         var $jmeno;
         var $cena;
         var $autor;
         
         // konstruktor (stejne jmeno jako id tridy)
         function Kniha() {
            echo 'konstruktor Kniha()<br/>';
            $this->jmeno = 'nezadano';
            $this->cena  = 0;
            $this->autor = 'nezadano';
         }
         
         // zadani obsahu 
         function zadej($jm, $c, $au) {
            $this->jmeno = $jm;
            $this->cena  = $c;
            $this->autor = $au;
         }         
                  
         // vypis 
         function vypis() {
            echo 'metoda vypis()<br/>';
            echo " jméno: $this->jmeno <br/>";
            echo " cena : $this->cena <br/>";
            echo " autor: ", $this->autor;
         }         
      }
      // --------------------------------------------------------------------
      
      // vytvoreni objektu, instance tridy Kniha
      $kniha = new Kniha;
      // vytvoreni automaticky zavolalo konstruktor Kniha

      //vyplneni obsahu  
      $kniha->zadej("C++ programovaci jazyk", 699,
                    "Bjarne Stroustrup");
      
      //vypis obsahu  
      $kniha->vypis();
    ?>
  </body>
</html>

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