2024(e)ko abenduaren 1(a), igandea

Datu-moten taula

C lengoaian erabiltzen diren datu-motak hurrengo taulan ematen dira. Ikastaro honetan garatuko diren programetarako ez ditugu denak beharko, ezinbestekoak hauek dira: char karaktereak gordetzeko, int eta long kopuru osoak gordetzeko eta float zenbaki errealekin lan egiteko.

Karaktere-aldagai baten tamaina 1 bytetik gora handitu behar bada, wchar_t mota erabil daiteke; edo float motako aldagai baten tamaina 4 bytetik 8 bytera handitu behar bada, double mota erabiltzen da, funtsean tamaina bikoitzeko float bat dena. Nahiz eta char eta float neurri estandar horiekin oinarrizko programa gehienak garatu ohi diren, baina agian etorkizunean besteak erabili behar izango dira.


Datu-motak, tamaina memorian eta heina
Datu-motaMemoriaHeinaIkasi
char 1 byte [-128..+127] BAI
signed char 1 byte [-128..+127] EZ
unsigned char 1 byte [0..+255] EZ
wchar_t 2 — 4 byte EZ
int 2 byte
4 byte		 [-32768..+32767]
[-2147483648..+2147483647]		 BAI
signed int 4 byte [-2147483648..+2147483647] EZ
unsigned int 4 byte [0..+4294967295] EZ
short int 2 byte [-32768..+32767] EZ
signed short int 2 byte [-32768..+32767] EZ
unsigned short int 2 byte [0..+65535] EZ
long 4 byte [-2147483648..+2147483647] BAI
long int 4 byte [-2147483648..+2147483647] EZ
signed long int 4 byte [-2147483648..+2147483647] EZ
unsigned long int 4 byte [0..+4294967295] EZ
float 4 byte [-3.4e+38, -3.4e-38], 0.0,
[+3.4e-38, +3.4e+38]		 BAI
double 8 byte [-1.7e+308, -1.7e-308], 0.0,
[+1.7e-308, +1.7e+308]		 BAI
long double 16 byte [-3.4e-4932, -1.1e+4932], 0.0,
[+3.4e-4932, +1.1e+4932]		 EZ


Eskubiko zutabearen bitartez adierazten da datu-mota guzti horietatik zeintzuk erabiliko ditugun, BAI marka dituztenak.


Hona hemen, goiko taula hori azaltzen duen programa. Jakitun gara une honetan, ikastaroaren hasieran, ikasleak ez duela kodea ulertuko, baina bai gai izango dela programa exekutatzeko eta bere irteera aztertzeko: 

/******************** 00_DatuMotak-1_Neurriak.c hasiera ********************/

#include <stdio.h>
#include <limits.h>

