์ค๋๋ง์ ๋คํธ ๊ธ๋ก ๋์์๋ค. ์ ๊ณต ์์ ๊ณผ ๋ฐ์ ์ผ์ ์ค์ ํํํ ๊ธ์ ์จ๋ณด๋ ค๊ณ ๋ ธ๋ ฅ ์ค์ด์ง๋ง... ์ฐธ ์ฝ์ง ์๋ค ใ ใ ๊ทธ๋๋ ๊พธ์คํจ์ด ์ค์ํ ๊ฒ ์๋๊ฒ ๋๊ฐ! ์ทจ๋ฏธ๋ ๋ง์ฐฌ๊ฐ์ง๋ค!! ์ผ๋จ ์์ํ์ผ๋ฉด ๋์ ๋ด์ผ์ง!
<Data Type>

์ด๋ฒ์ <Numeric Type>, <String type> ์ด๋ผ๊ณ ๋ ํ๋ '๋ฐ์ดํฐ์ type' ์ ๋ํ ๋ด์ฉ์ด๋ค. ์์ Dart๋ ์ ์(integer)์ ์ค์(double)์ ์ง์ํ๋ค๊ณ ๋ฐฐ์ ๋ค. ๊ทธ๋ฆฌ๊ณ var/dynamic/object ํ์ ์ ์ฌ์ฉํด๋ ๋ณ์ ํ์ ์ ์ ์ฅ์ด ๊ฐ๋ฅํจ์ ์๊ณ ์๋ค. ๊ทธ๋ ๋ค๋ฉด, ๊ฐ ํ์ ์ง์ ์ ๋ฐ๋ผ ์ซ์๋ค์ ๊ณ์ฐ์ ์ด๋ป๊ฒ ํ๊ณ , ์ฌ์ฉ์ ์ด๋ป๊ฒ ํด์ผํ ๊น?? ๋ String type๊ณผ Boolean Type์ ๋ค๋ฅธ ์ธ์ด๋ค์ฒ๋ผ ์ฌ์ฉ์ด ๊ฐ๋ฅํ ๊น?
<์ซ์ํ ํ์ (Number Type)>
1. ์ ์ํ ๋ฐ์ดํฐ (Integer Type)
ํํ int ํ, integer ํ์ ์ด๋ผ๊ณ ๋ถ๋ฅด๋ ์ ์ํ ๋ฐ์ดํฐ๋ค์ Dart์์ 64bit ๋ณด๋ค ์๋๋ก ์ ํ๋๋ค. ios, android ๋ฑ ๋ค์ํ ํ๊ฒฝ์์ ์ง์ํ๋ ๋งํผ, int๋ -2^63 ~ 2^63 -1์ ๊ฐ์ ํํํ ์ ์๋ค. ๋ฐ๋ฉด์ web์์ ์๋ํ๋ javascript์์๋ intํ์ -2^53 ~ 2^53 - 1์ ๊ฐ์ ํํํ ์ ์๋ค.
2. ์ค์ํ ๋ฐ์ดํฐ (Double Type or Floating point)
๋ฐ๋ฉด ์ค์ํ ํ์ ์ IEEE 754 ๋ฐฉ์์ ์ง์ํ๋ฉฐ, 64bit์ ์ฒ๋ฆฌ๋ฅผ ํ๋ค. ์๋ก ์ ์ธ ์ด์ผ๊ธฐ๋ ํฌ๊ฒ ํ์ง ์๊ฒ ์ง๋ง, ํด๋น ๋ฐฉ์์ด ๊ถ๊ธํ๋ค๋ฉด ์๋ ์ค๋ช ๊ณผ ํจ๊ป ์ฐธ์กฐ ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ ๊ฒ.
์ฌ๊ธฐ์ IEEE ๋ฐฉ์์??

