Typy premenných v avr-gcc: Rozdiel medzi revíziami
Z SensorWiki
(→Aritmetické operácie so základnými typmi) |
|||
| Riadok 86: | Riadok 86: | ||
<source lang="c++" style="background: LightYellow;"> | <source lang="c++" style="background: LightYellow;"> | ||
| − | // Premenna: Kod: Poznamka: | + | // Premenna: Kod: Poznamka: |
// Miesto v pamati Počet inštrukcií Veľkosť kódu Rýchlosť | // Miesto v pamati Počet inštrukcií Veľkosť kódu Rýchlosť | ||
| − | + | log_y = !log_x; // 1 Byte 5 instrukcii 14 Bytov 0,44 us | |
| − | int_y = int_x / 3; | + | int_y = int_x / 3; // 2 Byte 6 instrukcii + CALL 15,19 us - lebo na / uz nie je instrukcia |
| − | int_y = int_x / 2; | + | int_y = int_x / 2; // 2 Byte 9 instrukcii 26 Byte 0,81 us - lebo :2 sa da nahradit posunom vpravo >> |
| − | char_y = char_x / 3; | + | char_y = char_x / 3; // 1 Byte 4 instrukcie + CALL 5,38 us |
| − | long_y = long_x / 3; | + | long_y = long_x / 3; // 4 Byte 11 instrukcii + CALL / 39,37 us - lebo uz tahame a ukladame 4 bajty z pamati a do pamate |
| − | float_y = int_x / 3; | + | float_y = int_x / 3; // = ZLE = 13 instrukcii + 2xCALL! 16,88 us - tu je vysledok 0, lebo celociselne delenie len ulozime do premennej float |
| − | float_y = float_x / 3.0; // 4 Byte | + | float_y = float_x / 3.0; // 4 Byte 17 instrukcii + CALL / 30,81 us - volame podprogram pre floaty |
| − | double_y = double_x | + | double_y = double_x / 3.0; // 4 Byte 17 instrukcii + CALL / 30,93 us - to iste co float |
</source> | </source> | ||
| Riadok 102: | Riadok 102: | ||
'''Poznámky:''' | '''Poznámky:''' | ||
<references /> | <references /> | ||
| − | |||
| − | |||
== Potrebujem vo svojom programe pracovať s reálnymi číslami! == | == Potrebujem vo svojom programe pracovať s reálnymi číslami! == | ||
Verzia zo dňa a času 14:58, 13. máj 2021
Základné[1] typy premenných v avr-gcc
K dispozícii máme všetky bežné typy, ktoré sa používajú v jazyku C.
Veľkosť Rozsah
(signed) char 1 Byte (8 bitov) <−127, +127>
unsigned char 1 Byte (8 bitov) <0, 255>
signed int 2 Byty (16 bitov) <−32,767, +32,767>
unsigned int <0, 65,535>
signed long 4 Byty (32 bitov) <−2,147,483,647, +2,147,483,647>
unsigned long <0, 4,294,967,295>
float 4 Byty (32 bitov) IEEE-754 https://en.wikipedia.org/wiki/Single-precision_floating-point_format
double =float[2]
Okrem toho má programátor k dispozíci aj nové typy podľa štandardu C99, ktoré majú pevne definovanú veľkosť a tým pádom je zdrojový kód prenositeľnejší. Tieto typy nájdete v knižnici
<inttypes.h> a sú dostupné aj cez hlavičkový súbor (header) <stdint.h>.
int8_t 1 Byte (8 bitov) je to alias pre signed char
uint8_t 8-bit unsigned type
int16_t 2 Byty (16 bitov) = signed int / 16-bit signed type
uint16_t 16-bit unsigned type.
int32_t 4 Byty (32 bitov) 32-bit signed type
uint32_t 32-bit unsigned type
int64_t 8 Bytov (64 bitov) 64-bit signed type[3]
uint64_t 64-bit unsigned type
Okrem vyššieuvedených pridáva C99 aj typ bool definovaný v <stdbool.h> headri. Okrem toho sú tam aj makrá pre hodnoty true and false.
Má zmysel používať tento nový typ, keď aj tak zeberie 1 bajt podobne ako unsigned char? Rozdiel je vidieť v nasledovnom príklade. Používame v ňom aj deklaráciu volatile, aby nám pri pokusoch kompilátor nevyhodnotil tento kód ako nevyužitý a nevyhodil ho celkom z výsledného programu.
#include <stdbool.h>
volatile bool log_x;
volatile char char_x;
main(void)
{
log_x = 255; // obsahuje true
char_x = 255; // obsahuje 255, cize true
log_x = log_x + 1; // stale obsahuje true, pretoze 1+1 = 2 a to je nenulova hodnota, cize true
char_x = char_x + 1; // tu bude 0, cize false, pretoze 255+1=256, hodnota pretecie a dostaneme nulu, cize false
}
Poznámky:
- ↑ Zatiaľ vynechávame polia, smerníky a typy Enum, Union a pod.
- ↑ Anywhere the compiler sees "double", it says to itself, "Aha! The puny human said double. But I know better, so I'll replace it with float. Muwahahaha!"
- ↑ Note: This types are not available when the compiler option -mint8 is in effect.
Aritmetické operácie so základnými typmi
Pozrime sa podrobnejšie, aká je výpočtová náročnosť pre jednoduché aritmetické operácie. Ak by ste si to chceli vyskúšať, je potrebné deklarovať premenné ako volatile, inak kompilátor (vcelku rozumne) usúdi, že premenné, s ktorými nič nerobíme nie sú potrebné a z kódu ich vyhodí. V komentároch na každom riadku uvádzame okrem veľkosti premennej v pamäti aj na koľko inštrukcií sa preloží daný riadok a koľko bude trvať jeho vykonávanie. Nepočítali sme presne počet strojových cyklov, uspokojili sme sa s odčítaním času v simulátore. Hodnoty platia pre kryštál 16 MHz. Veľkosť kódu je len orientačná, tam kde sa volali špecifické podprogramy uvádzame CALL.
// Premenna: Kod: Poznamka:
// Miesto v pamati Počet inštrukcií Veľkosť kódu Rýchlosť
log_y = !log_x; // 1 Byte 5 instrukcii 14 Bytov 0,44 us
int_y = int_x + 3; // 2 Byte 5 instrukcii 18 Byte 0,63 us - 2 Byte vyber z pamati, scitaj (s vyhodou ADIW - Add immediate to word) a vrat do pamati
char_y = char_x + 3; // 1 Byte 3 instrukcie 10 Byte 0,31 us
long_y = long_x + 3; // 4 Byte 11 instrukcii 38 Byte 1,25 us - lebo tu uz tahame a ukladame 4 bajty z pamati a do pamate
float_y = float_x + 3; // 4 Byte 17 instrukcii + CALL 8,06 us - volame podprogram pre floaty
double_y = double_x + 3; // 4 Byte 17 instrukcii + CALL 8,06 us - toto je presne to iste ako float<ref>A</ref>
No a takto to vyzerá zasa s tými zložitejšími operáciami[1]
// Premenna: Kod: Poznamka:
// Miesto v pamati Počet inštrukcií Veľkosť kódu Rýchlosť
log_y = !log_x; // 1 Byte 5 instrukcii 14 Bytov 0,44 us
int_y = int_x / 3; // 2 Byte 6 instrukcii + CALL 15,19 us - lebo na / uz nie je instrukcia
int_y = int_x / 2; // 2 Byte 9 instrukcii 26 Byte 0,81 us - lebo :2 sa da nahradit posunom vpravo >>
char_y = char_x / 3; // 1 Byte 4 instrukcie + CALL 5,38 us
long_y = long_x / 3; // 4 Byte 11 instrukcii + CALL / 39,37 us - lebo uz tahame a ukladame 4 bajty z pamati a do pamate
float_y = int_x / 3; // = ZLE = 13 instrukcii + 2xCALL! 16,88 us - tu je vysledok 0, lebo celociselne delenie len ulozime do premennej float
float_y = float_x / 3.0; // 4 Byte 17 instrukcii + CALL / 30,81 us - volame podprogram pre floaty
double_y = double_x / 3.0; // 4 Byte 17 instrukcii + CALL / 30,93 us - to iste co float
Poznámky:
- ↑ BB