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

Jednoduché datové typy

Popis

Jednoduché datové typy lze dále rozdělit na standartní (dané jazykem) a programátorem definované (výčty a intervaly).

Také je lze dělit na ordinální (u každé hodnoty lze určit jejího následníka/předchůdce) a neordinální (reálná čísla).

Vývojový diagram

Přirozený jazyk

JSA

Za použitelné datové typy lze považovat dostupné registry procesoru.

celá čísla (datové registry)

V každém registru lze adresovat skupiny E (32 bitů), X (dolních 16 bitů), H (horních 8 bitů skupiny X)a L (dolních 8 bitů skupiny X). Pokud do registru EAX uložíme hodnotu 127006 (1 1111 0000 0001 1110) budou hodnoty AX 61470 (1111 0000 0001 1110), AH 240 (1111 0000) a AL 30 (0001 1110).

       E 31             X 15   H   7   L   0
         +----------------+--------+--------+
     EAX |                |   AH   |   AL   | AX  násobení,dělení
     EBX |                |   BH   |   BL   | BX  
     ECX |                |   CH   |   CL   | CX  čitač opakování smyček
     EDX |                |   DH   |   DL   | DX  
         +----------------+--------+--------+
         |              1 |11110000|00011110| priklad: 127006
         |                |        |     110| priklad: 6
         |                |      11|11101000| priklad: 1000 (dekadicky)
         +----------------+--------+--------+ 
     

Registr obsahuje šest typů najednou. Podle skupiny registru a reprezentace hodnoty jako bezznaménkové(unsigned) nebo se znaménkem(signed):

  • E 0..4294967295 (-2147483648..2147483647)
  • X 0..65536 (-32768..32767)
  • HL 0..255 (-128..127)
reálná čísla (datové registry numerického koprocesoru)
8 registrů reálných čísel.
NASM (.asm) direktivy v datovém segmentu
[jméno] direktiva <operandy>

Jméno je identifikátorem proměnné. Direktiva vyhradí její místo v paměti a inicializuje ho hodnotou.

  • db : byte/shortint (db 'string', 0xff, 11101000b, -55)
  • dw : integer/offset (dw 42767)
  • dd : DWord/single (dd 12345678h)
  • dq : double (dq 3.14e15)
  • dt : extendet (dt 1.5e-15)

Direktivy neinicializovaných proměnných (resb, resw, resd, resq, rest), pouze vyhradí místo v paměti. Například vstup resb 20 vyhradí místo 20 bajtů označené jako vstup.

Direktiva konstant (equ). Například max equ 7 vytvoří proměnnou max o hodnotě 7.

Pascal

standartní

boolean
Proměnné logického typu pravda, nepravda. Množina hodnot: {false, true}. Přípustné operace: {and, or, not, succ, pred, ord}, relační operátory: {<, >, =, >=, <=, <>}.
  • and, logický součin
  • or, logický součet
  • not, negace [not true=false]
  • succ, vrací hodnotu následníka [succ(2)=3]
  • pred, vrací hodnotu předchůdce [pred(2)=1]
  • ord, ordinální hodnota [ord(false)=0; ord(true)=1]
    a       b       a and b  a or b  ord(b)  not(b)
    -----------------------------------------------
    false   false   false    false    0       true
    false   true    false    true     1       false
    true    false   false    true     0       true
    true    true    true     true     1       false
    
shortInt
8-bitové číslo se znaménkem.
byte
8-bitové číslo bez znaménka.
integer
16-bitové číslo se znaménkem. Množina hodnot je podmnožinou množiny celých čísel (zobrazení je limitováno velikostí registru). Operace: {+, -, *, dif, mod, relační operátory, trunc(), round(), odd()}.
  • dif, celočíselné dělení [5 div 2 = 2]
  • mod, zbytek celočíselného dělení [5 mod 2 = 1]
  • trunc(x), odseknutí desetiné části reálného čísla [trunc(2.8)=2]
  • round(x), zaokrouhlení reálného čísla (+- 0.5) [round(2.8)=3]
  • odd(x), vrací hodnotu true pokud je x liché číslo [odd(2)=false]
word
16-bitové číslo bez znaménka.
longInt
32-bitové číslo se znaménkem.
single
32-bitové reálné číslo.
real
48-bitové reálné číslo. Operace: {+, -, *, /, relační operátory, trunc(), round() }.
double
64-bitové reálné číslo.
extended
80-bitové reálné číslo.
char
Množinou hodnot je množina znaků ASCII tabulky (256 znaků). Operace: { relační operátory }.
  • ord(x), ordinální(pořadové) číslo znaku v množině [ord('A')=65]
  • chr(x), znak jehož ordinální hodnota je x [chr(65)='A'] [chr(ord(x))=x]

programátorem definovaný

výčtový typ
Množinu hodnot definujeme jejich vyjmenováním. Přípustné operace {succ, pred, ord}.
      type  dny = (po, ut, st, ct, pa, so, ne);
     