IEEE754 ๋ฐฉ์์ ์ ์์ ์์ ๋ถ๋ถ์ผ๋ก ๋๋ด๋ ๊ณ ์ ์์์ ๋ฐฉ์๊ณผ๋ ๋ค๋ฅด๊ฒ ์ง์ ๋นํธ์ ๊ฐ์ ๋นํธ๋ก ๋๋์ด์ง ์ํ์ ์ซ์๋ฅผ ์๋ฏธํ๋ค! ๋ค๋ฅธ ๋ง๋ก ์ ์์ ์์๋ฅผ ๋ํ๋ด๋ ๋นํธ๋ฅผ ์ฌ์ ์ ์ ํด ๋์ง ์๊ณ , ์ํฉ์ ๋ฐ๋ผ ๋ณ๊ฒฝ๋๋ ๋ถ๋ ์์์ (floating point)์ ๋งํ๋ค. ์ข ๋ ์ฝ๊ฒ ์ค๋ช ํ์๋ฉด, ์ง์ ๋นํธ์๋ '์์์ ์ ์์น'๋ฅผ ๊ธฐ๋กํ๊ณ ๊ฐ์ ๋นํธ์๋ '์ ์ ์ฒด์ ํํ'๋ฅผ ๊ธฐ๋กํ๋ ํํ.
IEEE 754์ ์์ ํํ ๋ฐฉ์ (Ex. 118.625)
- ์์๋ฅผ 2์ง์๋ก ๋ณํ (ex. 118 -> 11101101000...์ 2์ง์๋ก ๋ณํ, 0.625 -> 0.101)
- ์ ์ผ ์์ ์๋ 1 ๋ค๋ก ์์์ ์ ์ฎ๊ธฐ๊ณ , ์ฎ๊ธด ๋งํผ์ ์๋ฅผ ์ง์๋นํธ์ ๊ธฐ๋ก. (ex. 1.110..๋ก ์์์ ์ ์ฎ๊น.)
- ์ด๋๋ ์์์ ๋ค์ ๋ชจ๋ ์๋ฅผ ๊ฐ์ ๋นํธ์ ๊ธฐ๋ก.
์ด์ intํ๊ณผ double ํ์ ๋ํด ์์๋ค๋ฉด, ๊ฐ ๋ฐ์ดํฐ ํ์ ๋ณ ๊ณ์ฐ๋ ํด๋ด์ผ๊ฒ ๋ค.
3. ์ซ์ํ ๋ฐ์ดํฐ์ ๊ณ์ฐ
> ์์๋๋ก ๋ํ๊ธฐ(+), ๋นผ๊ธฐ(-), ๊ณฑํ๊ธฐ(*), ๋๋๊ธฐ(/), ๋ชซ(~/), ๋๋จธ์ง(%) ๋ฅผ ์๋ฏธํ๋ค.
> ๋ฐ๋ก type์ ์ง์ ํด์ฃผ์ง ์์๋ ์์ ์ฒซ ๋ฒ์งธ ๊ณ์ฐ ๊ฒฐ๊ณผ์ ๋ค๋ฅด์ง ์์ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋ ๊ฒ์ ์ ์ ์๋ค. ์ฌ๊ธฐ์ Dart๊ฐ ๊ฐ๋ ํน์ดํ ์ฐ์ฐ์๊ฐ ์๋๋ฐ, ๋ฐ๋ก '++' ์ฐ์ฐ์์ด๋ค! ์ฝ๋๋ฅผ ํตํด ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง ํ ๋ฒ ์์๋ณด์.
๋ณด๋ค์ํผ, ์ฒ์ ์ ์ธํ var1์ ๋ณ์ ์ ๋ค๋ก ++ ์ฐ์ฐ์๊ฐ ๋ถ์ ๊ฒ์ ์ ์ ์๋ค. ์ด๋ '++'์ฐ์ฐ์๊ฐ ๋ถ์ ๋ณ์์ ํฌ๊ธฐ๋ฅผ 1์ฉ ํค์์ฃผ๊ธฐ ์ํจ์ด๋ค. ๊ทธ๋ ๋ค๋ฉด ์๋ค์ ๋ถ์ด๋ ๊ฒ์ ๋ฐ๋ผ ๊ฐ๋ ๋ฌ๋ผ์ง๊น? ๋น์ฐํ๋ค.
## 1) ์์์ ๊ฒฝ์ฐ, '++'๊ฐ ๋ณ์๋ณด๋ค ์์ ์๋ค. ์ด๋ (++)๋ ๋ค๋ฅธ ์ฐ์ฐ์(+)๋ณด๋ค ๋จผ์ ์์ ์ ํ๋ค. ๊ทธ ๊ณผ์ ์ ์์๋๋ก ์ดํด๋ณด๋ฉด,
- var1์ ๊ฐ์ 1๋งํผ ์ฆ๊ฐ ์ํค๊ณ ,
- ์์ 1์ ๊ฒฐ๊ณผ์ 10์ ๋ํ ํ,
- ๋ํ ๊ฒฐ๊ณผ๋ฅผ var1์ ๋ค์ ์ ์ฅํ๋ค.
๋ฐ๋ผ์ var1์ด ๋ง์ฝ 1๋ก ์ด๊ธฐํ๋ ์ํ์์, 1)์ ์ํํ๋ฉด 2๊ฐ ๋๊ณ , 2)๋ฅผ ์ํํ๋ฉด ๋ค์ 12๋ก ์ฆ๊ฐํ๋ฉฐ, ์ด๋ฅผ 3)์์ var1์ ์ ์ฅํ๋ ๊ฒ์ ์ ์ ์๋ค.
๋น์ทํ ์์๋ก python์์๋ += ์ ๊ฐ์ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋๋ฐ, ํ ๋ฒ ๋ณด๊ณ ๋์ด๊ฐ๋ณด์.
# python ํน์ด ์ฐ์ฐ์ ํํ
# var1๊ณผ var2 ์ ํฉ์ var3(์๋ก์ด ๋ณ์)์ ํ ๋นํ ํํ
var1, var2 = 10, 15
var3 = var1 + var2
print(var3)
# > 25
# OR var1๊ณผ var2์ ํฉ์ ๋ค์ var1์ ํ ๋นํ ํํ
var1 += var2 ( ==> var1 = var1 + var2)
print(var1)
# > 25
# var1์ ํฌ๊ธฐ๋ฅผ 1 ๋๋ฆฌ๊ณ ์ถ๋ค๋ฉด?
var1 = 10
var1 += 1 # var1 = var1 + 1
print(var1)
# > 11
## 2) ์์์ ๊ฒฝ์ฐ, '++'๊ฐ ๋ณ์๋ณด๋ค ๋ค์ ์๋ค. '++' ์ฐ์ฐ์๊ฐ ๋ณ์ ๋ค์ ์๋ ๊ฒฝ์ฐ๋, ์์ ๋๋ฒ์งธ ๊ฒฝ์ฐ์ ๋ฐ๋๋ก ๋์ํ๋ค. ์ฆ, ๊ฐ์ ๋ผ์ธ์ ๋ค๋ฅธ ์ฐ์ฐ์(+)๋ค์ ๋จผ์ ์ํํ๊ณ , ๋์ค์ ++ ์ฐ์ฐ์ ํ๋ค.
- var1์ 10์ ๋ํ ํ,
- ๋ํ ๊ฐ์ var1์ ๋ค์ ์ ์ฅํ๊ณ ,
- ์ ์ฅ๋ ๊ฐ์ +1๋งํผ ์ฆ๊ฐ์ํจ๋ค.
๋ฐ๋ผ์ ์์ ์์ ๊ฐ์ ๊ฒฝ์ฐ, 1) var1์ ๊ฐ์ 10์ ๋ํ๋ฉด 12, 2) ์์ 1)์ ๊ฒฐ๊ณผ๋ฅผ var1์ ์ ์ฅํ ํ, 3) var1์ ๊ฐ์ 1๋งํผ ์ฆ๊ฐ์ํจ๋ค.
๊ทผ๋ฐ ์ต์ข ์ ์ผ๋ก 3)์ ๊ฑฐ์ณ์ var1์ ๊ฐ์ 1 ์ฆ๊ฐ์ํจ๋ค๋ฉด, 23์ด ์ถ๋ ฅ๋์ด์ผ ํ์ง ์๋๊ฐ?? ์ 22๊ฐ ์ถ๋ ฅ๋ ๊น? ๋ด๋ถ ๋ ผ๋ฆฌ ๊ณผ์ ์ ๋ค์ ํ ๋ฒ ๋ฏ์ด๋ณด์.
- var1์ ๊ฐ์ 12์ธ ์ํ. ( > ##1)์์ var1 ์ 12๋ก ์ ์ฅ๋ ์ํ)
- ## 2) ์ ์ฒซ ๋ฒ์งธ ๊ณผ์ ์ var1์ 10์ ๋ํ๊ณ , ๋ํ ๊ฐ์ธ 22๋ var1์ ์ ์ฅ๋๋ค.
- '=' ์ฐ์ฐ์๋ฅผ ํตํด ํ ๋น๋ var1์ ๊ฐ์ 22. (์ฆ ๋ฉ๋ชจ๋ฆฌ ๋ด๋ถ์ ์ผ๋ก๋ var1์ด ๊ฐ๋ฅดํค๋ ์ฃผ์์ ๋ด๋ถ๊ฐ์ด ์์ง 22์ ๊ฐ์ ์ ์ฅํ๊ณ ์๋ ๊ฒ.) ์ดํ var1์ ๋ค์ ๋ถ์ ++ ์ฐ์ฐ์๋ฅผ ํตํด 1์ ๋ํ๋ค.
- print()๊ตฌ๋ฌธ์ ํตํด ์ถ๋ ฅ๋๋ var1์ ์ด๋ฏธ ์ ์ฅ๋ 22์ ํํ๋ฅผ ๋๊ฒ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ๋ค์ ++ ์ฐ์ฐ์๋ฅผ ๊ตณ์ด ์ ๋ถ์ฌ๋ ๋๊ฒ ๋ค. ์์ ์์ 1) ์ฒ๋ผ ํด๋ ๋๊ณ , python์ฒ๋ผ '+=' ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด๋ ๋๋ค.


์ดํด๊ฐ ์ด๋ ต๋ค๋ฉด ํด๋น ์์ ์ฝ๋๋ฅผ ๋ด๋ ์ข๋ค! ์ฐธ๊ณ )
int a;
int b;
a = 0;
b = ++a; // Increment a before b gets its value.
assert(a == b); // 1 == 1
a = 0;
b = a++; // Increment a after b gets its value.
assert(a != b); // 1 != 0
a = 0;
b = --a; // Decrement a before b gets its value.
assert(a == b); // -1 == -1
a = 0;
b = a--; // Decrement a after b gets its value.
assert(a != b); // -1 != 0
๊ธฐํ ํ์ (String, Boolean) ๋ค์ ๋์ค์...
'Dart, Flutter > ๐ณ Basic' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Dart [๋ณ์ & ์์] (0) | 2023.12.23 |
---|---|
Dart [Hello World!] (0) | 2023.12.21 |
[Dart vs C++] ver2 (0) | 2023.12.19 |
[Dart vs C++] ver1 (1) | 2023.12.18 |
Dart ์์ํ๊ธฐ [์ค์น ํธ] (2) | 2023.12.18 |