int main()
{
   printf("\n\n");
   printf("\n--------------------------------------------------------------------");
   printf("\n 'limits.h' fitxategian definitutako konstante osoak:");
   printf("\n \t - CHAR_MAX  =  %d", CHAR_MAX);
   printf("\n \t - CHAR_MIN  =  %d", CHAR_MIN);
   printf("\n \t - UCHAR_MAX =  %d", UCHAR_MAX);
   printf("\n \t - SHRT_MAX  =  %d", SHRT_MAX);
   printf("\n \t - SHRT_MIN  =  %d", SHRT_MIN);
   printf("\n \t - USHRT_MAX =  %d", USHRT_MAX);
   printf("\n \t - INT_MAX   =  %d", INT_MAX);
   printf("\n \t - INT_MIN   =  %d", INT_MIN);
   printf("\n \t - UINT_MAX  =  %u", UINT_MAX);
   printf("\n \t - LONG_MAX  = %li", LONG_MAX);
   printf("\n \t - LONG_MIN  = %li", LONG_MIN);
   printf("\n \t - ULONG_MAX = %lu", ULONG_MAX);
   printf("\n--------------------------------------------------------------------");
   printf("\n\n");

   printf("\n================================================================================");
   printf("\n  1. sizeof(char)          = %d  [-128..127]", (int)sizeof(char));
   printf("\n  2. sizeof(unsigned char) = %d  [0..255]", (int)sizeof(unsigned char));
   printf("\n");

   printf("\n  1. sizeof(int)                = %d [-2147483648..2147483647]", (int)sizeof(int));
   printf("\n  2. sizeof(short int | short)  = %d [-32768..32767]", (int)sizeof(short int));
   printf("\n  3. sizeof(short)              = %d [-32768..32767]", (int)sizeof(short));
   printf("\n  4. sizeof(unsigned int)       = %d [0..%u]", (int)sizeof(unsigned int), UINT_MAX);
   printf("\n  5. sizeof(unsigned short int) = %d [0..65535]", (int)sizeof(unsigned short int));
   printf("\n  6. sizeof(unsigned sort)      = %d [0..65535]", (int)sizeof(unsigned short));
   printf("\n  7. sizeof(long)               = %d [%li..%li]", (int)sizeof(long), LONG_MIN, LONG_MAX);
   printf("\n  8. sizeof(long int | long)    = %d [%li..%li]", (int)sizeof(long int), LONG_MIN, LONG_MAX);
   printf("\n  9. sizeof(unsigned long int)  = %d [0..%lu]", (int)sizeof(unsigned long int), ULONG_MAX);
   printf("\n 10. sizeof(unsigned long)      = %d [0..%lu]", (int)sizeof(unsigned long), ULONG_MAX);
   printf("\n");

   printf("\n  1. sizeof(float)       =  %d [-3.4E+38..-3.4E-38..0..+3.4E-38..+3.4E+38]", (int)sizeof(float));
   printf("\n  2. sizeof(double)      =  %d [-1.7E+308..-1.7E-308..0..+1.7E-308..+1.7E+308]", (int)sizeof(double));
   printf("\n  3. sizeof(long double) = %d [-3.4E+4932..-1.1E-4932..0..3.4E-4932..1.1E+4932]", (int)sizeof(long double));
   printf("\n================================================================================");
   printf("\n\n");

   char cLetra               = (char)(61);  // '='
   unsigned char ucLetra     = (char)(165); // 'Ñ'
   int iZbk                  = INT_MIN;     // (-2147483647-1)
   unsigned int uiKont       = UINT_MAX;    // 4294967295  0xffffffff
   short shZbk               = SHRT_MAX;    // 32767
   unsigned short int ushZbk = USHRT_MAX;   // 65535
   long lZbk                 = LONG_MAX;    // 9223372036854775807   0x7fffffffffffffffL
   unsigned long ulZbk       = ULONG_MAX;   // 18446744073709551615  0xffffffffffffffffUL
   float fZbk                = -6123.087;
   double dbZbk              = 2999945.031;

   printf("\n--------------------------------------------------------------------");
   printf("\n Aldagaietarako gehien erabiliko ditugun datu-motak:");
   printf("\n \t -           char cLetra  =  ('%c', %d, %X, %o) adibidez", cLetra, cLetra, cLetra, cLetra);
   printf("\n \t -              int iZbk  =  (%d) txikiena", iZbk);
   printf("\n \t -             long lZbk  =  (%li) handiena", lZbk);
   printf("\n \t -            float fZbk  =  (%.2f) adibidez", fZbk);
   printf("\n");
   printf("\n Aldagaietarako oso gutxitan erabiliko ditugun datu-motak:");
   printf("\n \t - unsigned char ucLetra  =  ('%c', %d, %X, %o) adibidez", ucLetra, ucLetra, ucLetra, ucLetra);
   printf("\n \t -           short shZbk  =  (%d) handiena", shZbk);
   printf("\n \t -   unsigned int uiKont  =  (%u) handiena", uiKont);
   printf("\n \t - unsigned short ushZbk  =  (%d) handiena", ushZbk);
   printf("\n \t -   unsigned long ulZbk  =  (%lu) handiena", ulZbk);
   printf("\n \t -          double dbZbk  =  (%.2lf) adibidez", dbZbk);
   printf("\n--------------------------------------------------------------------");
   printf("\n\n");

   return 0;
}