interval
Interval vytváříme nad hodnotami již definovaného typu, který nazýváme typ vázaný. Definujeme dolní a horní mez hodnot intervalu nad daným typem.
      type  pracovni_dny = po .. pa;  
                   datum = 1 .. 31;
     

C/C++

Všechna celá čísla mohou začínat explicitním uvedením signed, pro čísla se znaménkem nebo unsigned, pro čísla bez znaménka. Mimo změnu rozsahu hodnot čísla způsobí signed/unsigned i rozdíl v rychlosti programu. Bez explicitního uvedení bude vybrán "nejrychlejší" nebo dostupný typ na daném hardware.

Přesná velikost typů není zaručena a závisí na hardware kde program překládáme. Vždy ale platí : sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) dále sizeof(float) <= sizeof(double) <= sizeof(long double). Pro velikost signed/unsigned platí : sizeof(typ) = sizeof(signed typ) = sizeof(unsigned typ) kde typ je z {char, short, int, long}.

typy od normy C99

bool
Logický typ s hodnotou true/false.
float complex
Komplexní číslo.
long long int
Celé číslo 64 bitů.

celá čísla

char

Nejvhodnější typ pro uchování znaků nejčastěji jako 8-bitový byte. Velikost objektů se vyjadřuje pomocí násobku velikosti sizeof(char), která odpovídá jedné.

Char má nejméně 8 bitů s rozsahem 0..255 (unsigned char) a -128..127 (signed char).

short int

Short má nejméně 16 bitů s rozsahem 0..65535 (unsigned short int) a -32768..32767 (signed short int).

int

Proměnná typu int (bez signed/unsigned) by měla být nejčastěji používaná. Její velikost bude vždy taková aby na dané architektuře dosahovala maximální rychlosti. Proto i pro proměnné,které nikdy nebudou záporných hodnot, raději použijeme int namísto unsigned int.

Na 16-bitovém procesoru bude int také 16-bitový! Int má nejméně 16 bitů s rozsahem 0..65535 (unsigned short int) a -32768..32767 (signed short int). Na 32-bitovém procesuru má int 32 bitů s rozsahem 0..4294967295 (unsigned int) a -2147483648..2147483647 (signed int).

long int

Long má nejméně 32 bitů s rozsahem 0..4294967295 (unsigned int) a -2147483648..2147483647 (signed int). Na 64-bitovém procesuru má long 64 bitů s rozsahem 0..18446744073709551615 (unsigned long int) a -9223372036854775808..9223372036854775807 (signed long int).

reálná čísla

float
Malá přesnost, vždy 32 bitů.
double
Dvojnásobná přesnost, vždy 64 bitů.
long double
Přesnost na 96 bitů.

test velikosti a rozsahu


32-bitové Pentium 4


test[ size.cpp ]
#include <stdio.h>
#include <limits.h>
#include <float.h>

int main (int argc, char *argv[]) {
    printf("      typ \t velikost[B] \t rozsah \n");
    printf("--------------------------------------- \n");
    printf("         char \t  %d  \t <%d..%d> \n", sizeof(char), CHAR_MIN, CHAR_MAX);
    printf("unsigned char \t  %d  \t <%d..%d> \n", sizeof(unsigned char), 0, UCHAR_MAX);
    
    printf("         short \t  %d  \t <%d..%d> \n", sizeof(short), SHRT_MIN, SHRT_MAX);
    printf("unsigned short \t  %d  \t <%d..%d> \n", sizeof(unsigned short), 0, USHRT_MAX);
    
    printf("         int \t  %d  \t <%d..%d> \n", sizeof(int), INT_MIN, INT_MAX);
    printf("unsigned int \t  %d  \t <%d..%u> \n", sizeof(unsigned int), 0, UINT_MAX);
    
    printf("         long \t  %d  \t <%ld..%ld> \n", sizeof(long), LONG_MIN, LONG_MAX);
    printf("unsigned long \t  %d  \t <%d..%lu> \n", sizeof(unsigned long), 0, ULONG_MAX);

    printf("         float \t  %d  \t <%g..%g> \n", sizeof(float), FLT_MIN, FLT_MAX);
    printf("        double \t  %d  \t <%g..%g> \n", sizeof(double), DBL_MIN, DBL_MAX);     
    printf("   long double \t  %d  \t \n", sizeof(long double));
    
    printf("         bool \t  %d  \t <%d..%d> \n", sizeof(bool), false, true);
    
    char *i; // ukazatel na i
    printf("         ptr  \t  %d   \n", sizeof(i));
    return 0;
}

programátorem definované

enum
Výčtový typ definujeme vyjmenováním všech požadovaných hodnot. Tím určíme množinu hodnot, kterých může nabývat proměnná tohoto typu.