/******************** 00_DatuMotak-1_Neurriak.c amaiera ********************/

Laburbilduz, gure programetan zenbaki osokoentzat erabiliko ditugun datu-motak short, int eta long izango dira:

Datu-motaFormatua Balio kopurua 2N  Balioen heina edo barrutia
 char 
8 bit (+ eta -)
256
-128..127
unsigned char
8 bit (+)
256
0..255
 short int 
16 bit (+ eta -)
65536
-32768..32767
 short 
16 bit (+ eta -)
65536
-32768..32767
unsigned short
16 bit (+)
65536
0..65535
 int 
 int 
16 bit (+ eta -)
 32 bit (+ eta -)
65536
4294967296
-32768..32767
-2147483648..2147483647
unsigned int
32 bit (+)
4294967296
0..4294967295
 long int 
32 bit (+ eta -)
4294967296
 -2147483648..2147483647 
 long 
32 bit (+ eta -)
4294967296
 -2147483648..2147483647 



Zenbakiak: zenbatzeko ala neurtzeko?



ZENBAKIAREN KONTZEPTUA

Zenbakia kontzeptua funtsezkoa da gizarteko komunikazio eta harremanetarako. Hizkera orokor arruntean, zenbakiek etengabeko presentzia dute, objektuak zenbatzeko eta objektuak neurtzeko ohitura baitugu, eta bai zenbatzean zein neurtzean zenbakiak erabili behar baititugu.

Zenbatu eta neurtu aditzak nahasirik erabil daitezke hizkera orokorrean, baina teknikan eta zientzian bereizi behar ditugu bakoitzak ekintza desberdina adierazten duelako. Nahiz eta ekintza bietan zenbakiak erabili gauza bat da zenbatu eta beste gauza bat da neurtu.

ADITZA ERAGIKETA EMAITZA OBJEKTUAK
Zenbatu
Zenbaketa
Kopurua
Zenbakagarriak (diskretuak)
Neurtu
Neurketa
Neurria
Zenbakaitzak (jarraituak)

Zenbatu

Zehatz hitz eginda, zenbatu aditzak mota bereko zenbat objektu dauden kontatzea adierazten du. Beraz, zenbatu aditzaren esanahia kontaketarekin loturik dago eta dagokion eragiketa zenbaketa deitzen da. Zenbaketa eragiketaren emaitza kopurua da, hots, zenbat objektu dauden esatea.

Zer esanik ez, zenbatu ahal izateko, objektuek edo magnitudeek diskretuak izan behar dute, zenbakagarriak alegia, eta zenbaketaren emaitza zenbaki osoa izango da.

C programazio-lengoaian zenbaki osoak adierazteko ondoko datu-motak erabiliko ditugu nagusiki:
  • char
  • int
  • long
Neurtu

Bestalde, neurtu aditzak honako ekintza adierazten du: objektu edo magnitude fisiko jakin baten neurrian, unitatea zenbat aldiz sartzen den kalkulatzea. Beraz, neurtu aditzaren esanahia konparaketa batekin loturik dago eta dagokion eragiketa neurketa deitzen da. Neurketa eragiketaren emaitza neurria da, hots, magnitude fisikoa zein tamainatakoa den esatea.

Neurtu ahal izateko, magnitude fisikoek jarraituak izan behar dute, zenbakaitzak edo ez-zenbakagarriak alegia, eta neurketaren emaitza zenbaki ez-osoa izango da (edo bestela esanik zenbaki erreal).

C programazio-lengoaian zenbaki ez-osoak adierazteko ondoko datu-motak erabiliko ditugu:
  • float
  • double

 
ordua:
Etiketak: ,

iruzkinik ez:

Argitaratu iruzkina

Harpidetu honetara: Argitaratu iruzkinak (Atom)