enum[ enum.cpp ]
#include <stdio.h>
int main (int argc, char *argv[]) {
    // vyctovy typ barva 
    enum TBarva { CERVENA, ZELENA, MODRA };
    
    TBarva barva; // promenna vyctoveho typu
    barva = CERVENA;    
    barva = ZELENA;
    barva = MODRA;
    
    return 0;
}

Java

Typy jsou rozděleny na numerické a typ boolean. Numerické typy se dále dělí na celá čísla (byte short int long char) a reálná čísla (float double).

boolean

boolean
Nabývá hodnot true nebo false. Výchozí hodnota je false.

celá čísla

char
16-bitová hodnota reprezentující znak ve formátu UNICODE (UTF-16). Výchozí hodnota '\u0000'. Rozsah <0..65535>.
byte
8-bitové celé číslo o rozsahu -128..127 s výchozí hodnotou 0.
short
16-bitové celé číslo o rozsahu -32768..32767 s výchozí hodnotou 0.
int
32-bitové celé číslo o rozsahu -2147483648..2147483647 s výchozí hodnotou 0.
long
64-bitové celé číslo o rozsahu -9223372036854775808..9223372036854775807 s výchozí hodnotou 0L.

reálná čísla

float
32-bitové reálné číslo s jednoduchou přesností a výchozí hodnotou 0.0f.
double
64-bitové reálné číslo s dvojnásobnou přesností a výchozí hodnotou 0.0d.

JavaScript

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

boolean
Nabývá hodnot true nebo false.
      var zapnuto = true;
     
char
Znak jako řetězec o délce 1.
     var pismeno = 'a';
     
integer
Celé číslo.
      var rok = 1984;
     


typy[ typy1.html ]
<html>            
  <head>
    <title>Jednoduché datové typy</title>
  </head>
  
  <body>
    <script type="text/javascript">
      var zapnuto = true; // deklarace promenne s inicializaci na true
      var pismeno;        // deklarace promenne bez inicializace
      var rok = 1984;          
      
      pismeno = 'a';
      
      document.write("zapnuto " + zapnuto + "<br/>");
      document.write("pismeno "+pismeno+"<br/>");
      document.write("rok "+rok);
    </script>
  </body>
</html>

Matlab

Všechny typy reprezentovány jako matice (pole m*n), u jednoduchých typů o rozměrech 1*1. Pokud neuvedeme typ explicitně je výchozím typem reálné číslo (double).

integer
8 podtypů podle rozlišení znaménka a počtu vyhrazených bitů (int8/16/32/64 nebo bez znaménka uint8/16/32/64).
      i =  uint8(255);
      i =  int8(120);
      i =  int16(32000);
     
complex
Komplexní čísla s volitelnou imaginární jednotkou i nebo j.
       c = 1 + 2i;
       c = complex(1, 2);
     
single
32 bitová reálná čísla s menším rozsahem sice šetří paměť, ale mohou způsobit nepřesnosti například při součtu velkého počtu velmi malých čísel.
double
64 bitová reálná čísla.
      pi = 3.14;
     
logical
Logická hodnota 1 (true) a 0 (false).
      1 > 2 
      ans
          0
     
char
Znak je řetězcem o délce 1.
      znak = 'a';
     

PHP

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

boolean

Nabývá hodnot TRUE nebo FALSE, u kterých se nerozlišují velká a malá písmena (lze zapsat True, true, TRUE).

Při převodu z jiných typů (například jako vyhodnocování podmínky) pro False platí (ostatní hodnoty budou True):

  • 0 integer
  • 0.0 float
  • "0" a prázdný řetězec
  • pole s nulovým počtem prvků
  • objekt s nulovým počtem prvků
  • typ NULL
integer

Celočíselný typ (Z={..., -2, -1, 0, 1, 2, ...}) o základu 10 (decimální), 8 (oktalové začíná 0) nebo 16 (hexadecimální začíná 0x).

Volitelně může začínat i unárním operátorem (- nebo +). Maximální hodnota je závislá na použité platformě a obvykle bývá 32 bitů.

float
Reálné číslo s přesností (závislé na platformě) nejčastěji 64 bitů.
NULL
Typ NULL reprezentuje proměnnou, která nemá žádnou hodnotu.
      $prazdna_promenna = NULL;
     


typy[ types1.php ]
<html>            
  <head>
    <title>Datové typy 1</title>
  </head>
  
  <body>
    <?php
      // boolean      
      $b = True;
      
      //integer
      $i1 = 15; // desitkove
      $i1 = -1; // desitkove
      
      $i2 = 0777;  // oktalove
      $i2 = +0777; // oktalove
      
      $i3 = -0x21; // hexadecimalni
      $i3 = 0xff;  // hexadecimalni
      echo "int: ", $i1," | ", $i2," | ", $i3,"<br/>";
      
      //float
      $f1 = 0.1;
      $f2 = 2.1e3;
      $f3 = -3E2;
      $f4 = -3E-2;
      echo "float:  $f1 | $f2 | $f3 | $f4 <br/>";

    ?>
  </body>
</html>

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